Skip to content

Commit

Permalink
fix tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@rohenaz
rohenaz committed Mar 18, 2023
1 parent c80844b commit dc00367
Show file tree
Hide file tree
Showing 2 changed files with 39 additions and 171 deletions.
196 changes: 34 additions & 162 deletions bob.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,6 @@ import (
"fmt"
"strings"

"github.com/bitcoinschema/go-bob/util"
"github.com/bitcoinschema/go-bpu"
"github.com/libsv/go-bt/v2"
"github.com/libsv/go-bt/v2/bscript"
Expand Down Expand Up @@ -63,6 +62,9 @@ func NewFromString(line string) (bobTx *Tx, err error) {
func NewFromTx(tx *bt.Tx) (bobTx *Tx, err error) {
bobTx = new(Tx)
err = bobTx.FromTx(tx)
if err != nil {
return nil, err
}
return
}

Expand Down Expand Up @@ -181,171 +183,41 @@ func (t *Tx) FromString(line string) (err error) {
// FromTx takes a bt.Tx
func (t *Tx) FromTx(tx *bt.Tx) error {

// Set the transaction ID
t.Tx.H = tx.TxID()

// Set the inputs
for inIdx, i := range tx.Inputs {

cellHex := hex.EncodeToString(i.Bytes(false))
cellB64 := base64.RawStdEncoding.EncodeToString(i.Bytes(false))
cellStr := i.String()
txid := hex.EncodeToString(i.PreviousTxID())

bobInput := bpu.Input{
XPut: bpu.XPut{
I: uint8(inIdx),
Tape: []bpu.Tape{{
Cell: []bpu.Cell{{
H: &cellHex,
B: &cellB64,
S: &cellStr,
}},
I: 0,
}},
E: bpu.E{
H: &txid,
},
},
}

t.In = append(t.In, bobInput)
if tx == nil {
return fmt.Errorf("Tx must be set")
}

// Process outputs
for idxOut, o := range tx.Outputs {
var adr string

// Try to get a pub_key hash (ignore fail when this is not a locking script)
outPubKeyHash, _ := o.LockingScript.PublicKeyHash()
if len(outPubKeyHash) > 0 {
outAddress, err := bscript.NewAddressFromPublicKeyHash(outPubKeyHash, true)
if err != nil {
return fmt.Errorf("failed to get address from pubkeyhash %x: %w", outPubKeyHash, err)
}
adr = outAddress.AddressString
}

// Initialize out tapes and locking script asm
asm, err := o.LockingScript.ToASM()
if err != nil {
return err
}

pushDatas := strings.Split(asm, " ")

var outTapes []bpu.Tape
bobOutput := bpu.Output{
XPut: bpu.XPut{
I: uint8(idxOut),
Tape: outTapes,
E: bpu.E{
A: &adr,
},
var separator = "|"
var l = bpu.IncludeL
var opReturn = uint8(106)
var opFalse = uint8(0)
var splitConfig = []bpu.SplitConfig{
{
Token: &bpu.Token{
Op: &opReturn,
},
}

var opTape bpu.Tape
var currentTape bpu.Tape
var opOffset = 0
if len(pushDatas) > 0 {

// Check for OP_RETURN or OP_FALSE + OP_RETURN
// Look for OP_FALSE OP_RETURN or just OP_RETURN and separate into a cell collection
if len(pushDatas[0]) > 0 {
if pushDatas[0] == "OP_FALSE" || pushDatas[0] == "0" {
// OP_FALSE in position 0
var op = bscript.OpFALSE
var ops = "OP_FALSE"
opTape.Cell = append(opTape.Cell, bpu.Cell{
Op: &op,
Ops: &ops,
I: uint8(idxOut),
II: uint8(0),
})
opOffset++
// Check for OP_RETURN
if len(pushDatas[1]) > 0 && pushDatas[1] == "OP_RETURN" {
// OP_FALSE OP_RETURN
var op = bscript.OpRETURN
var ops = "OP_RETURN"
opTape.Cell = append(opTape.Cell, bpu.Cell{
Op: &op,
Ops: &ops,
I: uint8(idxOut),
II: uint8(1),
})
// pull them out into their own cell collection
outTapes = append(outTapes, opTape)
opOffset++

}
} else if len(pushDatas[0]) > 0 && pushDatas[0] == "OP_RETURN" {
var op = bscript.OpRETURN
var ops = "OP_RETURN"
opTape.Cell = append(opTape.Cell, bpu.Cell{
Op: &op,
Ops: &ops,
I: uint8(idxOut),
II: uint8(0),
})
opOffset++

// OP_RETURN in position 0
}
if opOffset > 0 {
outTapes = append(outTapes, opTape)
}
}
for pdIdx, pushData := range pushDatas {
if pdIdx < opOffset {
continue
}
// Ignore error if it fails, use empty
pushDataBytes, _ := hex.DecodeString(pushData)
b64String := base64.StdEncoding.EncodeToString(pushDataBytes)
var pushDataString = string(pushDataBytes)

// assume the pushdata is a chunk of
pushDataHex := pushData
var op uint8
var ops string
// asm is being put into the hex field - need to convert back to hex from opcodes if they exist in here
if pushDataByte, ok := util.OpCodeStrings[pushData]; ok {
// this pushdata is a valid opcode
pushDataHex = hex.EncodeToString([]byte{pushDataByte})
op = pushDataByte
ops = pushData
}
if pushData != ProtocolDelimiterAsm {
currentTape.Cell = append(currentTape.Cell, bpu.Cell{
Op: &op,
Ops: &ops,
B: &b64String,
H: &pushDataHex,
S: &pushDataString,
I: uint8(idxOut),
II: uint8(pdIdx - opOffset),
})
}
// Note: OP_SWAP is 0x7c which is also ascii "|" which is our protocol separator.
// This is not used as OP_SWAP at all since this is in the script after the OP_FALSE
// if "OP_RETURN" == pushData || ProtocolDelimiterAsm == pushData {
if ProtocolDelimiterAsm == pushData {
outTapes = append(outTapes, currentTape)
currentTape = bpu.Tape{}
opOffset = 0
}
}
}

// Add the trailing tape
outTapes = append(outTapes, currentTape)
bobOutput.Tape = outTapes

t.Out = append(t.Out, bobOutput)
Include: &l,
},
{
Token: &bpu.Token{
Op: &opFalse,
},
Include: &l,
},
{
Token: &bpu.Token{
S: &separator,
},
Require: &opReturn,
},
}

bpuTx, err := bpu.Parse(bpu.ParseConfig{Tx: tx, SplitConfig: splitConfig})
if err != nil {
return err
}
if bpuTx != nil {
t.BpuTx = *bpuTx
}
return nil
}

Expand Down
14 changes: 5 additions & 9 deletions bob_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -419,16 +419,12 @@ func BenchmarkNewFromTx(b *testing.B) {
}
}

// TestNewFromTxPanic tests for nil case in NewFromTx()
func TestNewFromTxPanic(t *testing.T) {
// TestNewFromTx2 tests for nil case in NewFromTx()
func TestNewFromTx2(t *testing.T) {
t.Parallel()

assert.Panics(t, func() {
b, err := NewFromTx(nil)
assert.NoError(t, err)
assert.NotNil(t, b)
_, _ = b.ToRawTxString()
})
b, err := NewFromTx(nil)
assert.Error(t, err)
assert.Nil(t, b)
}

// TestTx_ToTx tests for nil case in ToTx()
Expand Down

0 comments on commit dc00367

Please sign in to comment.