func TestOutputSplittingOversizeTx(t *testing.T) {
tearDown, pool, _ := TstCreatePoolAndTxStore(t)
defer tearDown()
requestAmount := coinutil.Amount(5)
bigInput := int64(3)
smallInput := int64(2)
request := TstNewOutputRequest(
t, 1, "34eVkREKgvvGASZW7hkgE2uNc1yycntMK6", requestAmount, pool.Manager().ChainParams())
seriesID, eligible := TstCreateCreditsOnNewSeries(t, pool, []int64{smallInput, bigInput})
changeStart := TstNewChangeAddress(t, pool, seriesID, 0)
w := newWithdrawal(0, []OutputRequest{request}, eligible, *changeStart)
w.txOptions = func(tx *withdrawalTx) {
tx.calculateFee = TstConstantFee(0)
tx.calculateSize = func() int {
// Trigger an output split right after the second input is added.
if len(tx.inputs) == 2 {
return txMaxSize + 1
}
return txMaxSize - 1
}
}
if err := w.fulfillRequests(); err != nil {
t.Fatal(err)
}
if len(w.transactions) != 2 {
t.Fatalf("Wrong number of finalized transactions; got %d, want 2", len(w.transactions))
}
tx1 := w.transactions[0]
if len(tx1.outputs) != 1 {
t.Fatalf("Wrong number of outputs on tx1; got %d, want 1", len(tx1.outputs))
}
if tx1.outputs[0].amount != coinutil.Amount(bigInput) {
t.Fatalf("Wrong amount for output in tx1; got %d, want %d", tx1.outputs[0].amount,
bigInput)
}
tx2 := w.transactions[1]
if len(tx2.outputs) != 1 {
t.Fatalf("Wrong number of outputs on tx2; got %d, want 1", len(tx2.outputs))
}
if tx2.outputs[0].amount != coinutil.Amount(smallInput) {
t.Fatalf("Wrong amount for output in tx2; got %d, want %d", tx2.outputs[0].amount,
smallInput)
}
if len(w.status.outputs) != 1 {
t.Fatalf("Wrong number of output statuses; got %d, want 1", len(w.status.outputs))
}
status := w.status.outputs[request.outBailmentID()].status
if status != statusSplit {
t.Fatalf("Wrong output status; got '%s', want '%s'", status, statusSplit)
}
}
func TestWithdrawalTxInputTotal(t *testing.T) {
tearDown, pool, _ := TstCreatePoolAndTxStore(t)
defer tearDown()
tx := createWithdrawalTx(t, pool, []int64{5}, []int64{})
if tx.inputTotal() != coinutil.Amount(5) {
t.Fatalf("Wrong total output; got %v, want %v", tx.outputTotal(), coinutil.Amount(5))
}
}
func TestWithdrawalTxOutputTotal(t *testing.T) {
tearDown, pool, _ := TstCreatePoolAndTxStore(t)
defer tearDown()
tx := createWithdrawalTx(t, pool, []int64{}, []int64{4})
tx.changeOutput = wire.NewTxOut(int64(1), []byte{})
if tx.outputTotal() != coinutil.Amount(4) {
t.Fatalf("Wrong total output; got %v, want %v", tx.outputTotal(), coinutil.Amount(4))
}
}
func TestStoreTransactionsWithChangeOutput(t *testing.T) {
tearDown, pool, store := TstCreatePoolAndTxStore(t)
defer tearDown()
wtx := createWithdrawalTxWithStoreCredits(t, store, pool, []int64{5e6}, []int64{1e6, 1e6})
wtx.changeOutput = wire.NewTxOut(int64(3e6), []byte{})
msgtx := wtx.toMsgTx()
tx := &changeAwareTx{MsgTx: msgtx, changeIdx: int32(len(msgtx.TxOut) - 1)}
if err := storeTransactions(store, []*changeAwareTx{tx}); err != nil {
t.Fatal(err)
}
sha := msgtx.TxSha()
txDetails, err := store.TxDetails(&sha)
if err != nil {
t.Fatal(err)
}
if txDetails == nil {
t.Fatal("The new tx doesn't seem to have been stored")
}
storedTx := txDetails.TxRecord.MsgTx
outputTotal := int64(0)
for i, txOut := range storedTx.TxOut {
if int32(i) != tx.changeIdx {
outputTotal += txOut.Value
}
}
if outputTotal != int64(2e6) {
t.Fatalf("Unexpected output amount; got %v, want %v", outputTotal, int64(2e6))
}
inputTotal := coinutil.Amount(0)
for _, debit := range txDetails.Debits {
inputTotal += debit.Amount
}
if inputTotal != coinutil.Amount(5e6) {
t.Fatalf("Unexpected input amount; got %v, want %v", inputTotal, coinutil.Amount(5e6))
}
credits, err := store.UnspentOutputs()
if err != nil {
t.Fatal(err)
}
if len(credits) != 1 {
t.Fatalf("Unexpected number of credits in txstore; got %d, want 1", len(credits))
}
changeOutpoint := wire.OutPoint{Hash: sha, Index: uint32(tx.changeIdx)}
if credits[0].OutPoint != changeOutpoint {
t.Fatalf("Credit's outpoint (%v) doesn't match the one from change output (%v)",
credits[0].OutPoint, changeOutpoint)
}
}
// TestRollbackLastOutputWhenNewOutputAdded checks that we roll back the last
// output if a tx becomes too big right after we add a new output to it.
func TestRollbackLastOutputWhenNewOutputAdded(t *testing.T) {
tearDown, pool, _ := TstCreatePoolAndTxStore(t)
defer tearDown()
net := pool.Manager().ChainParams()
series, eligible := TstCreateCreditsOnNewSeries(t, pool, []int64{5, 5})
requests := []OutputRequest{
// This is ordered by bailment ID
TstNewOutputRequest(t, 1, "34eVkREKgvvGASZW7hkgE2uNc1yycntMK6", 1, net),
TstNewOutputRequest(t, 2, "3PbExiaztsSYgh6zeMswC49hLUwhTQ86XG", 2, net),
}
changeStart := TstNewChangeAddress(t, pool, series, 0)
w := newWithdrawal(0, requests, eligible, *changeStart)
w.txOptions = func(tx *withdrawalTx) {
tx.calculateFee = TstConstantFee(0)
tx.calculateSize = func() int {
// Trigger an output split right after the second output is added.
if len(tx.outputs) > 1 {
return txMaxSize + 1
}
return txMaxSize - 1
}
}
if err := w.fulfillRequests(); err != nil {
t.Fatal("Unexpected error:", err)
}
// At this point we should have two finalized transactions.
if len(w.transactions) != 2 {
t.Fatalf("Wrong number of finalized transactions; got %d, want 2", len(w.transactions))
}
// First tx should have one output with 1 and one change output with 4
// satoshis.
firstTx := w.transactions[0]
req1 := requests[0]
checkTxOutputs(t, firstTx,
[]*withdrawalTxOut{&withdrawalTxOut{request: req1, amount: req1.Amount}})
checkTxChangeAmount(t, firstTx, coinutil.Amount(4))
// Second tx should have one output with 2 and one changeoutput with 3 satoshis.
secondTx := w.transactions[1]
req2 := requests[1]
checkTxOutputs(t, secondTx,
[]*withdrawalTxOut{&withdrawalTxOut{request: req2, amount: req2.Amount}})
checkTxChangeAmount(t, secondTx, coinutil.Amount(3))
}
func TestCreateTx(t *testing.T) {
bs := &waddrmgr.BlockStamp{Height: 11111}
mgr := newManager(t, txInfo.privKeys, bs)
account := uint32(0)
changeAddr, _ := coinutil.DecodeAddress("muqW4gcixv58tVbSKRC5q6CRKy8RmyLgZ5", &chaincfg.TestNet3Params)
var tstChangeAddress = func(account uint32) (coinutil.Address, error) {
return changeAddr, nil
}
// Pick all utxos from txInfo as eligible input.
eligible := mockCredits(t, txInfo.hex, []uint32{1, 2, 3, 4, 5})
// Now create a new TX sending 25e6 satoshis to the following addresses:
outputs := map[string]coinutil.Amount{outAddr1: 15e6, outAddr2: 10e6}
tx, err := createTx(eligible, outputs, bs, defaultFeeIncrement, mgr, account, tstChangeAddress, &chaincfg.TestNet3Params, false)
if err != nil {
t.Fatal(err)
}
if tx.ChangeAddr.String() != changeAddr.String() {
t.Fatalf("Unexpected change address; got %v, want %v",
tx.ChangeAddr.String(), changeAddr.String())
}
msgTx := tx.MsgTx
if len(msgTx.TxOut) != 3 {
t.Fatalf("Unexpected number of outputs; got %d, want 3", len(msgTx.TxOut))
}
// The outputs in our new TX amount to 25e6 satoshis, so to fulfil that
// createTx should have picked the utxos with indices 4, 3 and 5, which
// total 25.1e6.
if len(msgTx.TxIn) != 3 {
t.Fatalf("Unexpected number of inputs; got %d, want 3", len(msgTx.TxIn))
}
// Given the input (15e6 + 10e6 + 1e7) and requested output (15e6 + 10e6)
// amounts in the new TX, we should have a change output with 8.99e6, which
// implies a fee of 1e3 satoshis.
expectedChange := coinutil.Amount(8.999e6)
outputs[changeAddr.String()] = expectedChange
checkOutputsMatch(t, msgTx, outputs)
minFee := feeForSize(defaultFeeIncrement, msgTx.SerializeSize())
actualFee := coinutil.Amount(1e3)
if minFee > actualFee {
t.Fatalf("Requested fee (%v) for tx size higher than actual fee (%v)", minFee, actualFee)
}
}
func ExampleAmount() {
a := coinutil.Amount(0)
fmt.Println("Zero Satoshi:", a)
a = coinutil.Amount(1e8)
fmt.Println("100,000,000 Satoshis:", a)
a = coinutil.Amount(1e5)
fmt.Println("100,000 Satoshis:", a)
// Output:
// Zero Satoshi: 0 BTC
// 100,000,000 Satoshis: 1 BTC
// 100,000 Satoshis: 0.001 BTC
}
// Check that some requested outputs are not fulfilled when we don't have credits for all
// of them.
func TestFulfillRequestsNotEnoughCreditsForAllRequests(t *testing.T) {
tearDown, pool, _ := TstCreatePoolAndTxStore(t)
defer tearDown()
net := pool.Manager().ChainParams()
// Create eligible inputs and the list of outputs we need to fulfil.
seriesID, eligible := TstCreateCreditsOnNewSeries(t, pool, []int64{2e6, 4e6})
out1 := TstNewOutputRequest(
t, 1, "34eVkREKgvvGASZW7hkgE2uNc1yycntMK6", coinutil.Amount(3e6), net)
out2 := TstNewOutputRequest(
t, 2, "3PbExiaztsSYgh6zeMswC49hLUwhTQ86XG", coinutil.Amount(2e6), net)
out3 := TstNewOutputRequest(
t, 3, "3Qt1EaKRD9g9FeL2DGkLLswhK1AKmmXFSe", coinutil.Amount(5e6), net)
outputs := []OutputRequest{out1, out2, out3}
changeStart := TstNewChangeAddress(t, pool, seriesID, 0)
w := newWithdrawal(0, outputs, eligible, *changeStart)
if err := w.fulfillRequests(); err != nil {
t.Fatal(err)
}
tx := w.transactions[0]
// The created tx should spend both eligible credits, so we expect it to have
// an input amount of 2e6+4e6 satoshis.
inputAmount := eligible[0].Amount + eligible[1].Amount
// We expect it to include outputs for requests 1 and 2, plus a change output, but
// output request #3 should not be there because we don't have enough credits.
change := inputAmount - (out1.Amount + out2.Amount + tx.calculateFee())
expectedOutputs := []OutputRequest{out1, out2}
sort.Sort(byOutBailmentID(expectedOutputs))
expectedOutputs = append(
expectedOutputs, TstNewOutputRequest(t, 4, changeStart.addr.String(), change, net))
msgtx := tx.toMsgTx()
checkMsgTxOutputs(t, msgtx, expectedOutputs)
// withdrawal.status should state that outputs 1 and 2 were successfully fulfilled,
// and that output 3 was not.
expectedStatuses := map[OutBailmentID]outputStatus{
out1.outBailmentID(): statusSuccess,
out2.outBailmentID(): statusSuccess,
out3.outBailmentID(): statusPartial}
for _, wOutput := range w.status.outputs {
if wOutput.status != expectedStatuses[wOutput.request.outBailmentID()] {
t.Fatalf("Unexpected status for %v; got '%s', want '%s'", wOutput.request,
wOutput.status, expectedStatuses[wOutput.request.outBailmentID()])
}
}
}
func compareMsgTxAndWithdrawalTxOutputs(t *testing.T, msgtx *wire.MsgTx, tx *withdrawalTx) {
nOutputs := len(tx.outputs)
if tx.changeOutput != nil {
nOutputs++
}
if len(msgtx.TxOut) != nOutputs {
t.Fatalf("Unexpected number of TxOuts; got %d, want %d", len(msgtx.TxOut), nOutputs)
}
for i, output := range tx.outputs {
outputRequest := output.request
txOut := msgtx.TxOut[i]
if !bytes.Equal(txOut.PkScript, outputRequest.PkScript) {
t.Fatalf(
"Unexpected pkScript for outputRequest %d; got %x, want %x",
i, txOut.PkScript, outputRequest.PkScript)
}
gotAmount := coinutil.Amount(txOut.Value)
if gotAmount != outputRequest.Amount {
t.Fatalf(
"Unexpected amount for outputRequest %d; got %v, want %v",
i, gotAmount, outputRequest.Amount)
}
}
// Finally check the change output if it exists
if tx.changeOutput != nil {
msgTxChange := msgtx.TxOut[len(msgtx.TxOut)-1]
if msgTxChange != tx.changeOutput {
t.Fatalf("wrong TxOut in msgtx; got %v, want %v", msgTxChange, tx.changeOutput)
}
}
}
// mockCredits decodes the given txHex and returns the outputs with
// the given indices as eligible inputs.
func mockCredits(t *testing.T, txHex string, indices []uint32) []wtxmgr.Credit {
serialized, err := hex.DecodeString(txHex)
if err != nil {
t.Fatal(err)
}
utx, err := coinutil.NewTxFromBytes(serialized)
if err != nil {
t.Fatal(err)
}
tx := utx.MsgTx()
isCB := blockchain.IsCoinBaseTx(tx)
now := time.Now()
eligible := make([]wtxmgr.Credit, len(indices))
c := wtxmgr.Credit{
OutPoint: wire.OutPoint{Hash: *utx.Sha()},
BlockMeta: wtxmgr.BlockMeta{
Block: wtxmgr.Block{Height: -1},
},
}
for i, idx := range indices {
c.OutPoint.Index = idx
c.Amount = coinutil.Amount(tx.TxOut[idx].Value)
c.PkScript = tx.TxOut[idx].PkScript
c.Received = now
c.FromCoinBase = isCB
eligible[i] = c
}
return eligible
}
// TstCreateCreditsOnStore inserts a new credit in the given store for
// every item in the amounts slice.
func TstCreateCreditsOnStore(t *testing.T, s *wtxmgr.Store, pkScript []byte,
amounts []int64) []wtxmgr.Credit {
msgTx := createMsgTx(pkScript, amounts)
meta := &wtxmgr.BlockMeta{
Block: wtxmgr.Block{Height: TstInputsBlock},
}
rec, err := wtxmgr.NewTxRecordFromMsgTx(msgTx, time.Now())
if err != nil {
t.Fatal(err)
}
if err := s.InsertTx(rec, meta); err != nil {
t.Fatal("Failed to create inputs: ", err)
}
credits := make([]wtxmgr.Credit, len(msgTx.TxOut))
for i := range msgTx.TxOut {
if err := s.AddCredit(rec, meta, uint32(i), false); err != nil {
t.Fatal("Failed to create inputs: ", err)
}
credits[i] = wtxmgr.Credit{
OutPoint: wire.OutPoint{
Hash: rec.Hash,
Index: uint32(i),
},
BlockMeta: *meta,
Amount: coinutil.Amount(msgTx.TxOut[i].Value),
PkScript: msgTx.TxOut[i].PkScript,
}
}
return credits
}
func createAndFulfillWithdrawalRequests(t *testing.T, pool *Pool, roundID uint32) withdrawalInfo {
params := pool.Manager().ChainParams()
seriesID, eligible := TstCreateCreditsOnNewSeries(t, pool, []int64{2e6, 4e6})
requests := []OutputRequest{
TstNewOutputRequest(t, 1, "34eVkREKgvvGASZW7hkgE2uNc1yycntMK6", 3e6, params),
TstNewOutputRequest(t, 2, "3PbExiaztsSYgh6zeMswC49hLUwhTQ86XG", 2e6, params),
}
changeStart := TstNewChangeAddress(t, pool, seriesID, 0)
dustThreshold := coinutil.Amount(1e4)
startAddr := TstNewWithdrawalAddress(t, pool, seriesID, 1, 0)
lastSeriesID := seriesID
w := newWithdrawal(roundID, requests, eligible, *changeStart)
if err := w.fulfillRequests(); err != nil {
t.Fatal(err)
}
return withdrawalInfo{
requests: requests,
startAddress: *startAddr,
changeStart: *changeStart,
lastSeriesID: lastSeriesID,
dustThreshold: dustThreshold,
status: *w.status,
}
}
// Check that withdrawal.status correctly states that no outputs were fulfilled when we
// don't have enough eligible credits for any of them.
func TestFulfillRequestsNoSatisfiableOutputs(t *testing.T) {
tearDown, pool, _ := TstCreatePoolAndTxStore(t)
defer tearDown()
seriesID, eligible := TstCreateCreditsOnNewSeries(t, pool, []int64{1e6})
request := TstNewOutputRequest(
t, 1, "3Qt1EaKRD9g9FeL2DGkLLswhK1AKmmXFSe", coinutil.Amount(3e6), pool.Manager().ChainParams())
changeStart := TstNewChangeAddress(t, pool, seriesID, 0)
w := newWithdrawal(0, []OutputRequest{request}, eligible, *changeStart)
if err := w.fulfillRequests(); err != nil {
t.Fatal(err)
}
if len(w.transactions) != 0 {
t.Fatalf("Unexpected number of transactions; got %d, want 0", len(w.transactions))
}
if len(w.status.outputs) != 1 {
t.Fatalf("Unexpected number of outputs in WithdrawalStatus; got %d, want 1",
len(w.status.outputs))
}
status := w.status.outputs[request.outBailmentID()].status
if status != statusPartial {
t.Fatalf("Unexpected status for requested outputs; got '%s', want '%s'",
status, statusPartial)
}
}
// TstCreateSeriesCredits creates a new credit for every item in the amounts
// slice, locked to the given series' address with branch==1 and index==0.
func TstCreateSeriesCredits(t *testing.T, pool *Pool, seriesID uint32, amounts []int64) []credit {
addr := TstNewWithdrawalAddress(t, pool, seriesID, Branch(1), Index(0))
pkScript, err := txscript.PayToAddrScript(addr.addr)
if err != nil {
t.Fatal(err)
}
msgTx := createMsgTx(pkScript, amounts)
txSha := msgTx.TxSha()
credits := make([]credit, len(amounts))
for i := range msgTx.TxOut {
c := wtxmgr.Credit{
OutPoint: wire.OutPoint{
Hash: txSha,
Index: uint32(i),
},
BlockMeta: wtxmgr.BlockMeta{
Block: wtxmgr.Block{Height: TstInputsBlock},
},
Amount: coinutil.Amount(msgTx.TxOut[i].Value),
PkScript: msgTx.TxOut[i].PkScript,
}
credits[i] = newCredit(c, *addr)
}
return credits
}
func fetchRawUnminedCreditAmount(v []byte) (coinutil.Amount, error) {
if len(v) < 9 {
str := "short unmined credit value"
return 0, storeError(ErrData, str, nil)
}
return coinutil.Amount(byteOrder.Uint64(v)), nil
}
// TestOutputSplittingNotEnoughInputs checks that an output will get split if we
// don't have enough inputs to fulfil it.
func TestOutputSplittingNotEnoughInputs(t *testing.T) {
tearDown, pool, _ := TstCreatePoolAndTxStore(t)
defer tearDown()
net := pool.Manager().ChainParams()
output1Amount := coinutil.Amount(2)
output2Amount := coinutil.Amount(3)
requests := []OutputRequest{
// These output requests will have the same server ID, so we know
// they'll be fulfilled in the order they're defined here, which is
// important for this test.
TstNewOutputRequest(t, 1, "34eVkREKgvvGASZW7hkgE2uNc1yycntMK6", output1Amount, net),
TstNewOutputRequest(t, 2, "34eVkREKgvvGASZW7hkgE2uNc1yycntMK6", output2Amount, net),
}
seriesID, eligible := TstCreateCreditsOnNewSeries(t, pool, []int64{7})
w := newWithdrawal(0, requests, eligible, *TstNewChangeAddress(t, pool, seriesID, 0))
w.txOptions = func(tx *withdrawalTx) {
// Trigger an output split because of lack of inputs by forcing a high fee.
// If we just started with not enough inputs for the requested outputs,
// fulfillRequests() would drop outputs until we had enough.
tx.calculateFee = TstConstantFee(3)
}
if err := w.fulfillRequests(); err != nil {
t.Fatal(err)
}
if len(w.transactions) != 1 {
t.Fatalf("Wrong number of finalized transactions; got %d, want 1", len(w.transactions))
}
tx := w.transactions[0]
if len(tx.outputs) != 2 {
t.Fatalf("Wrong number of outputs; got %d, want 2", len(tx.outputs))
}
// The first output should've been left untouched.
if tx.outputs[0].amount != output1Amount {
t.Fatalf("Wrong amount for first tx output; got %v, want %v",
tx.outputs[0].amount, output1Amount)
}
// The last output should have had its amount updated to whatever we had
// left after satisfying all previous outputs.
newAmount := tx.inputTotal() - output1Amount - tx.calculateFee()
checkLastOutputWasSplit(t, w, tx, output2Amount, newAmount)
}
func TestFindingSpentCredits(t *testing.T) {
t.Parallel()
s, teardown, err := testStore()
defer teardown()
if err != nil {
t.Fatal(err)
}
// Insert transaction and credit which will be spent.
recvRec, err := NewTxRecord(TstRecvSerializedTx, time.Now())
if err != nil {
t.Fatal(err)
}
err = s.InsertTx(recvRec, TstRecvTxBlockDetails)
if err != nil {
t.Fatal(err)
}
err = s.AddCredit(recvRec, TstRecvTxBlockDetails, 0, false)
if err != nil {
t.Fatal(err)
}
// Insert confirmed transaction which spends the above credit.
spendingRec, err := NewTxRecord(TstSpendingSerializedTx, time.Now())
if err != nil {
t.Fatal(err)
}
err = s.InsertTx(spendingRec, TstSignedTxBlockDetails)
if err != nil {
t.Fatal(err)
}
err = s.AddCredit(spendingRec, TstSignedTxBlockDetails, 0, false)
if err != nil {
t.Fatal(err)
}
bal, err := s.Balance(1, TstSignedTxBlockDetails.Height)
if err != nil {
t.Fatal(err)
}
expectedBal := coinutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value)
if bal != expectedBal {
t.Fatalf("bad balance: %v != %v", bal, expectedBal)
}
unspents, err := s.UnspentOutputs()
if err != nil {
t.Fatal(err)
}
op := wire.NewOutPoint(TstSpendingTx.Sha(), 0)
if unspents[0].OutPoint != *op {
t.Fatal("unspent outpoint doesn't match expected")
}
if len(unspents) > 1 {
t.Fatal("has more than one unspent credit")
}
}
// fetchRawCreditAmountChange returns the amount of the credit and whether the
// credit is marked as change.
func fetchRawCreditAmountChange(v []byte) (coinutil.Amount, bool, error) {
if len(v) < 9 {
str := fmt.Sprintf("%s: short read (expected %d bytes, read %d)",
bucketCredits, 9, len(v))
return 0, false, storeError(ErrData, str, nil)
}
return coinutil.Amount(byteOrder.Uint64(v)), v[8]&(1<<1) != 0, nil
}
// maybeDropRequests will check the total amount we have in eligible inputs and drop
// requested outputs (in descending amount order) if we don't have enough to
// fulfill them all. For every dropped output request we update its entry in
// w.status.outputs with the status string set to statusPartial.
func (w *withdrawal) maybeDropRequests() {
inputAmount := coinutil.Amount(0)
for _, input := range w.eligibleInputs {
inputAmount += input.Amount
}
outputAmount := coinutil.Amount(0)
for _, request := range w.pendingRequests {
outputAmount += request.Amount
}
sort.Sort(sort.Reverse(byAmount(w.pendingRequests)))
for inputAmount < outputAmount {
request := w.popRequest()
log.Infof("Not fulfilling request to send %v to %v; not enough credits.",
request.Amount, request.Address)
outputAmount -= request.Amount
w.status.outputs[request.outBailmentID()].status = statusPartial
}
}
// newWithdrawalTx creates a new withdrawalTx and calls setOptions()
// passing the newly created tx.
func newWithdrawalTx(setOptions func(tx *withdrawalTx)) *withdrawalTx {
tx := &withdrawalTx{}
tx.calculateSize = func() int { return calculateTxSize(tx) }
tx.calculateFee = func() coinutil.Amount {
return coinutil.Amount(1+tx.calculateSize()/1000) * feeIncrement
}
setOptions(tx)
return tx
}
func fetchMinedBalance(ns walletdb.Bucket) (coinutil.Amount, error) {
v := ns.Get(rootMinedBalance)
if len(v) != 8 {
str := fmt.Sprintf("balance: short read (expected 8 bytes, "+
"read %v)", len(v))
return 0, storeError(ErrData, str, nil)
}
return coinutil.Amount(byteOrder.Uint64(v)), nil
}
func fetchRawUnminedCreditAmountChange(v []byte) (coinutil.Amount, bool, error) {
if len(v) < 9 {
str := "short unmined credit value"
return 0, false, storeError(ErrData, str, nil)
}
amt := coinutil.Amount(byteOrder.Uint64(v))
change := v[8]&(1<<1) != 0
return amt, change, nil
}
func (s *Store) addCredit(ns walletdb.Bucket, rec *TxRecord, block *BlockMeta, index uint32, change bool) error {
if block == nil {
k := canonicalOutPoint(&rec.Hash, index)
v := valueUnminedCredit(coinutil.Amount(rec.MsgTx.TxOut[index].Value), change)
return putRawUnminedCredit(ns, k, v)
}
k, v := existsCredit(ns, &rec.Hash, index, &block.Block)
if v != nil {
return nil
}
txOutAmt := coinutil.Amount(rec.MsgTx.TxOut[index].Value)
log.Debugf("Marking transaction %v output %d (%v) spendable",
rec.Hash, index, txOutAmt)
cred := credit{
outPoint: wire.OutPoint{
Hash: rec.Hash,
Index: index,
},
block: block.Block,
amount: txOutAmt,
change: change,
spentBy: indexedIncidence{index: ^uint32(0)},
}
v = valueUnspentCredit(&cred)
err := putRawCredit(ns, k, v)
if err != nil {
return err
}
minedBalance, err := fetchMinedBalance(ns)
if err != nil {
return err
}
err = putMinedBalance(ns, minedBalance+txOutAmt)
if err != nil {
return err
}
return putUnspent(ns, &cred.outPoint, &block.Block)
}
// TestRollBackLastOutputInsufficientOutputs checks that
// rollBackLastOutput returns an error if there are less than two
// outputs in the transaction.
func TestRollBackLastOutputInsufficientOutputs(t *testing.T) {
tx := newWithdrawalTx(defaultTxOptions)
_, _, err := tx.rollBackLastOutput()
TstCheckError(t, "", err, ErrPreconditionNotMet)
output := &WithdrawalOutput{request: TstNewOutputRequest(
t, 1, "34eVkREKgvvGASZW7hkgE2uNc1yycntMK6", coinutil.Amount(3), &chaincfg.MainNetParams)}
tx.addOutput(output.request)
_, _, err = tx.rollBackLastOutput()
TstCheckError(t, "", err, ErrPreconditionNotMet)
}
// spendRawCredit marks the credit with a given key as mined at some particular
// block as spent by the input at some transaction incidence. The debited
// amount is returned.
func spendCredit(ns walletdb.Bucket, k []byte, spender *indexedIncidence) (coinutil.Amount, error) {
v := ns.Bucket(bucketCredits).Get(k)
newv := make([]byte, 81)
copy(newv, v)
v = newv
v[8] |= 1 << 0
copy(v[9:41], spender.txHash[:])
byteOrder.PutUint32(v[41:45], uint32(spender.block.Height))
copy(v[45:77], spender.block.Hash[:])
byteOrder.PutUint32(v[77:81], spender.index)
return coinutil.Amount(byteOrder.Uint64(v[0:8])), putRawCredit(ns, k, v)
}
func TestTxFeeEstimationForSmallTx(t *testing.T) {
tx := newWithdrawalTx(defaultTxOptions)
// A tx that is smaller than 1000 bytes in size should have a fee of 10000
// satoshis.
tx.calculateSize = func() int { return 999 }
fee := tx.calculateFee()
wantFee := coinutil.Amount(1e3)
if fee != wantFee {
t.Fatalf("Unexpected tx fee; got %v, want %v", fee, wantFee)
}
}
func TestTxFeeEstimationForLargeTx(t *testing.T) {
tx := newWithdrawalTx(defaultTxOptions)
// A tx that is larger than 1000 bytes in size should have a fee of 1e3
// satoshis plus 1e3 for every 1000 bytes.
tx.calculateSize = func() int { return 3000 }
fee := tx.calculateFee()
wantFee := coinutil.Amount(4e3)
if fee != wantFee {
t.Fatalf("Unexpected tx fee; got %v, want %v", fee, wantFee)
}
}
// createWithdrawalTx creates a withdrawalTx with the given input and output amounts.
func createWithdrawalTx(t *testing.T, pool *Pool, inputAmounts []int64, outputAmounts []int64) *withdrawalTx {
net := pool.Manager().ChainParams()
tx := newWithdrawalTx(defaultTxOptions)
_, credits := TstCreateCreditsOnNewSeries(t, pool, inputAmounts)
for _, c := range credits {
tx.addInput(c)
}
for i, amount := range outputAmounts {
request := TstNewOutputRequest(
t, uint32(i), "34eVkREKgvvGASZW7hkgE2uNc1yycntMK6", coinutil.Amount(amount), net)
tx.addOutput(request)
}
return tx
}
// finalizeCurrentTx finalizes the transaction in w.current, moves it to the
// list of finalized transactions and replaces w.current with a new empty
// transaction.
func (w *withdrawal) finalizeCurrentTx() error {
log.Debug("Finalizing current transaction")
tx := w.current
if len(tx.outputs) == 0 {
log.Debug("Current transaction has no outputs, doing nothing")
return nil
}
pkScript, err := txscript.PayToAddrScript(w.status.nextChangeAddr.addr)
if err != nil {
return newError(ErrWithdrawalProcessing, "failed to generate pkScript for change address", err)
}
if tx.addChange(pkScript) {
var err error
w.status.nextChangeAddr, err = nextChangeAddress(w.status.nextChangeAddr)
if err != nil {
return newError(ErrWithdrawalProcessing, "failed to get next change address", err)
}
}
ntxid := tx.ntxid()
for i, txOut := range tx.outputs {
outputStatus := w.status.outputs[txOut.request.outBailmentID()]
outputStatus.addOutpoint(
OutBailmentOutpoint{ntxid: ntxid, index: uint32(i), amount: txOut.amount})
}
// Check that WithdrawalOutput entries with status==success have the sum of
// their outpoint amounts matching the requested amount.
for _, txOut := range tx.outputs {
// Look up the original request we received because txOut.request may
// represent a split request and thus have a different amount from the
// original one.
outputStatus := w.status.outputs[txOut.request.outBailmentID()]
origRequest := outputStatus.request
amtFulfilled := coinutil.Amount(0)
for _, outpoint := range outputStatus.outpoints {
amtFulfilled += outpoint.amount
}
if outputStatus.status == statusSuccess && amtFulfilled != origRequest.Amount {
msg := fmt.Sprintf("%s was not completely fulfilled; only %v fulfilled", origRequest,
amtFulfilled)
return newError(ErrWithdrawalProcessing, msg, nil)
}
}
w.transactions = append(w.transactions, tx)
w.current = newWithdrawalTx(w.txOptions)
return nil
}
func (it *debitIterator) readElem() error {
if len(it.ck) < 72 {
str := fmt.Sprintf("%s: short key (expected %d bytes, read %d)",
bucketDebits, 72, len(it.ck))
return storeError(ErrData, str, nil)
}
if len(it.cv) < 80 {
str := fmt.Sprintf("%s: short read (expected %d bytes, read %d)",
bucketDebits, 80, len(it.cv))
return storeError(ErrData, str, nil)
}
it.elem.Index = byteOrder.Uint32(it.ck[68:72])
it.elem.Amount = coinutil.Amount(byteOrder.Uint64(it.cv))
return nil
}
