467 lines
16 KiB
Go
467 lines
16 KiB
Go
package wallet_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math/big"
|
|
"slices"
|
|
"testing"
|
|
|
|
"github.com/btcsuite/btcd/btcutil/base58"
|
|
"github.com/cosmos/go-bip39"
|
|
"github.com/phamminh0811/private-grpc/crypto"
|
|
"github.com/phamminh0811/private-grpc/nockchain"
|
|
"github.com/phamminh0811/private-grpc/wallet"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
// The entropy, salt and result is taken from "nockchain-wallet keygen" command
|
|
func TestKeyGen(t *testing.T) {
|
|
entropyBigInt, isOk := new(big.Int).SetString("29615235796517918707367078072007441124337225858809749976291970867443501879006", 10)
|
|
assert.True(t, isOk)
|
|
|
|
entropy := entropyBigInt.Bytes()
|
|
assert.Len(t, entropy, 32)
|
|
|
|
saltBigInt, isOk := new(big.Int).SetString("212311808188922973323281316240858086116", 10)
|
|
assert.True(t, isOk)
|
|
|
|
salt := saltBigInt.Bytes()
|
|
assert.Len(t, salt, 16)
|
|
|
|
argonBytes := crypto.DeriveKey(0, entropy[:], salt[:], nil, nil, 6, 786432, 4, 32)
|
|
slices.Reverse(argonBytes)
|
|
mnemonic, err := bip39.NewMnemonic(argonBytes)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, mnemonic, "brass vacuum stairs hurt brisk govern describe enforce fly exact rescue capable belt flavor lottery sauce easy frame orange legal injury border obey novel")
|
|
|
|
masterKey, err := crypto.MasterKeyFromSeed(mnemonic)
|
|
assert.NoError(t, err)
|
|
|
|
assert.Equal(t,
|
|
base58.Encode(masterKey.PublicKey),
|
|
"39DL6YA1kSRCKMjzpFEtC8rmnxVuseUrP2LnViwY7YEhZYZkX2HmnAZ63Uwy1DwuXstmF1VeJDucg719xw49j9CKL3bsKq3A6SZN918CowcgQroHsgohj7dYgpGRWk41s42F",
|
|
)
|
|
assert.Equal(t,
|
|
base58.Encode(masterKey.PrivateKey),
|
|
"4SyUrsbGKPRknzvGakWmFbYefzHzb1r4LUmJpQD8WPcR",
|
|
)
|
|
assert.Equal(t,
|
|
base58.Encode(masterKey.ChainCode),
|
|
"58SARPmADHvUcpq7XfBoCgwzy5QC8Kb3JrezpHqA85x2",
|
|
)
|
|
|
|
// assert import priv/pubkey
|
|
privBytes := append([]byte{0x00}, masterKey.PrivateKey...)
|
|
importPrivKey := crypto.SerializeExtend(masterKey.ChainCode, privBytes, crypto.PrivateKeyStart)
|
|
assert.Len(t, importPrivKey, 82)
|
|
importPubKey := crypto.SerializeExtend(masterKey.ChainCode, masterKey.PublicKey, crypto.PublicKeyStart)
|
|
assert.Len(t, importPubKey, 145)
|
|
|
|
assert.Equal(t,
|
|
base58.Encode(importPrivKey),
|
|
"zprv2CyrSHEkzQzu4HCtJRFiP4t2rVMauZwLfJDFrNbqS8Pz3nsmXy5bAUx2HYUykaMuU4MiQTHsDcKYjLCjrPfpceNT9XBHgx1pUjKzBrF6Wdo",
|
|
)
|
|
assert.Equal(t,
|
|
base58.Encode(importPubKey),
|
|
"zpubUQwNTNE3hsCkMpBnD37W5QirkyVryokAVPLnPin1c6M13RRsq3yEJbwp5ies6qXF6DvJq5Woxw6ygT53PSVrmrsQgtHhbfMEixKNFm7qb4mELhpyoovpFEV1YPHFZx4xQGYBNF6qvXU6AHNh4TLrUdkYAdXKS2J5rPiSVPrXKGo8fLG6ZBCGBjJfPcwDb2VEJC",
|
|
)
|
|
}
|
|
|
|
func TestImportKey(t *testing.T) {
|
|
type Input struct {
|
|
req *nockchain.ImportKeysRequest
|
|
expectResp *nockchain.ImportKeysResponse
|
|
isErr bool
|
|
errStr string
|
|
}
|
|
|
|
correctImportPrivKey := base58.Decode("zprv2CyrSHEkzQzu4HCtJRFiP4t2rVMauZwLfJDFrNbqS8Pz3nsmXy5bAUx2HYUykaMuU4MiQTHsDcKYjLCjrPfpceNT9XBHgx1pUjKzBrF6Wdo")
|
|
invalidImportPrivKeyPrefix := make([]byte, 82)
|
|
copy(invalidImportPrivKeyPrefix[:], correctImportPrivKey)
|
|
invalidImportPrivKeyPrefix[45] = 0x01
|
|
|
|
invalidImportPrivKeyChecksum := make([]byte, 82)
|
|
copy(invalidImportPrivKeyChecksum[:], correctImportPrivKey)
|
|
copy(invalidImportPrivKeyChecksum[78:], []byte{1, 2, 3, 4})
|
|
|
|
correctImportPubkey := base58.Decode("zpubUQwNTNE3hsCkMpBnD37W5QirkyVryokAVPLnPin1c6M13RRsq3yEJbwp5ies6qXF6DvJq5Woxw6ygT53PSVrmrsQgtHhbfMEixKNFm7qb4mELhpyoovpFEV1YPHFZx4xQGYBNF6qvXU6AHNh4TLrUdkYAdXKS2J5rPiSVPrXKGo8fLG6ZBCGBjJfPcwDb2VEJC")
|
|
invalidImportPubkeyChecksum := make([]byte, 145)
|
|
copy(invalidImportPubkeyChecksum[:], correctImportPubkey)
|
|
copy(invalidImportPubkeyChecksum[141:], []byte{1, 2, 3, 4})
|
|
|
|
response := &nockchain.ImportKeysResponse{
|
|
PublicKey: "39DL6YA1kSRCKMjzpFEtC8rmnxVuseUrP2LnViwY7YEhZYZkX2HmnAZ63Uwy1DwuXstmF1VeJDucg719xw49j9CKL3bsKq3A6SZN918CowcgQroHsgohj7dYgpGRWk41s42F",
|
|
PrivateKey: "4SyUrsbGKPRknzvGakWmFbYefzHzb1r4LUmJpQD8WPcR",
|
|
ChainCode: "58SARPmADHvUcpq7XfBoCgwzy5QC8Kb3JrezpHqA85x2",
|
|
ImportPrivateKey: base58.Encode(correctImportPrivKey),
|
|
ImportPublicKey: base58.Encode(correctImportPubkey),
|
|
}
|
|
|
|
responseReadOnly := &nockchain.ImportKeysResponse{
|
|
PublicKey: "39DL6YA1kSRCKMjzpFEtC8rmnxVuseUrP2LnViwY7YEhZYZkX2HmnAZ63Uwy1DwuXstmF1VeJDucg719xw49j9CKL3bsKq3A6SZN918CowcgQroHsgohj7dYgpGRWk41s42F",
|
|
PrivateKey: "",
|
|
ChainCode: "58SARPmADHvUcpq7XfBoCgwzy5QC8Kb3JrezpHqA85x2",
|
|
ImportPrivateKey: "",
|
|
ImportPublicKey: base58.Encode(correctImportPubkey),
|
|
}
|
|
inputs := []Input{
|
|
// case invalid type
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: "",
|
|
ImportType: nockchain.ImportType_UNDEFINED,
|
|
},
|
|
expectResp: nil,
|
|
isErr: true,
|
|
errStr: "invalid import type",
|
|
},
|
|
// case invalid extended key
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: "some wrong string",
|
|
ImportType: nockchain.ImportType_EXTENDED_KEY,
|
|
},
|
|
expectResp: nil,
|
|
isErr: true,
|
|
errStr: "invalid extended key",
|
|
},
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: "zprv wrong priv import key length",
|
|
ImportType: nockchain.ImportType_EXTENDED_KEY,
|
|
},
|
|
expectResp: nil,
|
|
isErr: true,
|
|
errStr: "invalid extended private key length",
|
|
},
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: base58.Encode(invalidImportPrivKeyPrefix),
|
|
ImportType: nockchain.ImportType_EXTENDED_KEY,
|
|
},
|
|
expectResp: nil,
|
|
isErr: true,
|
|
errStr: "invalid private key prefix at byte 45",
|
|
},
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: base58.Encode(invalidImportPrivKeyChecksum),
|
|
ImportType: nockchain.ImportType_EXTENDED_KEY,
|
|
},
|
|
expectResp: nil,
|
|
isErr: true,
|
|
errStr: "invalid checksum",
|
|
},
|
|
// case success import priv key
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: base58.Encode(correctImportPrivKey),
|
|
ImportType: nockchain.ImportType_EXTENDED_KEY,
|
|
},
|
|
expectResp: response,
|
|
isErr: false,
|
|
errStr: "",
|
|
},
|
|
// case invalid import pub key
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: "zpub wrong public import key length",
|
|
ImportType: nockchain.ImportType_EXTENDED_KEY,
|
|
},
|
|
expectResp: nil,
|
|
isErr: true,
|
|
errStr: "invalid extended public key length",
|
|
},
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: base58.Encode(invalidImportPubkeyChecksum),
|
|
ImportType: nockchain.ImportType_EXTENDED_KEY,
|
|
},
|
|
expectResp: nil,
|
|
isErr: true,
|
|
errStr: "invalid checksum",
|
|
},
|
|
// case success import pub key
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: base58.Encode(correctImportPubkey),
|
|
ImportType: nockchain.ImportType_EXTENDED_KEY,
|
|
},
|
|
expectResp: responseReadOnly,
|
|
isErr: false,
|
|
errStr: "",
|
|
},
|
|
// case missing chaincode when import master privkey
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: "4SyUrsbGKPRknzvGakWmFbYefzHzb1r4LUmJpQD8WPcR",
|
|
ImportType: nockchain.ImportType_MASTER_PRIVKEY,
|
|
},
|
|
expectResp: nil,
|
|
isErr: true,
|
|
errStr: "master key must be in [chain_code],[key] format",
|
|
},
|
|
// case invalid length
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: "abcdxyz,4SyUrsbGKPRknzvGakWmFbYefzHzb1r4LUmJpQD8WPcR",
|
|
ImportType: nockchain.ImportType_MASTER_PRIVKEY,
|
|
},
|
|
expectResp: nil,
|
|
isErr: true,
|
|
errStr: "invalid chain code length",
|
|
},
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: "58SARPmADHvUcpq7XfBoCgwzy5QC8Kb3JrezpHqA85x2,abcdxyz",
|
|
ImportType: nockchain.ImportType_MASTER_PRIVKEY,
|
|
},
|
|
expectResp: nil,
|
|
isErr: true,
|
|
errStr: "invalid priv key length",
|
|
},
|
|
// case success import master privkey
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: "58SARPmADHvUcpq7XfBoCgwzy5QC8Kb3JrezpHqA85x2,4SyUrsbGKPRknzvGakWmFbYefzHzb1r4LUmJpQD8WPcR",
|
|
ImportType: nockchain.ImportType_MASTER_PRIVKEY,
|
|
},
|
|
expectResp: response,
|
|
isErr: false,
|
|
errStr: "",
|
|
},
|
|
// case success import seed
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: "brass vacuum stairs hurt brisk govern describe enforce fly exact rescue capable belt flavor lottery sauce easy frame orange legal injury border obey novel",
|
|
ImportType: nockchain.ImportType_SEEDPHRASE,
|
|
},
|
|
expectResp: response,
|
|
isErr: false,
|
|
errStr: "",
|
|
},
|
|
// case sucess import pubkey
|
|
{
|
|
req: &nockchain.ImportKeysRequest{
|
|
Key: "39DL6YA1kSRCKMjzpFEtC8rmnxVuseUrP2LnViwY7YEhZYZkX2HmnAZ63Uwy1DwuXstmF1VeJDucg719xw49j9CKL3bsKq3A6SZN918CowcgQroHsgohj7dYgpGRWk41s42F",
|
|
ImportType: nockchain.ImportType_WATCH_ONLY,
|
|
},
|
|
expectResp: &nockchain.ImportKeysResponse{
|
|
PublicKey: "39DL6YA1kSRCKMjzpFEtC8rmnxVuseUrP2LnViwY7YEhZYZkX2HmnAZ63Uwy1DwuXstmF1VeJDucg719xw49j9CKL3bsKq3A6SZN918CowcgQroHsgohj7dYgpGRWk41s42F",
|
|
},
|
|
isErr: false,
|
|
errStr: "",
|
|
},
|
|
}
|
|
|
|
for _, input := range inputs {
|
|
nc, err := wallet.NewNockchainClient("nockchain-api.zorp.io:443")
|
|
assert.NoError(t, err)
|
|
|
|
handler := wallet.NewGprcHandler(*nc)
|
|
|
|
resp, err := handler.ImportKeys(context.Background(), input.req)
|
|
if input.isErr {
|
|
assert.ErrorContains(t, err, input.errStr)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, resp, input.expectResp)
|
|
}
|
|
}
|
|
}
|
|
|
|
// This test should be run with timeout 120s
|
|
func TestScan(t *testing.T) {
|
|
// some random seed we take to get empty notes
|
|
seed1 := "foster chicken claw fade income frown junior abandon price lesson mango wrap dry clay loyal camera caught during property useless puppy royal soccer arm"
|
|
seed2 := "brass vacuum stairs hurt brisk govern describe enforce fly exact rescue capable belt flavor lottery sauce easy frame orange legal injury border obey novel"
|
|
|
|
masterKey1, err := crypto.MasterKeyFromSeed(seed1)
|
|
assert.NoError(t, err)
|
|
|
|
nc, err := wallet.NewNockchainClient("nockchain-api.zorp.io:443")
|
|
assert.NoError(t, err)
|
|
|
|
masterKey1Scan, err := nc.WalletGetBalance(base58.Encode(masterKey1.PublicKey))
|
|
assert.NoError(t, err)
|
|
assert.Empty(t, masterKey1Scan.Notes)
|
|
|
|
masterKey2, err := crypto.MasterKeyFromSeed(seed2)
|
|
assert.NoError(t, err)
|
|
|
|
masterKey2Scan, err := nc.WalletGetBalance(base58.Encode(masterKey2.PublicKey))
|
|
assert.NoError(t, err)
|
|
assert.Len(t, masterKey2Scan.Notes, 1)
|
|
assert.Equal(t, masterKey2Scan.Notes[0].Note.Assets.Value, uint64(100000))
|
|
assert.Equal(t, masterKey2Scan.Notes[0].Note.OriginPage.Value, uint64(35054))
|
|
}
|
|
|
|
// This test should be run with timeout 120s
|
|
func TestFullFlow(t *testing.T) {
|
|
mnemonic1 := "rail nurse smile angle uphold gun kitten spoon quick frozen trigger cable decorate episode blame tray off bag arena taxi approve breeze job letter"
|
|
masterKey1, err := crypto.MasterKeyFromSeed(mnemonic1)
|
|
assert.NoError(t, err)
|
|
|
|
mnemonic2 := "brass vacuum stairs hurt brisk govern describe enforce fly exact rescue capable belt flavor lottery sauce easy frame orange legal injury border obey novel"
|
|
masterKey2, err := crypto.MasterKeyFromSeed(mnemonic2)
|
|
assert.NoError(t, err)
|
|
|
|
inputName := "[4taoqkpysafnp64WBQyzHDKVrqkMeNrdAiVSbWdzZmj7yQYZgQtCq4W 9cjUFbdtaFHeXNWCAKjsTphBchHmCoUU6a1aDbJAFz9qHqeG8osh4wF]"
|
|
|
|
nc, err := wallet.NewNockchainClient("nockchain-api.zorp.io:443")
|
|
assert.NoError(t, err)
|
|
|
|
masterKeyScan, err := nc.WalletGetBalance(base58.Encode(masterKey1.PublicKey))
|
|
assert.NoError(t, err)
|
|
|
|
var note *nockchain.NockchainNote
|
|
for _, balanceEntry := range masterKeyScan.Notes {
|
|
firstName := crypto.Tip5HashToBase58([5]uint64{
|
|
balanceEntry.Name.First.Belt_1.Value,
|
|
balanceEntry.Name.First.Belt_2.Value,
|
|
balanceEntry.Name.First.Belt_3.Value,
|
|
balanceEntry.Name.First.Belt_4.Value,
|
|
balanceEntry.Name.First.Belt_5.Value,
|
|
})
|
|
lastName := crypto.Tip5HashToBase58([5]uint64{
|
|
balanceEntry.Name.Last.Belt_1.Value,
|
|
balanceEntry.Name.Last.Belt_2.Value,
|
|
balanceEntry.Name.Last.Belt_3.Value,
|
|
balanceEntry.Name.Last.Belt_4.Value,
|
|
balanceEntry.Name.Last.Belt_5.Value,
|
|
})
|
|
nname := "[" + firstName + " " + lastName + "]"
|
|
if nname == inputName {
|
|
nnote := wallet.ParseBalanceEntry(balanceEntry)
|
|
note = &nnote
|
|
break
|
|
}
|
|
}
|
|
assert.NotNil(t, note)
|
|
|
|
parentHash, err := wallet.HashNote(note)
|
|
assert.NoError(t, err)
|
|
|
|
gift := uint64(100000)
|
|
seed1 := &nockchain.NockchainSeed{
|
|
OutputSource: nil,
|
|
Recipient: &nockchain.NockchainLock{
|
|
KeysRequired: 1,
|
|
Pubkeys: []string{base58.Encode(masterKey2.PublicKey)},
|
|
},
|
|
TimelockIntent: nil,
|
|
Gift: gift,
|
|
ParentHash: crypto.Tip5HashToBase58(parentHash),
|
|
}
|
|
|
|
gift = note.Asset - gift - 100
|
|
seed2 := &nockchain.NockchainSeed{
|
|
OutputSource: nil,
|
|
Recipient: &nockchain.NockchainLock{
|
|
KeysRequired: 1,
|
|
Pubkeys: []string{base58.Encode(masterKey1.PublicKey)},
|
|
},
|
|
TimelockIntent: nil,
|
|
Gift: gift,
|
|
ParentHash: crypto.Tip5HashToBase58(parentHash),
|
|
}
|
|
|
|
spend := nockchain.NockchainSpend{
|
|
Signatures: nil,
|
|
Seeds: []*nockchain.NockchainSeed{
|
|
seed1, seed2,
|
|
},
|
|
Fee: 100,
|
|
}
|
|
|
|
msg, err := wallet.HashMsg(&spend)
|
|
assert.NoError(t, err)
|
|
|
|
chalT8, sigT8, err := wallet.ComputeSig(*masterKey1, msg)
|
|
assert.NoError(t, err)
|
|
|
|
spend.Signatures = []*nockchain.NockchainSignature{
|
|
{
|
|
Pubkey: base58.Encode(masterKey1.PublicKey),
|
|
Chal: chalT8[:],
|
|
Sig: sigT8[:],
|
|
},
|
|
}
|
|
|
|
input := nockchain.NockchainInput{
|
|
Name: &nockchain.NockchainName{
|
|
First: "4taoqkpysafnp64WBQyzHDKVrqkMeNrdAiVSbWdzZmj7yQYZgQtCq4W",
|
|
Last: "9cjUFbdtaFHeXNWCAKjsTphBchHmCoUU6a1aDbJAFz9qHqeG8osh4wF",
|
|
},
|
|
Note: note,
|
|
Spend: &spend,
|
|
}
|
|
|
|
id, err := wallet.ComputeTxId([]*nockchain.NockchainInput{&input}, &nockchain.TimelockRange{
|
|
Min: nil,
|
|
Max: nil,
|
|
}, 100)
|
|
assert.NoError(t, err)
|
|
|
|
rawTx := nockchain.RawTx{
|
|
TxId: crypto.Tip5HashToBase58(id),
|
|
Inputs: []*nockchain.NockchainInput{&input},
|
|
TimelockRange: &nockchain.TimelockRange{
|
|
Min: nil,
|
|
Max: nil,
|
|
},
|
|
TotalFees: 100,
|
|
}
|
|
resp, err := nc.WalletSendTransaction(&rawTx)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, resp.Result, &nockchain.WalletSendTransactionResponse_Ack{
|
|
Ack: &nockchain.Acknowledged{},
|
|
})
|
|
|
|
txAcceptedResp, err := nc.TxAccepted(rawTx.TxId)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, txAcceptedResp.Result, &nockchain.TransactionAcceptedResponse_Accepted{
|
|
Accepted: true,
|
|
})
|
|
}
|
|
|
|
// This test should be run with timeout 300s
|
|
func TestCreateTx(t *testing.T) {
|
|
seed1 := "pledge vessel toilet sunny hockey skirt spend wire disorder attitude crumble lecture problem bundle bone rather address over suit ancient primary gospel silent repair"
|
|
masterKey1, err := crypto.MasterKeyFromSeed(seed1)
|
|
assert.NoError(t, err)
|
|
|
|
seed2 := "brass vacuum stairs hurt brisk govern describe enforce fly exact rescue capable belt flavor lottery sauce easy frame orange legal injury border obey novel"
|
|
masterKey2, err := crypto.MasterKeyFromSeed(seed2)
|
|
assert.NoError(t, err)
|
|
|
|
nc, err := wallet.NewNockchainClient("nockchain-api.zorp.io:443")
|
|
assert.NoError(t, err)
|
|
handler := wallet.NewGprcHandler(*nc)
|
|
|
|
inputs := "[CxiTK4HjqPRebUkoy6rH89ZcNGuH4goHkmKgmgCJxZEFS2C3qrDoh4y 91z5muQKgHZDcChdnCSTEtvuN8dbbXp5wzNs5xrCkce2YvSX1q6fu3d],[CxiTK4HjqPRebUkoy6rH89ZcNGuH4goHkmKgmgCJxZEFS2C3qrDoh4y 3a9VWigUM1TuS79yM4dAqkiUg6WJMUPGwVKJpQUHCLJcFZsCWM2q6pF],[CxiTK4HjqPRebUkoy6rH89ZcNGuH4goHkmKgmgCJxZEFS2C3qrDoh4y 9RkPvHMtuYtjV2qvB86u7zcnr26SdVcKzFnHgfhUSEG1W3FgKgLpbBm]"
|
|
recipients := fmt.Sprintf("%s,%s,%s", base58.Encode(masterKey2.PublicKey), base58.Encode(masterKey2.PublicKey), base58.Encode(masterKey2.PublicKey))
|
|
gifts := "100,100,100"
|
|
fee := 100
|
|
|
|
req := &nockchain.CreateTxRequest{
|
|
Names: inputs,
|
|
Recipients: recipients,
|
|
Gifts: gifts,
|
|
Fee: uint64(fee),
|
|
IsMasterKey: true,
|
|
Key: base58.Encode(masterKey1.PrivateKey),
|
|
ChainCode: base58.Encode(masterKey1.ChainCode),
|
|
Index: 0,
|
|
Hardened: false,
|
|
TimelockIntent: nil,
|
|
}
|
|
|
|
res, err := handler.CreateTx(context.Background(), req)
|
|
assert.NoError(t, err)
|
|
|
|
// the result is taken from create-tx scripts
|
|
assert.Equal(t, res.RawTx.TxId, "8gjTa6H1MrKXPWgNJCF9fsYE7PUfqhYzxetUoTftz7zyHCv24ZYHDM3")
|
|
}
|