diff --git a/client/asset/btc/btc.go b/client/asset/btc/btc.go
index 0544e66bd5..595a54a7b6 100644
--- a/client/asset/btc/btc.go
+++ b/client/asset/btc/btc.go
@@ -8,6 +8,7 @@ import (
"context"
"crypto/sha256"
"encoding/binary"
+ "encoding/hex"
"encoding/json"
"errors"
"fmt"
@@ -4421,6 +4422,11 @@ func (btc *baseWallet) RegFeeConfirmations(_ context.Context, id dex.Bytes) (con
return
}
+// BondConfirmations gets the numer of confirmations since the creation of a bond.
+func (btc *baseWallet) BondConfirmations(_ context.Context, id dex.Bytes) (confs uint32, err error) {
+ return btc.RegFeeConfirmations(context.Background(), id)
+}
+
func (btc *baseWallet) checkPeers() {
numPeers, err := btc.node.peerCount()
if err != nil {
@@ -4972,8 +4978,11 @@ func (btc *baseWallet) MakeBondTx(ver uint16, amt, feeRate uint64, lockTime time
bondInfo := &asset.BondTxInfo{
AccountID: acctID,
- LockTime: uint64(lockTimeSec),
- BondID: pkh,
+ Bond: &asset.BondInfo{
+ ID: hex.EncodeToString(pkh),
+ Amount: amt,
+ LockTime: uint64(lockTimeSec),
+ },
}
btc.addTxToHistory(asset.CreateBond, txid, amt, fee, bondInfo, nil, false)
@@ -5091,9 +5100,13 @@ func (btc *baseWallet) RefundBond(ctx context.Context, ver uint16, coinID, scrip
fees = amt - uint64(msgTx.TxOut[0].Value)
}
bondInfo := &asset.BondTxInfo{
- LockTime: uint64(lockTime),
- BondID: pkhPush,
+ Bond: &asset.BondInfo{
+ ID: hex.EncodeToString(pkhPush),
+ Amount: amt,
+ LockTime: uint64(lockTime),
+ },
}
+
btc.addTxToHistory(asset.RedeemBond, txID, amt, fees, bondInfo, nil, true)
return NewOutput(txHash, 0, uint64(msgTx.TxOut[0].Value)), nil
}
diff --git a/client/asset/dcr/dcr.go b/client/asset/dcr/dcr.go
index 8713fb3e19..ba741b27c7 100644
--- a/client/asset/dcr/dcr.go
+++ b/client/asset/dcr/dcr.go
@@ -4237,9 +4237,11 @@ func (dcr *ExchangeWallet) MakeBondTx(ver uint16, amt, feeRate uint64, lockTime
success = true
bondInfo := &asset.BondTxInfo{
- AccountID: acctID,
- LockTime: uint64(lockTimeSec),
- BondID: pkh,
+ Bond: &asset.BondInfo{
+ ID: hex.EncodeToString(pkh),
+ Amount: amt,
+ LockTime: uint64(lockTimeSec),
+ },
}
dcr.addTxToHistory(asset.CreateBond, txHash, amt, fee, bondInfo, nil, false)
txIDToRemoveFromHistory = txHash
@@ -4332,13 +4334,16 @@ func (dcr *ExchangeWallet) RefundBond(ctx context.Context, ver uint16, coinID, s
return nil, translateRPCCancelErr(err)
}
- refundAmt := msgTx.TxOut[0].Value
+ fees := amt - uint64(msgTx.TxOut[0].Value)
bondInfo := &asset.BondTxInfo{
- LockTime: uint64(lockTime),
- BondID: pkhPush,
+ Bond: &asset.BondInfo{
+ ID: hex.EncodeToString(pkhPush),
+ Amount: amt,
+ LockTime: uint64(lockTime),
+ },
}
- dcr.addTxToHistory(asset.RedeemBond, txHash, amt, amt-uint64(refundAmt), bondInfo, nil, true)
- return newOutput(redeemHash, 0, uint64(refundAmt), wire.TxTreeRegular), nil
+ dcr.addTxToHistory(asset.RedeemBond, txHash, amt, fees, bondInfo, nil, true)
+ return newOutput(redeemHash, 0, uint64(msgTx.TxOut[0].Value), wire.TxTreeRegular), nil
/* If we need to find the actual unspent bond transaction for any of:
(1) the output amount, (2) the commitment output data, or (3) to ensure
@@ -4521,6 +4526,11 @@ func (dcr *ExchangeWallet) TransactionConfirmations(ctx context.Context, txID st
return uint32(tx.Confirmations), nil
}
+// BondConfirmations gets the numer of confirmations since the creation of a bond.
+func (dcr *ExchangeWallet) BondConfirmations(ctx context.Context, coinID dex.Bytes) (confs uint32, err error) {
+ return dcr.RegFeeConfirmations(ctx, coinID)
+}
+
// RegFeeConfirmations gets the number of confirmations for the specified
// output.
func (dcr *ExchangeWallet) RegFeeConfirmations(ctx context.Context, coinID dex.Bytes) (confs uint32, err error) {
diff --git a/client/asset/eth/eth.go b/client/asset/eth/eth.go
index 5bac46c57d..83637a8497 100644
--- a/client/asset/eth/eth.go
+++ b/client/asset/eth/eth.go
@@ -31,7 +31,9 @@ import (
"decred.org/dcrdex/dex/keygen"
"decred.org/dcrdex/dex/networks/erc20"
dexeth "decred.org/dcrdex/dex/networks/eth"
+ v0Bond "decred.org/dcrdex/dex/networks/eth/bondcontracts/v0"
multibal "decred.org/dcrdex/dex/networks/eth/contracts/multibalance"
+ "github.com/decred/dcrd/dcrec/secp256k1/v4"
"github.com/decred/dcrd/dcrec/secp256k1/v4/ecdsa"
"github.com/decred/dcrd/hdkeychain/v3"
"github.com/ethereum/go-ethereum"
@@ -270,6 +272,12 @@ func (d *Driver) DecodeCoinID(coinID []byte) (string, error) {
return "", err
}
return c.String(), nil
+ case bondCoinSize:
+ c, err := decodeBondCoin(coinID)
+ if err != nil {
+ return "", err
+ }
+ return c.String(), nil
case common.AddressLength * 2, common.AddressLength*2 + 2:
hexAddr := string(coinID)
if !common.IsHexAddress(hexAddr) {
@@ -383,6 +391,7 @@ var _ asset.Authenticator = (*ETHWallet)(nil)
var _ asset.TokenApprover = (*TokenWallet)(nil)
var _ asset.WalletHistorian = (*ETHWallet)(nil)
var _ asset.WalletHistorian = (*TokenWallet)(nil)
+var _ asset.BondUpdater = (*ETHWallet)(nil)
type baseWallet struct {
// The asset subsystem starts with Connect(ctx). This ctx will be initialized
@@ -461,6 +470,11 @@ type assetWallet struct {
refundReserves uint64
}
+ maintainingBondReserves atomic.Bool
+
+ ethBond *v0Bond.ETHBond
+ bondAddress common.Address
+
findRedemptionMtx sync.RWMutex
findRedemptionReqs map[[32]byte]*findRedemptionRequest
@@ -832,6 +846,18 @@ func (w *ETHWallet) Connect(ctx context.Context) (_ *sync.WaitGroup, err error)
}
}
+ bondAddress, found := dexeth.ETHBondAddress[w.net]
+ if !found {
+ return nil, fmt.Errorf("no bond address for network %s", w.net)
+ }
+
+ ethBond, err := v0Bond.NewETHBond(bondAddress, w.node.contractBackend())
+ if err != nil {
+ return nil, err
+ }
+ w.ethBond = ethBond
+ w.bondAddress = bondAddress
+
w.txDB, err = newBadgerTxDB(filepath.Join(w.dir, "tx.db"), w.log.SubLogger("TXDB"))
if err != nil {
return nil, err
@@ -1152,7 +1178,7 @@ func (w *assetWallet) fundReserveOfType(t fundReserveType) *uint64 {
// lockFunds locks funds for a use case.
func (w *assetWallet) lockFunds(amt uint64, t fundReserveType) error {
- balance, err := w.balance()
+ balance, err := w.balanceWithoutBondReserves()
if err != nil {
return err
}
@@ -1195,11 +1221,12 @@ func (w *assetWallet) amountLocked() uint64 {
// Balance returns the available and locked funds (token or eth).
func (w *assetWallet) Balance() (*asset.Balance, error) {
- return w.balance()
+ return w.balanceWithBondReserves()
}
-// balance returns the total available funds in the account.
-func (w *assetWallet) balance() (*asset.Balance, error) {
+// balanceWithoutBondReserves returns the total available funds in the account
+// without accounting for bond reserves.
+func (w *assetWallet) balanceWithoutBondReserves() (*asset.Balance, error) {
bal, err := w.balanceWithTxPool()
if err != nil {
return nil, fmt.Errorf("pending balance error: %w", err)
@@ -1215,9 +1242,33 @@ func (w *assetWallet) balance() (*asset.Balance, error) {
Available: available,
Locked: locked,
Immature: w.atomize(bal.PendingIn),
+ Other: make(map[asset.BalanceCategory]asset.CustomBalance),
}, nil
}
+// balanceWithBondReserves returns the total available funds in the account
+// accounting for bond reserves.
+func (w *assetWallet) balanceWithBondReserves() (*asset.Balance, error) {
+ bal, err := w.balanceWithoutBondReserves()
+ if err != nil {
+ return nil, err
+ }
+
+ reserves := w.bondReserves()
+
+ if reserves > bal.Available {
+ w.log.Warnf("Available balance insufficient for bond reserves: %f < %f", bal.Available, reserves)
+ bal.ReservesDeficit = reserves - bal.Available
+ reserves = bal.Available
+ }
+
+ bal.BondReserves = reserves
+ bal.Available -= reserves
+ bal.Locked += reserves
+
+ return bal, nil
+}
+
// MaxOrder generates information about the maximum order size and associated
// fees that the wallet can support for the given DEX configuration. The fees are an
// estimate based on current network conditions, and will be <= the fees
@@ -1968,7 +2019,7 @@ func (w *ETHWallet) Swap(swaps *asset.Swaps) ([]asset.Receipt, asset.Coin, uint6
}
txHash := tx.Hash()
- w.addToTxHistory(tx.Nonce(), swapVal, swaps.FeeRate*gasLimit, w.assetID, txHash, asset.Swap, nil)
+ w.addToTxHistory(tx.Nonce(), swapVal, swaps.FeeRate*gasLimit, w.assetID, txHash, asset.Swap, nil, nil)
receipts := make([]asset.Receipt, 0, n)
for _, swap := range swaps.Contracts {
@@ -2059,7 +2110,7 @@ func (w *TokenWallet) Swap(swaps *asset.Swaps) ([]asset.Receipt, asset.Coin, uin
contractAddr := w.netToken.SwapContracts[swaps.Version].Address.String()
txHash := tx.Hash()
- w.addToTxHistory(tx.Nonce(), swapVal, swaps.FeeRate*gasLimit, w.assetID, txHash, asset.Swap, nil)
+ w.addToTxHistory(tx.Nonce(), swapVal, swaps.FeeRate*gasLimit, w.assetID, txHash, asset.Swap, nil, nil)
receipts := make([]asset.Receipt, 0, n)
for _, swap := range swaps.Contracts {
@@ -2232,7 +2283,7 @@ func (w *assetWallet) Redeem(form *asset.RedeemForm, feeWallet *assetWallet, non
}
txHash := tx.Hash()
- w.addToTxHistory(tx.Nonce(), redeemedValue, gasFeeCap*gasLimit, w.assetID, txHash, asset.Redeem, nil)
+ w.addToTxHistory(tx.Nonce(), redeemedValue, gasFeeCap*gasLimit, w.assetID, txHash, asset.Redeem, nil, nil)
txs := make([]dex.Bytes, len(form.Redemptions))
for i := range txs {
@@ -2313,7 +2364,7 @@ func (w *assetWallet) approveToken(amount *big.Int, maxFeeRate, gasLimit uint64,
if amount.Cmp(big.NewInt(0)) == 0 {
txType = asset.RevokeTokenApproval
}
- w.addToTxHistory(tx.Nonce(), 0, maxFeeRate*gasLimit, w.assetID, txHash, txType, nil)
+ w.addToTxHistory(tx.Nonce(), 0, maxFeeRate*gasLimit, w.assetID, txHash, txType, nil, nil)
return nil
})
@@ -2383,7 +2434,7 @@ func (w *TokenWallet) ApproveToken(assetVer uint32, onConfirm func()) (string, e
return "", fmt.Errorf("error calculating approval gas: %w", err)
}
- ethBal, err := w.parent.balance()
+ ethBal, err := w.parent.Balance()
if err != nil {
return "", fmt.Errorf("error getting eth balance: %w", err)
}
@@ -2433,7 +2484,7 @@ func (w *TokenWallet) UnapproveToken(assetVer uint32, onConfirm func()) (string,
return "", fmt.Errorf("error calculating approval gas: %w", err)
}
- ethBal, err := w.parent.balance()
+ ethBal, err := w.parent.Balance()
if err != nil {
return "", fmt.Errorf("error getting eth balance: %w", err)
}
@@ -2896,7 +2947,7 @@ func (w *assetWallet) Refund(_, contract dex.Bytes, feeRate uint64) (dex.Bytes,
txHash := tx.Hash()
refundValue := dexeth.WeiToGwei(swap.Value)
- w.addToTxHistory(tx.Nonce(), refundValue, fees, w.assetID, txHash, asset.Refund, nil)
+ w.addToTxHistory(tx.Nonce(), refundValue, fees, w.assetID, txHash, asset.Refund, nil, nil)
return txHash[:], nil
}
@@ -2928,14 +2979,265 @@ func (eth *ETHWallet) Locked() bool {
return eth.node.locked()
}
-// SendTransaction broadcasts a valid fully-signed transaction.
-func (eth *baseWallet) SendTransaction(rawTx []byte) ([]byte, error) {
+func txIsSigned(tx *types.Transaction) bool {
+ if tx == nil {
+ return false
+ }
+
+ v, r, s := tx.RawSignatureValues()
+ // If all three values are zero, the transaction is not signed.
+ return !((v == nil || v.Cmp(big.NewInt(0)) == 0) &&
+ (r == nil || r.Cmp(big.NewInt(0)) == 0) &&
+ (s == nil || s.Cmp(big.NewInt(0)) == 0))
+}
+
+func (w *assetWallet) bondTxInfo(tx *types.Transaction) (asset.TransactionType, *asset.BondTxInfo) {
+ newBondTxInfo := func(accountID, bondID [32]byte, lockTime uint64) *asset.BondTxInfo {
+ return &asset.BondTxInfo{
+ AccountID: accountID[:],
+ Bond: &asset.BondInfo{
+ ID: hex.EncodeToString(bondID[:]),
+ Amount: w.atomize(tx.Value()),
+ LockTime: lockTime,
+ },
+ }
+ }
+
+ updateBondTxInfo := func(accountID [32]byte, bondsToUpdate, newBondIDs [][32]byte, value *big.Int, locktime uint64) *asset.BondTxInfo {
+ replacedBonds := make([]*asset.BondInfo, len(bondsToUpdate))
+ var totalReplacedBondValue uint64
+ var changeBondLockTime uint64
+ for i, bondID := range bondsToUpdate {
+ bondData, err := w.ethBond.BondData(&bind.CallOpts{Context: w.ctx, From: w.addr}, accountID, bondID)
+ if err != nil {
+ w.log.Errorf("updateBondTxToInfo: failed to get bond data: %v", err)
+ continue
+ }
+ replacedBonds[i] = &asset.BondInfo{
+ ID: hex.EncodeToString(bondID[:]),
+ Amount: w.atomize(bondData.Value),
+ LockTime: bondData.Locktime,
+ }
+ totalReplacedBondValue += w.atomize(bondData.Value)
+ if changeBondLockTime == 0 || bondData.Locktime < changeBondLockTime {
+ changeBondLockTime = bondData.Locktime
+ }
+ }
+
+ var newBondID string
+ if len(newBondIDs) == 2 {
+ newBondID = hex.EncodeToString(newBondIDs[1][:])
+ } else {
+ newBondID = hex.EncodeToString(newBondIDs[0][:])
+ }
+ newBondValue := w.atomize(value)
+ newBond := &asset.BondInfo{
+ ID: newBondID,
+ Amount: newBondValue,
+ LockTime: locktime,
+ }
+
+ var changeBond *asset.BondInfo
+ if len(newBondIDs) == 2 {
+ changeBond = &asset.BondInfo{
+ ID: hex.EncodeToString(newBondIDs[0][:]),
+ Amount: totalReplacedBondValue - newBondValue,
+ LockTime: changeBondLockTime,
+ }
+ }
+
+ return &asset.BondTxInfo{
+ AccountID: accountID[:],
+ Bond: newBond,
+ ChangeBond: changeBond,
+ ReplacedBonds: replacedBonds,
+ }
+ }
+
+ accountID, bondID, lockTime, err := dexeth.ParseCreateBondTx(tx.Data())
+ if err == nil {
+ return asset.CreateBond, newBondTxInfo(accountID, bondID, lockTime)
+ }
+
+ accountID, bondsToUpdate, newBondIDs, value, locktime, err := dexeth.ParseUpdateBondsTx(tx.Data())
+ if err == nil {
+ return asset.UpdateBond, updateBondTxInfo(accountID, bondsToUpdate, newBondIDs, value, locktime)
+ }
+
+ // This is checked in the sendUnsignedBondTransaction, so this should never happen
+ w.log.Errorf("bondTxToInfo: failed to parse bond tx data: %v", err)
+ return asset.Unknown, nil
+}
+
+// sendBondTxWithNewNonceAndGasFee resubmits a bond transaction with the gas
+// fee provided and a new nonce. The transaction is placed into monitoredTxs
+// with the key being the hash of the unsigned nonce-less transaction.
+func (w *assetWallet) sendBondTxWithNewNonceAndGasFee(tx *types.Transaction, gasFeeCap *big.Int) (common.Hash, error) {
+ w.nonceSendMtx.Lock()
+ defer w.nonceSendMtx.Unlock()
+
+ txOpts, err := w.node.txOpts(w.ctx, dexeth.WeiToGwei(tx.Value()), tx.Gas(), gasFeeCap, nil)
+ if err != nil {
+ return common.Hash{}, err
+ }
+ sentTx, err := w.node.sendTransaction(w.ctx, txOpts, *tx.To(), tx.Data())
+ if err != nil {
+ if mRPC, is := w.node.(*multiRPCClient); is {
+ mRPC.voidUnusedNonce()
+ }
+ return common.Hash{}, err
+ }
+
+ txHash := sentTx.Hash()
+ fees := dexeth.WeiToGwei(sentTx.GasPrice()) * sentTx.Gas()
+ bondAmount := dexeth.WeiToGwei(sentTx.Value())
+
+ txType, bondTxInfo := w.bondTxInfo(tx)
+ w.addToTxHistory(txOpts.Nonce.Uint64(), bondAmount, fees, w.assetID, txHash, txType, bondTxInfo, nil)
+
+ w.tipMtx.RLock()
+ tip := w.currentTip
+ w.tipMtx.RUnlock()
+
+ w.monitoredTxs[tx.Hash()] = &monitoredTx{
+ tx: sentTx,
+ blockSubmitted: tip.Number.Uint64(),
+ removeAfterConfirms: 3,
+ timeSubmitted: time.Now(),
+ }
+
+ return txHash, nil
+}
+
+// sendUnsignedBondTransaction takes an unsigned bond creation transaction,
+// adds a nonce, and submits it to the network. If the transaction has already
+// been submitted (it is found in in monitoredTxs, then the transaction is not
+// resubmitted unless it has been overridden by another transaction with the
+// same nonce or the base gas fee has increased and the transaction cannot be
+// mined at the current max fee rate.
+func (w *assetWallet) sendUnsignedBondTransaction(tx *types.Transaction) ([]byte, error) {
+ _, _, _, newBondErr := dexeth.ParseCreateBondTx(tx.Data())
+ if newBondErr != nil {
+ _, _, _, _, _, updateBondErr := dexeth.ParseUpdateBondsTx(tx.Data())
+ if updateBondErr != nil {
+ return nil, fmt.Errorf("non-bond creation transactions must be signed before sending: %w", newBondErr)
+ }
+ }
+
+ baseFee, _, err := w.node.currentFees(w.ctx)
+ if err != nil {
+ return nil, fmt.Errorf("error getting net fee state: %w", err)
+ }
+
+ w.monitoredTxsMtx.Lock()
+ defer w.monitoredTxsMtx.Unlock()
+
+ monitoredTx, found := w.monitoredTxs[tx.Hash()]
+ if !found {
+ // If this is the first time submitting this transaction, do not submit
+ // if the base fee is greater than the gas fee limit.
+ gasFeeCap := tx.GasFeeCap()
+ if baseFee.Cmp(tx.GasFeeCap()) > 0 {
+ gasFeeLimitWei := dexeth.GweiToWei(w.gasFeeLimit())
+ if baseFee.Cmp(gasFeeLimitWei) > 0 {
+ return nil, fmt.Errorf("base fee %d exceeds gas fee limit %d. not sending bond tx", baseFee, gasFeeLimitWei)
+ }
+ // In MakeBondTx, the GasFeeCap is set to gasFeeLimit, but maybe the
+ // user updated the gasFeeLimit due to the above error message.
+ gasFeeCap = gasFeeLimitWei
+ }
+
+ txHash, err := w.sendBondTxWithNewNonceAndGasFee(tx, gasFeeCap)
+ if err != nil {
+ return nil, err
+ }
+
+ return txHash.Bytes(), nil
+ }
+
+ receipt, _, err := w.node.transactionReceipt(w.ctx, monitoredTx.tx.Hash())
+ if err != nil && err != asset.CoinNotFoundError {
+ return nil, err
+ }
+ if err == nil && receipt.BlockNumber.Cmp(big.NewInt(0)) > 0 {
+ // If already mined, just return the tx hash
+ return monitoredTx.tx.Hash().Bytes(), nil
+ }
+
+ // If the transaction has been recently submitted, transactionReceipt might
+ // return asset.CoinNotFoundError and the confirmed nonce was already bumped.
+ if err == asset.CoinNotFoundError && time.Since(monitoredTx.timeSubmitted) < time.Minute {
+ return monitoredTx.tx.Hash().Bytes(), nil
+ }
+
+ // If the transaction is still pending, check if the nonce is still valid.
+ // If not, resubmit with new nonce.
+ confirmedNonce, err := w.node.getConfirmedNonce(w.ctx)
+ if err != nil {
+ return nil, err
+ }
+ if confirmedNonce > monitoredTx.tx.Nonce() {
+ txHash, err := w.sendBondTxWithNewNonceAndGasFee(tx, monitoredTx.tx.GasFeeCap())
+ if err != nil {
+ return nil, err
+ }
+ return txHash.Bytes(), nil
+ }
+
+ // If nonce is not yet expired, check if gas fee too low.
+ if baseFee.Cmp(monitoredTx.tx.GasFeeCap()) > 0 {
+ baseFeeGwei := dexeth.WeiToGwei(baseFee)
+ gasLimit := monitoredTx.tx.Gas()
+ if gasLimit == 0 {
+ // Should not happen, but return here to avoid divide-by-zero
+ // panic below.
+ return nil, fmt.Errorf("gas is zero")
+ }
+
+ gasFeeCapGwei := dexeth.WeiToGwei(monitoredTx.tx.GasFeeCap())
+ originalFundsUsed := gasFeeCapGwei * monitoredTx.tx.Gas()
+ additionalFundsNeeded := (2 * baseFeeGwei * gasLimit) - originalFundsUsed
+ bal, err := w.Balance()
+ if err != nil {
+ return nil, err
+ }
+
+ // Use as much as possible. On the initial send, we can reject, but if this tx is
+ // already pending, we should try to bump the gas fee in order to avoid holding up
+ // other transactions.
+ var gasFeeCap *big.Int
+ if bal.Available > additionalFundsNeeded {
+ gasFeeCap = gasFeeCap.Mul(baseFee, big.NewInt(2))
+ } else {
+ totalFee := dexeth.GweiToWei(bal.Available + originalFundsUsed)
+ gasFeeCap = totalFee.Div(totalFee, big.NewInt(int64(monitoredTx.tx.Gas())))
+ }
+
+ txHash, err := w.sendBondTxWithNewNonceAndGasFee(tx, gasFeeCap)
+ if err != nil {
+ return nil, err
+ }
+ return txHash.Bytes(), nil
+ }
+
+ // If nonce is not yet expired and gas fee is still good, just return the tx hash
+ return monitoredTx.tx.Hash().Bytes(), nil
+}
+
+// SendTransaction broadcasts a transaction. If it is not yet signed,
+// a nonce will be added and the transaction signed.
+func (w *assetWallet) SendTransaction(rawTx []byte) ([]byte, error) {
tx := new(types.Transaction)
err := tx.UnmarshalBinary(rawTx)
if err != nil {
return nil, fmt.Errorf("failed to unmarshal transaction: %w", err)
}
- if err := eth.node.sendSignedTransaction(eth.ctx, tx); err != nil {
+
+ if !txIsSigned(tx) {
+ return w.sendUnsignedBondTransaction(tx)
+ }
+
+ if err := w.node.sendSignedTransaction(w.ctx, tx); err != nil {
return nil, err
}
return tx.Hash().Bytes(), nil
@@ -3074,6 +3376,291 @@ func (w *ETHWallet) EstimateSendTxFee(addr string, value, _ uint64, subtract boo
return maxFee, w.ValidateAddress(addr), nil
}
+// MakeBondTx creates an unsigned transaction to create a new bond. ETH
+// transactions cannot be signed beforehand due to nonce ordering, so the
+// the SignedTx and UnsignedTx fields in the return value both contain
+// the same data. The nonce and the signature is added when SendTransaction
+// is called.
+func (w *ETHWallet) MakeBondTx(ver uint16, amt uint64, feeRate uint64, lockTime time.Time, privKey *secp256k1.PrivateKey, acctID []byte) (*asset.Bond, func(), error) {
+ if ver != 0 {
+ return nil, nil, fmt.Errorf("only version 0 bonds are supported")
+ }
+
+ var accountID, bondID [32]byte
+ copy(accountID[:], acctID)
+ copy(bondID[:], privKey.Serialize())
+ data, err := dexeth.PackCreateBondTx(accountID, bondID, uint64(lockTime.Unix()))
+ if err != nil {
+ return nil, nil, err
+ }
+
+ balance, err := w.balanceWithoutBondReserves()
+ if err != nil {
+ return nil, nil, err
+ }
+
+ gasFeeLimit := w.gasFeeLimit()
+ if balance.Available < amt+dexeth.NewBondGas*gasFeeLimit {
+ return nil, nil, asset.ErrInsufficientBalance
+ }
+
+ bondTx := types.NewTx(&types.DynamicFeeTx{
+ Value: dexeth.GweiToWei(amt),
+ To: &w.bondAddress,
+ Gas: dexeth.NewBondGas,
+ GasFeeCap: dexeth.GweiToWei(gasFeeLimit),
+ Data: data})
+ serializedTx, err := bondTx.MarshalBinary()
+ if err != nil {
+ return nil, nil, err
+ }
+
+ abort := func() {}
+
+ return &asset.Bond{
+ Version: ver,
+ AssetID: BipID,
+ Amount: amt,
+ CoinID: createBondCoin(accountID, bondID, amt).ID(),
+ SignedTx: serializedTx,
+ UnsignedTx: serializedTx,
+ LockTime: uint64(lockTime.Unix()),
+ }, abort, nil
+}
+
+// setupForUpdateBond extracts the accountID and bondIDs from the bondCoins,
+// sorts the bondIDs by lock time, and returns the earliest lockTime and total
+// value of the bonds to be updated.
+func (w *ETHWallet) setupForUpdateBond(bondCoins []dex.Bytes) (accountID [32]byte, sortedBondIDs [][32]byte, earliestLockTime uint64, totalValue uint64, err error) {
+ type bondIDAndLockTime struct {
+ bondID [32]byte
+ lockTime uint64
+ }
+
+ bondIDsAndLockTimes := make([]*bondIDAndLockTime, len(bondCoins))
+ totalBondValueWei := big.NewInt(0)
+
+ for i, bondCoin := range bondCoins {
+ bondCoin, err := decodeBondCoin(bondCoin)
+ if err != nil {
+ return [32]byte{}, nil, 0, 0, err
+ }
+
+ bondData, err := w.ethBond.BondData(&bind.CallOpts{Context: w.ctx, From: w.addr}, bondCoin.accountID, bondCoin.bondID)
+ if err != nil {
+ return [32]byte{}, nil, 0, 0, fmt.Errorf("error getting bond data: %w", err)
+ }
+
+ if i == 0 {
+ accountID = bondCoin.accountID
+ } else if accountID != bondCoin.accountID {
+ return [32]byte{}, nil, 0, 0, fmt.Errorf("bonds to update must be from the same account")
+ }
+
+ bondIDsAndLockTimes[i] = &bondIDAndLockTime{
+ bondID: bondCoin.bondID,
+ lockTime: bondData.Locktime,
+ }
+ totalBondValueWei = totalBondValueWei.Add(totalBondValueWei, bondData.Value)
+ }
+
+ totalValue = dexeth.WeiToGwei(totalBondValueWei)
+
+ sort.Slice(bondIDsAndLockTimes, func(i, j int) bool {
+ return bondIDsAndLockTimes[i].lockTime < bondIDsAndLockTimes[j].lockTime
+ })
+ earliestLockTime = bondIDsAndLockTimes[0].lockTime
+
+ sortedBondIDs = make([][32]byte, len(bondIDsAndLockTimes))
+ for i, bondIDAndLockTime := range bondIDsAndLockTimes {
+ sortedBondIDs[i] = bondIDAndLockTime.bondID
+ }
+
+ return accountID, sortedBondIDs, earliestLockTime, totalValue, nil
+}
+
+// UpdateBondTx creates an unsigned transaction that uses the funds locked in
+// one or more bonds to create a new bond with a longer lockTime. If the total
+// value of the bonds is greater than the new bond, a "change" bond will be
+// created with the remaining funds and the same lockTime as the earliest
+// expiring bond. If two bonds are being created, the "change" bond will be the
+// first in the returned []*asset.Bond slice.
+//
+// Requirements:
+// - The correct amount of privKeys must be passed, depending on whether or not
+// a change bond is needed.
+// - The lockTime must be later than the latest lockTime of the bondsToUpdate.
+// - The value of the earliest expiring bond must be greater than the "change"
+// bond value.
+// - The bondsToUpdate must all be from the same account.
+func (w *ETHWallet) UpdateBondTx(ver uint16, bondsToUpdate []dex.Bytes, privKeys []*secp256k1.PrivateKey, amt uint64, lockTime time.Time) ([]*asset.Bond, error) {
+ if len(bondsToUpdate) == 0 {
+ return nil, fmt.Errorf("no bonds to update")
+ }
+
+ accountID, bondIDs, earliestLockTime, totalValueGwei, err := w.setupForUpdateBond(bondsToUpdate)
+ if err != nil {
+ return nil, err
+ }
+
+ var gweiRequired uint64
+ if totalValueGwei < amt {
+ gweiRequired = amt - totalValueGwei
+ }
+ balance, err := w.balanceWithoutBondReserves()
+ if err != nil {
+ return nil, err
+ }
+ gasFeeLimit := w.gasFeeLimit()
+ if balance.Available < gweiRequired+dexeth.UpdateBondGas*gasFeeLimit {
+ return nil, asset.ErrInsufficientBalance
+ }
+
+ newBondCoinIDs := make([][32]byte, 0, len(privKeys))
+ for _, privKey := range privKeys {
+ var bondID [32]byte
+ copy(bondID[:], privKey.Serialize())
+ newBondCoinIDs = append(newBondCoinIDs, bondID)
+ }
+
+ weiAmt := dexeth.GweiToWei(amt)
+ lt := uint64(lockTime.Unix())
+ weiToSend := dexeth.GweiToWei(gweiRequired)
+ canUpdate, _, reason, err := w.ethBond.VerifyBondUpdate(
+ &bind.CallOpts{Context: w.ctx, From: w.addr}, accountID, bondIDs, newBondCoinIDs, weiAmt, lt, weiToSend)
+ if err != nil {
+ return nil, fmt.Errorf("error checking if bond can be updated: %w", err)
+ }
+ if !canUpdate {
+ return nil, fmt.Errorf("bond cannot be updated: %s", reason)
+ }
+
+ data, err := dexeth.PackUpdateBondsTx(accountID, bondIDs, newBondCoinIDs, weiAmt, lt)
+ if err != nil {
+ return nil, err
+ }
+
+ bondTx := types.NewTx(&types.DynamicFeeTx{
+ Value: weiToSend,
+ To: &w.bondAddress,
+ Gas: dexeth.UpdateBondGas,
+ GasFeeCap: dexeth.GweiToWei(gasFeeLimit),
+ Data: data})
+ serializedTx, err := bondTx.MarshalBinary()
+ if err != nil {
+ return nil, err
+ }
+
+ if len(newBondCoinIDs) == 2 {
+ return []*asset.Bond{
+ {
+ Version: ver,
+ AssetID: BipID,
+ Amount: totalValueGwei - amt,
+ CoinID: createBondCoin(accountID, newBondCoinIDs[0], totalValueGwei-amt).ID(),
+ SignedTx: serializedTx,
+ UnsignedTx: serializedTx,
+ LockTime: earliestLockTime,
+ },
+ {
+ Version: ver,
+ AssetID: BipID,
+ Amount: amt,
+ CoinID: createBondCoin(accountID, newBondCoinIDs[1], amt).ID(),
+ SignedTx: serializedTx,
+ UnsignedTx: serializedTx,
+ LockTime: uint64(lockTime.Unix()),
+ },
+ }, nil
+ }
+
+ return []*asset.Bond{
+ {
+ Version: ver,
+ AssetID: BipID,
+ Amount: amt,
+ CoinID: createBondCoin(accountID, newBondCoinIDs[0], amt).ID(),
+ SignedTx: serializedTx,
+ UnsignedTx: serializedTx,
+ LockTime: uint64(lockTime.Unix()),
+ },
+ }, nil
+}
+
+// RefundBond retrieves the funds locked in an expired bond.
+func (w *ETHWallet) RefundBond(ctx context.Context, ver uint16, coinID []byte, _ []byte, _ uint64, _ *secp256k1.PrivateKey) (asset.Coin, error) {
+ bondCoin, err := decodeBondCoin(coinID)
+ if err != nil {
+ return nil, err
+ }
+
+ refundable, err := w.ethBond.BondRefundable(&bind.CallOpts{Context: ctx}, bondCoin.accountID, bondCoin.bondID)
+ if err != nil {
+ return nil, fmt.Errorf("error checking if bond is refundable: %w", err)
+ }
+ if !refundable {
+ return nil, fmt.Errorf("bond is not refundable")
+ }
+
+ bondData, err := w.ethBond.BondData(&bind.CallOpts{Context: ctx}, bondCoin.accountID, bondCoin.bondID)
+ if err != nil {
+ return nil, fmt.Errorf("error getting bond data: %w", err)
+ }
+
+ w.nonceSendMtx.Lock()
+ defer w.nonceSendMtx.Unlock()
+ txOpts, err := w.node.txOpts(ctx, 0, dexeth.RefundBondGas, dexeth.GweiToWei(w.gasFeeLimit()), nil)
+ if err != nil {
+ return nil, err
+ }
+ tx, err := w.ethBond.RefundBond(txOpts, bondCoin.accountID, bondCoin.bondID)
+ if err != nil {
+ return nil, fmt.Errorf("error refunding bond: %w", err)
+ }
+
+ bondVal := dexeth.WeiToGwei(bondData.Value)
+ fees := dexeth.WeiToGwei(tx.GasPrice()) * tx.Gas()
+
+ bondInfo := &asset.BondTxInfo{
+ AccountID: bondCoin.accountID[:],
+ Bond: &asset.BondInfo{
+ ID: hex.EncodeToString(bondCoin.bondID[:]),
+ Amount: bondVal,
+ LockTime: bondData.Locktime,
+ },
+ }
+ w.addToTxHistory(tx.Nonce(), bondVal, fees, w.assetID, tx.Hash(), asset.RedeemBond, bondInfo, nil)
+
+ return createBondCoin(bondCoin.accountID, bondCoin.bondID, bondVal), nil
+}
+
+// SetBondReserves does nothing for ETH, because bond reserves are only
+// required for the fee buffer.
+func (a *assetWallet) SetBondReserves(reserves uint64) {
+ a.maintainingBondReserves.Store(reserves > 0)
+}
+
+func bondFeeBuffer(feeRateLimit uint64) uint64 {
+ const numExtensions uint64 = 8
+ return feeRateLimit * dexeth.UpdateBondGas * numExtensions
+}
+
+// BondsFeeBuffer suggests how much may be required to be reserved for
+// transaction fees when bond rotation is enabled.
+func (w *assetWallet) BondsFeeBuffer(feeRate uint64) uint64 {
+ return bondFeeBuffer(feeRate)
+}
+
+// bondReserves returns the bond fee buffer if the nominal bond reserves
+// and greater than zero, otherwise it returns zero.
+func (w *assetWallet) bondReserves() uint64 {
+ if w.maintainingBondReserves.Load() {
+ return w.BondsFeeBuffer(w.gasFeeLimit())
+ }
+
+ return 0
+}
+
// EstimateSendTxFee returns a tx fee estimate for a send tx. The provided fee
// rate is ignored since all sends will use an internally derived fee rate. If
// an address is provided, it will ensure wallet has enough to cover total
@@ -3177,7 +3764,7 @@ func (w *ETHWallet) Send(addr string, value, _ uint64) (asset.Coin, error) {
txType = asset.SelfSend
}
- w.addToTxHistory(tx.Nonce(), value, maxFee, w.assetID, txHash, txType, &addr)
+ w.addToTxHistory(tx.Nonce(), value, maxFee, w.assetID, txHash, txType, nil, &addr)
return &coin{id: txHash, value: value}, nil
}
@@ -3201,7 +3788,7 @@ func (w *TokenWallet) Send(addr string, value, _ uint64) (asset.Coin, error) {
}
txHash := tx.Hash()
- w.addToTxHistory(tx.Nonce(), value, maxFee, w.assetID, txHash, asset.Send, &addr)
+ w.addToTxHistory(tx.Nonce(), value, maxFee, w.assetID, txHash, asset.Send, nil, &addr)
return &coin{id: txHash, value: value}, nil
}
@@ -3359,11 +3946,32 @@ func (eth *baseWallet) swapOrRedemptionFeesPaid(ctx context.Context, coinID, con
return dexeth.WeiToGwei(bigFees), secretHashes, nil
}
-// TransactionConfirmations gets the number of confirmations for the specified
-// transaction.
-func (eth *baseWallet) TransactionConfirmations(ctx context.Context, txID string) (confs uint32, err error) {
- txHash := common.HexToHash(txID)
- return eth.node.transactionConfirmations(ctx, txHash)
+// BondConfirmations gets the numer of confirmations since the creation of a bond.
+func (eth *ETHWallet) BondConfirmations(ctx context.Context, coinID dex.Bytes) (confs uint32, err error) {
+ bondCoin, err := decodeBondCoin(coinID)
+ if err != nil {
+ return 0, err
+ }
+
+ bondData, err := eth.ethBond.BondData(&bind.CallOpts{Context: ctx}, bondCoin.accountID, bondCoin.bondID)
+ if err != nil {
+ return 0, err
+ }
+
+ bestHdr, err := eth.node.bestHeader(ctx)
+ if err != nil {
+ return 0, err
+ }
+
+ if bondData.InitBlockNumber.Int64() == 0 {
+ return 0, nil
+ }
+
+ if bestHdr.Number.Int64() < bondData.InitBlockNumber.Int64() {
+ return 0, nil
+ }
+
+ return uint32(bestHdr.Number.Int64() - bondData.InitBlockNumber.Int64() + 1), nil
}
// RegFeeConfirmations gets the number of confirmations for the specified
@@ -3495,6 +4103,9 @@ func (eth *ETHWallet) checkForNewBlocks(ctx context.Context) {
go func() {
for _, w := range connectedWallets {
+ if w.emit == nil {
+ continue
+ }
w.emit.TipChange(bestHdr.Number.Uint64())
}
}()
@@ -3517,6 +4128,48 @@ func (eth *ETHWallet) checkForNewBlocks(ctx context.Context) {
defer eth.txDbWg.Done()
eth.checkPendingTxs()
}()
+
+ eth.txDbWg.Add(1)
+ go func() {
+ defer eth.txDbWg.Done()
+ eth.clearConfirmedMonitoredTxs(bestHdr.Number.Uint64())
+ }()
+}
+
+// clearConfirmedMonitoredTxs removes monitored transaction maked with
+// removeAfterConfirms if they have been confirmed.
+func (w *assetWallet) clearConfirmedMonitoredTxs(currentTip uint64) {
+ w.monitoredTxsMtx.Lock()
+ defer w.monitoredTxsMtx.Unlock()
+
+ for _, tx := range w.monitoredTxs {
+ if tx.removeAfterConfirms == 0 {
+ continue
+ }
+
+ txHash := tx.tx.Hash()
+ _, txBlock, err := w.node.getTransaction(w.ctx, txHash)
+ if err != nil && errors.Is(asset.CoinNotFoundError, err) {
+ continue
+ } else if err != nil {
+ w.log.Errorf("error getting receipt for monitored tx %s: %v", tx.tx.Hash(), err)
+ continue
+ }
+
+ w.log.Tracef("clearing monitored tx %s, txBlock: %d, currentTip: %d", txHash, txBlock, currentTip)
+
+ var confirms uint64
+ if currentTip >= uint64(txBlock) {
+ confirms = uint64(txBlock) - currentTip + 1
+ }
+
+ if confirms >= tx.removeAfterConfirms {
+ if err := w.txDB.removeMonitoredTxs([]common.Hash{txHash}); err != nil {
+ w.log.Errorf("failed to delete monitored tx: %v", err)
+ }
+ delete(w.monitoredTxs, tx.tx.Hash())
+ }
+ }
}
// getLatestMonitoredTx looks up a txHash in the monitoredTxs map. If the
@@ -4585,6 +5238,10 @@ func (w *baseWallet) emitTransactionNote(tx *asset.WalletTransaction, new bool)
}
w.walletsMtx.RUnlock()
+ if baseWallet.emit == nil {
+ return
+ }
+
if found {
baseWallet.emit.TransactionNote(tx, new)
} else {
@@ -4733,7 +5390,7 @@ func (w *baseWallet) checkPendingTxs() {
const txHistoryNonceKey = "Nonce"
-func (w *baseWallet) addToTxHistory(nonce, amount, fees uint64, assetID uint32, txHash common.Hash, txType asset.TransactionType, recipient *string) {
+func (w *baseWallet) addToTxHistory(nonce, amount, fees uint64, assetID uint32, txHash common.Hash, txType asset.TransactionType, bondInfo *asset.BondTxInfo, recipient *string) {
var tokenAssetID *uint32
if assetID != w.baseChainID {
tokenAssetID = &assetID
@@ -4750,6 +5407,7 @@ func (w *baseWallet) addToTxHistory(nonce, amount, fees uint64, assetID uint32,
AdditionalData: map[string]string{
txHistoryNonceKey: strconv.FormatUint(nonce, 10),
},
+ BondInfo: bondInfo,
},
SubmissionTime: uint64(time.Now().Unix()),
savedToDB: true,
@@ -4798,6 +5456,13 @@ func (w *TokenWallet) TxHistory(n int, refID *string, past bool) ([]*asset.Walle
return w.txDB.getTxs(n, refID, past, &w.assetID)
}
+// TransactionConfirmations gets the number of confirmations for the specified
+// transaction.
+func (eth *baseWallet) TransactionConfirmations(ctx context.Context, txID string) (confs uint32, err error) {
+ txHash := common.HexToHash(txID)
+ return eth.node.transactionConfirmations(ctx, txHash)
+}
+
// providersFile reads a file located at ~/dextest/credentials.json.
// The file contains seed and provider information for wallets used for
// getgas, deploy, and nodeclient testing. If simnet providers are not
diff --git a/client/asset/eth/fundingcoin.go b/client/asset/eth/fundingcoin.go
index 536cbd1779..aaf0d56e66 100644
--- a/client/asset/eth/fundingcoin.go
+++ b/client/asset/eth/fundingcoin.go
@@ -7,12 +7,14 @@ import (
"encoding/binary"
"fmt"
+ "decred.org/dcrdex/client/asset"
"decred.org/dcrdex/dex"
"github.com/ethereum/go-ethereum/common"
)
const fundingCoinIDSize = 28 // address (20) + amount (8) = 28
const tokenFundingCoinIDSize = 36 // address (20) + amount (8) + amount (8) = 36
+const bondCoinSize = 64 // accountID (32) + bondID (32)
// fundingCoin is an identifier for a coin which has not yet been sent to the
// swap contract.
@@ -135,3 +137,51 @@ func createTokenFundingCoin(address common.Address, tokenValue, fees uint64) *to
fees: fees,
}
}
+
+type bondCoin struct {
+ accountID [32]byte
+ bondID [32]byte
+ value uint64
+}
+
+var _ asset.Coin = (*bondCoin)(nil)
+
+func decodeBondCoin(coinID []byte) (*bondCoin, error) {
+ if len(coinID) != bondCoinSize {
+ return nil, fmt.Errorf("decodeBondRefundCoin: length expected %v, got %v",
+ bondCoinSize, len(coinID))
+ }
+
+ var bondID, accountID [32]byte
+ copy(accountID[:], coinID[0:32])
+ copy(bondID[:], coinID[32:64])
+
+ return &bondCoin{
+ bondID: bondID,
+ accountID: accountID,
+ }, nil
+}
+
+func (c *bondCoin) ID() dex.Bytes {
+ return append(c.accountID[:], c.bondID[:]...)
+}
+
+func (c *bondCoin) String() string {
+ return fmt.Sprintf("accountID: %x, bondID: %x", c.accountID, c.bondID)
+}
+
+func (c *bondCoin) Value() uint64 {
+ return c.value
+}
+
+func (c *bondCoin) TxID() string {
+ return ""
+}
+
+func createBondCoin(accountID, bondID [32]byte, value uint64) *bondCoin {
+ return &bondCoin{
+ accountID: accountID,
+ bondID: bondID,
+ value: value,
+ }
+}
diff --git a/client/asset/eth/multirpc_live_test.go b/client/asset/eth/multirpc_live_test.go
index 7e9d159ee3..6ea6cb1354 100644
--- a/client/asset/eth/multirpc_live_test.go
+++ b/client/asset/eth/multirpc_live_test.go
@@ -4,10 +4,18 @@ package eth
import (
"context"
+ "encoding/hex"
+ "fmt"
"os"
+ "path/filepath"
"testing"
+ "time"
+ "decred.org/dcrdex/client/asset"
"decred.org/dcrdex/dex"
+ "decred.org/dcrdex/dex/encode"
+ dexeth "decred.org/dcrdex/dex/networks/eth"
+ "github.com/decred/dcrd/dcrec/secp256k1/v4"
)
const (
@@ -17,6 +25,14 @@ const (
var mt *MRPCTest
+var (
+ ctx = context.Background()
+ homeDir = os.Getenv("HOME")
+ simnetWalletDir = filepath.Join(homeDir, "dextest", "eth", "client_rpc_tests", "simnet")
+ simnetWalletSeed = "0812f5244004217452059e2fd11603a511b5d0870ead753df76c966ce3c71531"
+ pw = "bee75192465cef9f8ab1198093dfed594e93ae810ccbbf2b3b12e1771cc6cb19"
+)
+
func TestMain(m *testing.M) {
ctx, shutdown := context.WithCancel(context.Background())
mt = NewMRPCTest(ctx, ChainConfig, NetworkCompatibilityData, "eth")
@@ -96,3 +112,176 @@ func TestFreeServers(t *testing.T) {
func TestMainnetCompliance(t *testing.T) {
mt.TestMainnetCompliance(t)
}
+
+func setupWallet(walletDir, seed string, net dex.Network) error {
+ walletType := walletTypeRPC
+ seedBytes, err := hex.DecodeString(seed)
+ if err != nil {
+ return fmt.Errorf("error decoding seed: %v", err)
+ }
+
+ comp, err := NetworkCompatibilityData(net)
+ if err != nil {
+ return fmt.Errorf("error finding compatibility data: %v", err)
+ }
+
+ cfg := &asset.CreateWalletParams{
+ Type: walletType,
+ Seed: seedBytes,
+ Pass: []byte(pw),
+ Settings: map[string]string{
+ "gasfeelimit": "200",
+ "providers": filepath.Join(homeDir, "dextest", "eth", "alpha", "node", "geth.ipc"),
+ "special_activelyUsed": "false",
+ },
+ DataDir: walletDir,
+ Net: net,
+ Logger: dex.StdOutLogger("T", dex.LevelTrace),
+ }
+
+ return CreateEVMWallet(dexeth.ChainIDs[net], cfg, &comp, false)
+}
+
+func TestMakeBondTx(t *testing.T) {
+ err := setupWallet(simnetWalletDir, simnetWalletSeed, dex.Simnet)
+ if err != nil {
+ t.Fatalf("error setting up wallet: %v", err)
+ }
+
+ walletConfig := &asset.WalletConfig{
+ Type: "rpc",
+ Settings: map[string]string{
+ "gasfeelimit": "200",
+ "providers": filepath.Join(homeDir, "dextest", "eth", "alpha", "node", "geth.ipc"),
+ "special_activelyUsed": "false",
+ },
+ PeersChange: func(uint32, error) {},
+ DataDir: simnetWalletDir,
+ }
+ log := dex.StdOutLogger("T", dex.LevelTrace)
+
+ backend, err := newWallet(walletConfig, log, dex.Simnet)
+ if err != nil {
+ t.Fatalf("error creating wallet: %v", err)
+ }
+
+ context, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ cm := dex.NewConnectionMaster(backend)
+ err = cm.Connect(context)
+ if err != nil {
+ t.Fatalf("error connecting wallet: %v", err)
+ }
+
+ priv, err := secp256k1.GeneratePrivateKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ addr, err := backend.DepositAddress()
+ if err != nil {
+ t.Fatalf("error getting deposit address: %v", err)
+ }
+ fmt.Printf("deposit address: %s\n", addr)
+
+ accountID := encode.RandomBytes(32)
+ fmt.Printf("accountID %x\n", accountID)
+ amt := uint64(1000000000)
+ bond, _, err := backend.MakeBondTx(0, amt, 0, time.Now(), priv, accountID)
+ if err != nil {
+ t.Fatalf("error creating bond tx: %v", err)
+ }
+
+ err = backend.Unlock([]byte(pw))
+ if err != nil {
+ t.Fatalf("error unlocking wallet: %v", err)
+ }
+
+ bondTxHash, err := backend.SendTransaction(bond.SignedTx)
+ if err != nil {
+ t.Fatalf("error sending bond tx: %v", err)
+ }
+
+ fmt.Printf("Initial bond ID %s\n", hex.EncodeToString(priv.Serialize()))
+ fmt.Printf("Initial bond TX Hash %x\n", bondTxHash)
+
+ var confs uint32
+ for i := 0; i < 30; i++ {
+ confs, err = backend.BondConfirmations(ctx, bond.CoinID)
+ if err != nil {
+ t.Fatalf("error getting confirmations: %v", err)
+ }
+ if confs > 0 {
+ break
+ }
+ fmt.Println("Waiting for confirmations for initial bond tx...")
+ time.Sleep(1 * time.Second)
+ }
+ if confs == 0 {
+ t.Fatalf("no confirmations")
+ }
+
+ newPriv1, err := secp256k1.GeneratePrivateKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ newPriv2, err := secp256k1.GeneratePrivateKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ fmt.Printf("Change Bond ID: %s\n", hex.EncodeToString(newPriv1.Serialize()))
+ fmt.Printf("Updated Bond ID: %s\n", hex.EncodeToString(newPriv2.Serialize()))
+
+ newBonds, err := backend.UpdateBondTx(0, []dex.Bytes{bond.CoinID}, []*secp256k1.PrivateKey{newPriv1, newPriv2}, amt/2, time.Now())
+ if err != nil {
+ t.Fatalf("error creating update bond tx: %v", err)
+ }
+
+ for _, newBond := range newBonds {
+ newBondTxHash, err := backend.SendTransaction(newBond.SignedTx)
+ if err != nil {
+ t.Fatalf("error sending update bond tx: %v", err)
+ }
+ fmt.Printf("Update bond tx hash %x\n", newBondTxHash)
+ }
+
+ for i := 0; i < 30; i++ {
+ confs, err = backend.BondConfirmations(ctx, newBonds[0].CoinID)
+ if err != nil {
+ t.Fatalf("error getting confirmations: %v", err)
+ }
+ if confs > 0 {
+ break
+ }
+ fmt.Println("Waiting for confirmations for update bond tx...")
+ time.Sleep(1 * time.Second)
+ }
+ if confs == 0 {
+ t.Fatalf("no confirmations")
+ }
+
+ bal, err := backend.Balance()
+ if err != nil {
+ t.Fatalf("error getting balance: %v", err)
+ }
+ preRefundBalance := bal.Available
+
+ _, err = backend.RefundBond(ctx, 0, newBonds[0].CoinID, nil, 0, priv)
+ if err != nil {
+ t.Fatalf("error creating refund tx: %v", err)
+ }
+
+ for i := 0; i < 20; i++ {
+ bal, err := backend.Balance()
+ if err != nil {
+ t.Fatalf("error getting balance: %v", err)
+ }
+ if bal.Available > preRefundBalance {
+ return
+ }
+ fmt.Println("Waiting for bond refund...")
+ time.Sleep(1 * time.Second)
+ }
+}
diff --git a/client/asset/eth/txdb.go b/client/asset/eth/txdb.go
index 4b7da5491c..db91ba9845 100644
--- a/client/asset/eth/txdb.go
+++ b/client/asset/eth/txdb.go
@@ -34,15 +34,27 @@ type extendedWalletTx struct {
savedToDB bool
}
-// monitoredTx is used to keep track of redemption transactions that have not
-// yet been confirmed. If a transaction has to be replaced due to the fee
-// being too low or another transaction being mined with the same nonce,
-// the replacement transaction's ID is recorded in the replacementTx field.
-// replacedTx is used to maintain a doubly linked list, which allows deletion
-// of transactions that were replaced after a transaction is confirmed.
+// monitoredTx is used to keep track of redemption and bond creation/update
+// transactions that have not yet been confirmed.
+//
+// If a redemption transaction has to be resubmitted, the replacement
+// transaction's ID is recorded in the replacementTx field. replacedTx is used
+// to maintain a doubly linked list, which allows the most recently submitted
+// transaction to be looked up in case an older one's ID is requested.
+//
+// For bond creation/update transactions this is not needed, since BondConfirmations
+// is called using the BondID instead of with the transaction ID.
type monitoredTx struct {
tx *types.Transaction
blockSubmitted uint64
+ // There is a goroutine that runs on each new block that checks the
+ // number of confirmations for all monitoredTxs with removeAfterConfirms > 0.
+ // If the number of confirmations is greater than or equal to
+ // removeAfterConfirms, the transaction is removed. This is done for
+ // bond transactions. redemption transactions are removed separately
+ // from this process.
+ removeAfterConfirms uint64
+ timeSubmitted time.Time
// This mutex must be held during the entire process of confirming
// a transaction. This is to avoid confirmations of the same
@@ -60,7 +72,7 @@ type monitoredTx struct {
// MarshalBinary marshals a monitoredTx into a byte array.
// It satisfies the encoding.BinaryMarshaler interface for monitoredTx.
func (m *monitoredTx) MarshalBinary() (data []byte, err error) {
- b := encode.BuildyBytes{0}
+ b := encode.BuildyBytes{1}
txB, err := m.tx.MarshalBinary()
if err != nil {
return nil, fmt.Errorf("error marshaling tx: %v", err)
@@ -71,24 +83,26 @@ func (m *monitoredTx) MarshalBinary() (data []byte, err error) {
binary.BigEndian.PutUint64(blockB, m.blockSubmitted)
b = b.AddData(blockB)
- if m.replacementTx != nil {
- replacementTxHash := m.replacementTx[:]
- b = b.AddData(replacementTxHash)
+ removeAfterConfirmsB := make([]byte, 8)
+ binary.BigEndian.PutUint64(removeAfterConfirmsB, m.removeAfterConfirms)
+ b = b.AddData(removeAfterConfirmsB)
+
+ if m.replacementTx == nil {
+ b = b.AddData([]byte{})
+ } else {
+ b = b.AddData(m.replacementTx[:])
+ }
+
+ if m.replacedTx == nil {
+ b = b.AddData([]byte{})
+ } else {
+ b = b.AddData(m.replacedTx[:])
}
return b, nil
}
-// UnmarshalBinary loads a data from a marshalled byte array into a
-// monitoredTx.
-func (m *monitoredTx) UnmarshalBinary(data []byte) error {
- ver, pushes, err := encode.DecodeBlob(data)
- if err != nil {
- return err
- }
- if ver != 0 {
- return fmt.Errorf("unknown version %d", ver)
- }
+func (m *monitoredTx) unmarshalV0(pushes [][]byte) error {
if len(pushes) != 2 && len(pushes) != 3 {
return fmt.Errorf("wrong number of pushes %d", len(pushes))
}
@@ -108,6 +122,54 @@ func (m *monitoredTx) UnmarshalBinary(data []byte) error {
return nil
}
+// v1 added the removeAfterConfirms and the replacedTx fields.
+func (m *monitoredTx) unmarshalV1(pushes [][]byte) error {
+ if len(pushes) != 5 {
+ return fmt.Errorf("wrong number of pushes %d", len(pushes))
+ }
+
+ m.tx = &types.Transaction{}
+ if err := m.tx.UnmarshalBinary(pushes[0]); err != nil {
+ return fmt.Errorf("error reading tx: %w", err)
+ }
+
+ m.blockSubmitted = binary.BigEndian.Uint64(pushes[1])
+ m.removeAfterConfirms = binary.BigEndian.Uint64(pushes[2])
+
+ if len(pushes[3]) > 0 {
+ var replacementTxHash common.Hash
+ copy(replacementTxHash[:], pushes[3])
+ m.replacementTx = &replacementTxHash
+ }
+
+ if len(pushes[4]) > 0 {
+ var replacedTxHash common.Hash
+ copy(replacedTxHash[:], pushes[4])
+ m.replacedTx = &replacedTxHash
+ }
+
+ return nil
+}
+
+// UnmarshalBinary loads a data from a marshalled byte array into a
+// monitoredTx.
+func (m *monitoredTx) UnmarshalBinary(data []byte) error {
+ ver, pushes, err := encode.DecodeBlob(data)
+ if err != nil {
+ return err
+ }
+
+ if ver > 1 {
+ return fmt.Errorf("unknown version %d", ver)
+ }
+
+ if ver == 0 {
+ return m.unmarshalV0(pushes)
+ }
+
+ return m.unmarshalV1(pushes)
+}
+
var (
// noncePrefix is the prefix for the key used to map a nonce to an
// extendedWalletTx.
diff --git a/client/asset/eth/txdb_test.go b/client/asset/eth/txdb_test.go
index f6a6c148fa..575e626a2f 100644
--- a/client/asset/eth/txdb_test.go
+++ b/client/asset/eth/txdb_test.go
@@ -268,10 +268,16 @@ func TestTxDB(t *testing.T) {
if a.tx.Hash() != b.tx.Hash() {
return false
}
- if a.replacementTx != nil && b.replacementTx != nil && *a.replacementTx != *b.replacementTx {
+ if (a.replacementTx == nil) != (b.replacementTx == nil) {
return false
}
- if a.replacedTx != nil && b.replacedTx != nil && *a.replacedTx != *b.replacedTx {
+ if a.replacementTx != nil && *a.replacementTx != *b.replacementTx {
+ return false
+ }
+ if (a.replacedTx == nil) != (b.replacedTx == nil) {
+ return false
+ }
+ if a.replacedTx != nil && *a.replacedTx != *b.replacedTx {
return false
}
if a.blockSubmitted != b.blockSubmitted {
diff --git a/client/asset/interface.go b/client/asset/interface.go
index 929065bb7c..974416991c 100644
--- a/client/asset/interface.go
+++ b/client/asset/interface.go
@@ -35,6 +35,7 @@ const (
WalletTraitTicketBuyer // The wallet can participate in decred staking.
WalletTraitHistorian // This wallet can return its transaction history
WalletTraitFundsMixer // The wallet can mix funds.
+ WalletTraitBondUpdater // The wallet can update bonds.
)
// IsRescanner tests if the WalletTrait has the WalletTraitRescanner bit set.
@@ -145,6 +146,12 @@ func (wt WalletTrait) IsFundsMixer() bool {
return wt&WalletTraitFundsMixer != 0
}
+// IsBondUpdater tests if the WalletTrait has the WalletTraitBondUpdater bit set,
+// which indicates the wallet implements the BondUpdater interface.
+func (wt WalletTrait) IsBondUpdater() bool {
+ return wt&WalletTraitBondUpdater != 0
+}
+
// DetermineWalletTraits returns the WalletTrait bitset for the provided Wallet.
func DetermineWalletTraits(w Wallet) (t WalletTrait) {
if _, is := w.(Rescanner); is {
@@ -201,6 +208,9 @@ func DetermineWalletTraits(w Wallet) (t WalletTrait) {
if _, is := w.(FundsMixer); is {
t |= WalletTraitFundsMixer
}
+ if _, is := w.(BondUpdater); is {
+ t |= WalletTraitBondUpdater
+ }
return t
}
@@ -614,6 +624,8 @@ type Bonder interface {
// RefundBond will refund the bond given the full bond output details and
// private key to spend it. The bond is broadcasted.
RefundBond(ctx context.Context, ver uint16, coinID, script []byte, amt uint64, privKey *secp256k1.PrivateKey) (Coin, error)
+ // BondConfirmations gets the numer of confirmations since the creation of a bond.
+ BondConfirmations(ctx context.Context, coinID dex.Bytes) (confs uint32, err error)
// A RefundBondByCoinID may be created in the future to attempt to refund a
// bond by locating it on chain, i.e. without providing the amount or
@@ -624,6 +636,32 @@ type Bonder interface {
// required for efficient client bond management.
}
+// BondUpdater is a wallet that can use the values of existing bonds to create
+// new bonds with a longer lockTime. Wallets that support this do not need to
+// reserve funds in order to maintain a certain tier, because bonds can be
+// extended before they expire.
+type BondUpdater interface {
+ Bonder
+
+ // UpdateBondTx creates an unsigned transaction that uses the funds locked
+ // in one or more bonds to create a new bond with a longer lockTime. If the
+ // total value of the bonds is greater than the new bond, a "change" bond
+ // will be created with the remaining funds and the same lockTime as the
+ // earliest expiring bond. If two bonds are being created, the "change"
+ // bond will be the first in the returned []*asset.Bond slice.
+ //
+ // Requirements:
+ // - The correct amount of privKeys must be passed, depending on whether
+ // or not a change bond is needed. The first will be used for the
+ // change bond.
+ // - The lockTime must be later than the latest lockTime of the
+ // bondsToUpdate.
+ // - The value of the earliest expiring bond must be greater than the
+ // "change" bond value.
+ // - The bondsToUpdate must all be from the same account.
+ UpdateBondTx(ver uint16, bondsToUpdate []dex.Bytes, privKeys []*secp256k1.PrivateKey, amt uint64, lockTime time.Time) ([]*Bond, error)
+}
+
// Rescanner is a wallet implementation with rescan functionality.
type Rescanner interface {
Rescan(ctx context.Context) error
@@ -1083,6 +1121,7 @@ const (
TicketPurchase
TicketVote
TicketRevocation
+ UpdateBond
)
// IncomingTxType returns true if the wallet's balance increases due to a
@@ -1091,15 +1130,20 @@ func IncomingTxType(txType TransactionType) bool {
return txType == Receive || txType == Redeem || txType == Refund || txType == RedeemBond
}
-// BondTxInfo contains information about a CreateBond or RedeemBond
-// transaction.
+type BondInfo struct {
+ ID string `json:"id"`
+ Amount uint64 `json:"amount"`
+ LockTime uint64 `json:"lockTime"`
+}
+
+// BondTxInfo contains information about a CreateBond, RedeemBond, or
+// UpdateBond transaction.
type BondTxInfo struct {
// AccountID is the account is the account ID that the bond is applied to.
- AccountID dex.Bytes `json:"accountID"`
- // LockTime is the time until which the bond is locked.
- LockTime uint64 `json:"lockTime"`
- // BondID is the ID of the bond.
- BondID dex.Bytes `json:"bondID"`
+ AccountID dex.Bytes `json:"accountID"`
+ Bond *BondInfo `json:"bond"`
+ ChangeBond *BondInfo `json:"changeBond"`
+ ReplacedBonds []*BondInfo `json:"replacedBond"`
}
// WalletTransaction represents a transaction that was made by a wallet.
@@ -1144,11 +1188,12 @@ type WalletHistorian interface {
// the corresponding signed transaction, and a final request is made once the
// bond is fully confirmed. The caller should manage the private key.
type Bond struct {
- Version uint16
- AssetID uint32
- Amount uint64
- CoinID []byte
- Data []byte // additional data to interpret the bond e.g. redeem script, bond contract, etc.
+ Version uint16
+ AssetID uint32
+ Amount uint64
+ CoinID []byte
+ LockTime uint64
+ Data []byte // additional data to interpret the bond e.g. redeem script, bond contract, etc.
// SignedTx and UnsignedTx are the opaque (raw bytes) signed and unsigned
// bond creation transactions, in whatever encoding and funding scheme for
// this asset and wallet. The unsigned one is used to pre-validate this bond
@@ -1159,6 +1204,10 @@ type Bond struct {
// RedeemTx is a backup transaction that spends the bond output. Normally
// the a key index will be used to derive the key when the bond expires.
RedeemTx []byte
+
+ // ReplacedBy is set to the CoinID of the bond that has replaced this bond,
+ // if any.
+ ReplacedBy dex.Bytes
}
// ShieldedStatus is the balance and address associated with the shielded
diff --git a/client/cmd/dexc-desktop/app_darwin.go b/client/cmd/dexc-desktop/app_darwin.go
index 6e03607316..6f801e7bad 100644
--- a/client/cmd/dexc-desktop/app_darwin.go
+++ b/client/cmd/dexc-desktop/app_darwin.go
@@ -244,7 +244,6 @@ func mainCore() error {
<-clientCore.Ready()
var marketMaker *mm.MarketMaker
- var mmCM *dex.ConnectionMaster
if cfg.Experimental {
// TODO: on shutdown, stop market making and wait for trades to be
// canceled.
diff --git a/client/core/bond.go b/client/core/bond.go
index df695c558d..4eafd3fa7e 100644
--- a/client/core/bond.go
+++ b/client/core/bond.go
@@ -7,6 +7,8 @@ import (
"fmt"
"math"
"sort"
+ "strconv"
+ "strings"
"time"
"decred.org/dcrdex/client/asset"
@@ -235,6 +237,7 @@ func (c *Core) updateBondReserves(balanceCheckID ...uint32) {
// asset.
n := uint64(len(bondValues))
feeReserves := n * bonder.BondsFeeBuffer(c.feeSuggestionAny(w.AssetID))
+
// Even if reserves are 0, we may still want to reserve fees for
// renewing bonds.
paddedReserves := nominalReserves + feeReserves
@@ -254,6 +257,7 @@ func (c *Core) updateBondReserves(balanceCheckID ...uint32) {
paddedReserves, unbip(w.AssetID), avail)
}
}
+
bonder.SetBondReserves(paddedReserves)
}
}
@@ -370,20 +374,21 @@ func (c *Core) dexBondConfig(dc *dexConnection, now int64) *dexBondCfg {
type dexAcctBondState struct {
ExchangeAuth
- repost []*asset.Bond
- mustPost int64 // includes toComp
- toComp int64
- inBonds uint64
+ repost []*asset.Bond
+ mustPost int64 // includes toComp
+ toComp int64
+ inBonds uint64
+ weakBonds, strongBonds []*db.Bond
}
-// bondStateOfDEX collects all the information needed to determine what
-// bonds need to be refunded and how much new bonds should be posted.
func (c *Core) bondStateOfDEX(dc *dexConnection, bondCfg *dexBondCfg) *dexAcctBondState {
dc.acct.authMtx.Lock()
defer dc.acct.authMtx.Unlock()
state := new(dexAcctBondState)
- weakBonds := make([]*db.Bond, 0, len(dc.acct.bonds))
+
+ state.weakBonds = make([]*db.Bond, 0, len(dc.acct.bonds))
+ state.strongBonds = make([]*db.Bond, 0, len(dc.acct.bonds))
filterExpiredBonds := func(bonds []*db.Bond) (liveBonds []*db.Bond) {
for _, bond := range bonds {
@@ -395,9 +400,11 @@ func (c *Core) bondStateOfDEX(dc *dexConnection, bondCfg *dexBondCfg) *dexAcctBo
c.log.Infof("Newly expired bond found: %v (%s)", coinIDString(bond.AssetID, bond.CoinID), unbip(bond.AssetID))
} else {
if int64(bond.LockTime) <= bondCfg.replaceThresh {
- weakBonds = append(weakBonds, bond) // but not yet expired (still live or pending)
+ state.weakBonds = append(state.weakBonds, bond) // but not yet expired (still live or pending)
c.log.Infof("Soon to expire bond found: %v (%s)",
coinIDString(bond.AssetID, bond.CoinID), unbip(bond.AssetID))
+ } else {
+ state.strongBonds = append(state.strongBonds, bond)
}
liveBonds = append(liveBonds, bond)
}
@@ -412,7 +419,7 @@ func (c *Core) bondStateOfDEX(dc *dexConnection, bondCfg *dexBondCfg) *dexAcctBo
dc.acct.bonds = filterExpiredBonds(dc.acct.bonds)
dc.acct.pendingBonds = filterExpiredBonds(dc.acct.pendingBonds) // possibly expired before confirmed
state.PendingStrength = sumBondStrengths(dc.acct.pendingBonds, bondCfg.bondAssets)
- state.WeakStrength = sumBondStrengths(weakBonds, bondCfg.bondAssets)
+ state.WeakStrength = sumBondStrengths(state.weakBonds, bondCfg.bondAssets)
state.LiveStrength = sumBondStrengths(dc.acct.bonds, bondCfg.bondAssets) // for max bonded check
state.PendingBonds = dc.pendingBonds()
// Extract the expired bonds.
@@ -473,6 +480,10 @@ func (c *Core) refundExpiredBonds(ctx context.Context, acct *dexAccount, cfg *de
assetIDs := make(map[uint32]struct{})
for _, bond := range state.ExpiredBonds {
+ if bond.ReplacedBy != nil {
+ continue
+ }
+
bondIDStr := fmt.Sprintf("%v (%s)", coinIDString(bond.AssetID, bond.CoinID), unbip(bond.AssetID))
if now < int64(bond.LockTime) {
ttr := time.Duration(int64(bond.LockTime)-now) * time.Second
@@ -617,6 +628,216 @@ func (c *Core) repostPendingBonds(dc *dexConnection, cfg *dexBondCfg, state *dex
}
}
+func bondsForAsset(state *dexAcctBondState, assetID uint32) (weakAndExpired []*db.Bond, strong []*db.Bond) {
+ weakAndExpired = make([]*db.Bond, 0, len(state.weakBonds)+len(state.ExpiredBonds))
+ strong = make([]*db.Bond, 0, len(state.strongBonds))
+
+ for _, b := range state.weakBonds {
+ if b.AssetID == assetID {
+ weakAndExpired = append(weakAndExpired, b)
+ }
+ }
+ for _, b := range state.ExpiredBonds {
+ if b.AssetID == assetID {
+ weakAndExpired = append(weakAndExpired, b)
+ }
+ }
+ for _, b := range state.strongBonds {
+ if b.AssetID == assetID {
+ strong = append(strong, b)
+ }
+ }
+
+ return
+}
+
+func (c *Core) updateBonds(dc *dexConnection, cfg *dexBondCfg, state *dexAcctBondState, wallet *xcWallet, unlocked bool) (bool, error) {
+ if state.TargetTier == 0 || state.mustPost <= 0 || cfg.bondExpiry <= 0 {
+ return false, nil
+ }
+
+ bondAsset := cfg.bondAssets[state.BondAssetID]
+ if bondAsset == nil {
+ return false, nil
+ }
+
+ weakAndExpired, strong := bondsForAsset(state, state.BondAssetID)
+ bondsToUpdate := make([]*db.Bond, 0, len(state.strongBonds)+len(state.weakBonds)+len(state.ExpiredBonds))
+ lockDur := minBondLifetime(c.net, cfg.bondExpiry)
+ lockTime := time.Now().Add(lockDur).Truncate(time.Second)
+
+ // Always include strong bonds that expire prior to the lockTime.
+ var strongBondAmt uint64
+ for _, bond := range strong {
+ if bond.LockTime < uint64(lockTime.Unix()) {
+ bondsToUpdate = append(bondsToUpdate, bond)
+ strongBondAmt += bond.Amount
+ }
+ }
+
+ mustPostAmt := uint64(state.mustPost) * bondAsset.Amt
+
+ // Include weak/expired bonds until the mustPost amount is reached.
+ // Prefer bonds that expire later.
+ sort.Slice(weakAndExpired, func(i, j int) bool {
+ return weakAndExpired[i].LockTime > weakAndExpired[j].LockTime
+ })
+ var reusedBondedAmt uint64
+ for _, bond := range weakAndExpired {
+ bondsToUpdate = append(bondsToUpdate, bond)
+ reusedBondedAmt += bond.Amount
+ if reusedBondedAmt >= mustPostAmt {
+ break
+ }
+ }
+
+ // If there are no bonds to update, then a new bond must be created.
+ if len(bondsToUpdate) == 0 {
+ return false, nil
+ }
+
+ var additionalAmtRequired uint64
+ if reusedBondedAmt < mustPostAmt {
+ additionalAmtRequired = mustPostAmt - reusedBondedAmt
+ }
+
+ amtToPost := additionalAmtRequired
+
+ // Make sure we're not posting more than MaxBondedAmt
+ if state.MaxBondedAmt > 0 {
+ expiredStrength := sumBondStrengths(state.ExpiredBonds, cfg.bondAssets)
+ currentlyBondedAmt := uint64(state.PendingStrength+state.LiveStrength+expiredStrength) * bondAsset.Amt
+ if currentlyBondedAmt >= state.MaxBondedAmt {
+ // If greater then something went wrong...
+ amtToPost = 0
+ } else if currentlyBondedAmt+amtToPost > state.MaxBondedAmt {
+ amtToPost = state.MaxBondedAmt - currentlyBondedAmt
+ }
+ }
+ amtToPost = amtToPost / bondAsset.Amt * bondAsset.Amt // round down to nearest bond size
+
+ // Make sure the new bond is not larger than we need
+ newBondSize := reusedBondedAmt + strongBondAmt + amtToPost
+ totalRequired := strongBondAmt + uint64(state.mustPost)*bondAsset.Amt
+ if totalRequired < newBondSize {
+ newBondSize = totalRequired
+ }
+
+ bondKeys := make([]*secp256k1.PrivateKey, 0, 2)
+ keyIndexes := make([]uint32, 0, 2)
+
+ // Will always create at least one new bond.
+ bondKey, keyIndex, err := c.nextBondKey(bondAsset.ID)
+ defer bondKey.Zero()
+ if err != nil {
+ return false, err
+ }
+ bondKeys = append(bondKeys, bondKey)
+ keyIndexes = append(keyIndexes, keyIndex)
+
+ // If we reusing more than the size of the new bond, we need
+ // a "change" bond.
+ if reusedBondedAmt+strongBondAmt > newBondSize {
+ bondKey, keyIndex, err := c.nextBondKey(bondAsset.ID)
+ defer bondKey.Zero()
+ if err != nil {
+ return false, err
+ }
+ bondKeys = append(bondKeys, bondKey)
+ keyIndexes = append(keyIndexes, keyIndex)
+ }
+
+ bondIDsToUpdate := make([]dex.Bytes, 0, len(bondsToUpdate))
+ for _, bond := range bondsToUpdate {
+ bondIDsToUpdate = append(bondIDsToUpdate, bond.CoinID)
+ }
+
+ newBonds, err := wallet.UpdateBondTx(bondAsset.Version, bondIDsToUpdate, bondKeys, newBondSize, lockTime)
+ if err != nil {
+ return false, codedError(bondPostErr, err)
+ }
+
+ nonChangeBond := newBonds[0]
+ if len(newBonds) == 2 {
+ nonChangeBond = newBonds[1]
+ }
+ err = c.preValidateBond(dc, nonChangeBond)
+ if err != nil {
+ return false, err
+ }
+
+ newDBBonds := make([]*db.Bond, 0, len(newBonds)+len(bondsToUpdate))
+ var replacementBondID dex.Bytes
+ for i, bond := range newBonds {
+ newDBBonds = append(newDBBonds, &db.Bond{
+ Version: bond.Version,
+ AssetID: bond.AssetID,
+ CoinID: bond.CoinID,
+ UnsignedTx: bond.UnsignedTx,
+ SignedTx: bond.SignedTx,
+ Data: bond.Data,
+ Amount: bond.Amount,
+ LockTime: bond.LockTime,
+ KeyIndex: keyIndexes[i],
+ RefundTx: bond.RedeemTx,
+ })
+ replacementBondID = bond.CoinID
+ }
+ for _, updatedBond := range bondsToUpdate {
+ updatedBond.ReplacedBy = replacementBondID
+ newDBBonds = append(newDBBonds, updatedBond)
+ }
+
+ err = c.db.AddBonds(dc.acct.host, newDBBonds)
+ if err != nil {
+ return false, err
+ }
+
+ removeBond := func(bondsList *[]*db.Bond, coinID dex.Bytes) bool {
+ list := *bondsList
+ for i, bond := range list {
+ if bytes.Equal(bond.CoinID, coinID) {
+ newList := append(list[:i], list[i+1:]...)
+ *bondsList = newList
+ return true
+ }
+ }
+ return false
+ }
+
+ // Add the newly created bond(s) to pendingBonds, and remove the replaced bonds.
+ dc.acct.authMtx.Lock()
+ for i, bond := range newDBBonds {
+ if i < len(newBonds) {
+ dc.acct.pendingBonds = append(dc.acct.pendingBonds, bond)
+ } else {
+ if !(removeBond(&dc.acct.bonds, bond.CoinID) || removeBond(&dc.acct.pendingBonds, bond.CoinID) || removeBond(&dc.acct.expiredBonds, bond.CoinID)) {
+ c.log.Warnf("Failed to remove replaced bond %s from account", bond.CoinID)
+ }
+ }
+ }
+ dc.acct.authMtx.Unlock()
+
+ if txCast, err := wallet.SendTransaction(newBonds[0].SignedTx); err != nil {
+ c.log.Warnf("Failed to broadcast update bond tx (%v). Tx bytes: %x", err, newBonds[0].SignedTx)
+ } else {
+ c.log.Infof("Broadcasted update bond tx %v", txCast)
+ }
+
+ c.updateAssetBalance(state.BondAssetID)
+
+ for _, bond := range newBonds {
+ bondCoinStr := coinIDString(bond.AssetID, bond.CoinID)
+ details := fmt.Sprintf("Waiting for %d confirmations to post bond %v (%s) to %s",
+ bondAsset.Confs, bondCoinStr, unbip(bond.AssetID), dc.acct.host) // TODO: subject, detail := c.formatDetails(...)
+ c.notify(newBondPostNoteWithConfirmations(TopicBondConfirming, string(TopicBondConfirming),
+ details, db.Success, bond.AssetID, bondCoinStr, 0, dc.acct.host, &state.ExchangeAuth))
+ c.monitorBondConfs(dc, bond, bondAsset.Confs)
+ }
+
+ return true, nil
+}
+
// postRequiredBonds posts any required bond increments for a dexConnection.
func (c *Core) postRequiredBonds(
dc *dexConnection,
@@ -708,9 +929,24 @@ func (c *Core) rotateBonds(ctx context.Context) {
bondCfg := c.dexBondConfig(dc, now)
acctBondState := c.bondStateOfDEX(dc, bondCfg)
-
c.repostPendingBonds(dc, bondCfg, acctBondState, unlocked)
+ wallet, err := c.connectedWallet(acctBondState.BondAssetID)
+ if err != nil {
+ if acctBondState.TargetTier > 0 {
+ c.log.Errorf("%v wallet not available for bonds: %v", unbip(acctBondState.BondAssetID), err)
+ }
+ continue
+ }
+
+ var updatePerformed bool
+ if _, isUpdater := wallet.Wallet.(asset.BondUpdater); isUpdater {
+ updatePerformed, err = c.updateBonds(dc, bondCfg, acctBondState, wallet, unlocked)
+ if err != nil {
+ c.log.Errorf("Error while trying to update bonds for %v: %v", dc.acct.host, err)
+ }
+ }
+
refundedAssets, expiredStrength, err := c.refundExpiredBonds(ctx, dc.acct, bondCfg, acctBondState, now)
if err != nil {
c.log.Errorf("Failed to refund expired bonds for %v: %v", dc.acct.host, err)
@@ -728,15 +964,9 @@ func (c *Core) rotateBonds(ctx context.Context) {
continue
}
- wallet, err := c.connectedWallet(acctBondState.BondAssetID)
- if err != nil {
- if acctBondState.TargetTier > 0 {
- c.log.Errorf("%v wallet not available for bonds: %v", unbip(acctBondState.BondAssetID), err)
- }
- continue
+ if !updatePerformed {
+ c.postRequiredBonds(dc, bondCfg, acctBondState, bondAsset, wallet, expiredStrength, unlocked)
}
-
- c.postRequiredBonds(dc, bondCfg, acctBondState, bondAsset, wallet, expiredStrength, unlocked)
}
c.updateBondReserves()
@@ -780,6 +1010,8 @@ func (c *Core) preValidateBond(dc *dexConnection, bond *asset.Bond) error {
return nil
}
+var errAlreadyConfirming = fmt.Errorf("bond already confirming")
+
func (c *Core) postBond(dc *dexConnection, bond *asset.Bond) (*msgjson.PostBondResult, error) {
if len(dc.acct.encKey) == 0 {
return nil, fmt.Errorf("uninitialized account")
@@ -804,6 +1036,9 @@ func (c *Core) postBond(dc *dexConnection, bond *asset.Bond) (*msgjson.PostBondR
postBondRes := new(msgjson.PostBondResult)
err := dc.signAndRequest(postBond, msgjson.PostBondRoute, postBondRes, DefaultResponseTimeout)
if err != nil {
+ if strings.Contains(err.Error(), strconv.Itoa(msgjson.BondAlreadyConfirmingError)) {
+ return nil, errAlreadyConfirming
+ }
return nil, codedError(registerErr, err)
}
@@ -834,6 +1069,11 @@ func (c *Core) postAndConfirmBond(dc *dexConnection, bond *asset.Bond) {
// bond will be active (and account created if new) and we should confirm
// the bond (in DB and dc.acct.{bond,pendingBonds}).
pbr, err := c.postBond(dc, bond) // can be long while server searches
+ if errors.Is(err, errAlreadyConfirming) {
+ // No need for error notification if is server still confirming.
+ c.log.Warnf("Still waiting for server to confirm bond: %s", coinIDStr)
+ return
+ }
if err != nil {
subject, details := c.formatDetails(TopicBondPostError, err, err)
c.notify(newBondPostNote(TopicBondPostError, subject, details, db.ErrorLevel, dc.acct.host))
@@ -861,7 +1101,8 @@ func (c *Core) monitorBondConfs(dc *dexConnection, bond *asset.Bond, reqConfs ui
c.log.Errorf("No connected wallet for asset %v: %v", unbip(assetID), err)
return
}
- lastConfs, err := wallet.RegFeeConfirmations(c.ctx, coinID)
+
+ lastConfs, err := wallet.BondConfirmations(c.ctx, coinID)
coinNotFound := errors.Is(err, asset.CoinNotFoundError)
if err != nil && !coinNotFound {
c.log.Errorf("Error getting confirmations for %s: %w", coinIDStr, err)
@@ -892,7 +1133,7 @@ func (c *Core) monitorBondConfs(dc *dexConnection, bond *asset.Bond, reqConfs ui
trigger := func() (bool, error) {
// Retrieve the current wallet in case it was reconfigured.
wallet, _ := c.wallet(assetID) // We already know the wallet is there by now.
- confs, err := wallet.RegFeeConfirmations(c.ctx, coinID)
+ confs, err := wallet.BondConfirmations(c.ctx, coinID)
if err != nil && !errors.Is(err, asset.CoinNotFoundError) {
return false, fmt.Errorf("Error getting confirmations for %s: %w", coinIDStr, err)
}
diff --git a/client/core/core.go b/client/core/core.go
index 493d3ca08f..6dac0ebdc5 100644
--- a/client/core/core.go
+++ b/client/core/core.go
@@ -8469,7 +8469,7 @@ func (c *Core) startDexConnection(acctInfo *db.AccountInfo, dc *dexConnection) e
defer dc.acct.authMtx.Unlock()
for _, dbBond := range acctInfo.Bonds {
- if dbBond.Refunded { // maybe don't even load these, but it may be of use for record keeping
+ if dbBond.Refunded || dbBond.ReplacedBy != nil { // maybe don't even load these, but it may be of use for record keeping
continue
}
diff --git a/client/core/core_test.go b/client/core/core_test.go
index 0f6a6d8ba5..f9fe4ea077 100644
--- a/client/core/core_test.go
+++ b/client/core/core_test.go
@@ -365,6 +365,7 @@ type TDB struct {
acctErr error
createAccountErr error
addBondErr error
+ addBondsErr error
storeAccountProofErr error
updateOrderErr error
activeDEXOrders []*db.MetaOrder
@@ -429,6 +430,10 @@ func (tdb *TDB) AddBond(host string, bond *db.Bond) error {
return tdb.addBondErr
}
+func (tdb *TDB) AddBonds(host string, bonds []*db.Bond) error {
+ return tdb.addBondsErr
+}
+
func (tdb *TDB) ConfirmBond(host string, assetID uint32, bondCoinID []byte) error {
return nil
}
@@ -648,6 +653,7 @@ func (r *tReceipt) SignedRefund() dex.Bytes {
}
type TXCWallet struct {
+ assetID uint32
swapSize uint64
sendFeeSuggestion uint64
sendCoin *tCoin
@@ -700,6 +706,7 @@ type TXCWallet struct {
feeCoin []byte
makeRegFeeTxErr error
feeCoinSent []byte
+ sentRawTransaction []byte
sendTxnErr error
contractExpired bool
contractLockTime time.Time
@@ -721,9 +728,11 @@ type TXCWallet struct {
bondTxCoinID []byte
refundBondCoin asset.Coin
refundBondErr error
+ makeBondTxRes *asset.Bond
makeBondTxErr error
reserves atomic.Uint64
+ refundBondCoinParam dex.Bytes
confirmRedemptionResult *asset.ConfirmRedemptionStatus
confirmRedemptionErr error
confirmRedemptionCalled bool
@@ -754,6 +763,7 @@ func newTWallet(assetID uint32) (*xcWallet, *TXCWallet) {
SupportedVersions: []uint32{0},
},
bondTxCoinID: encode.RandomBytes(32),
+ assetID: assetID,
}
var broadcasting uint32 = 1
xcWallet := &xcWallet{
@@ -946,6 +956,7 @@ func (w *TXCWallet) Send(address string, value, feeSuggestion uint64) (asset.Coi
}
func (w *TXCWallet) SendTransaction(rawTx []byte) ([]byte, error) {
+ w.sentRawTransaction = rawTx
return w.feeCoinSent, w.sendTxnErr
}
@@ -1097,6 +1108,10 @@ func (*TXCWallet) FundMultiOrder(ord *asset.MultiOrder, maxLock uint64) (coins [
var _ asset.Bonder = (*TXCWallet)(nil)
+func (w *TXCWallet) BondConfirmations(ctx context.Context, id dex.Bytes) (confs uint32, err error) {
+ return w.tConfirmations(ctx, id)
+}
+
func (*TXCWallet) BondsFeeBuffer(feeRate uint64) uint64 {
return 4 * 1000 * feeRate * 2
}
@@ -1113,6 +1128,9 @@ func (w *TXCWallet) MakeBondTx(ver uint16, amt, feeRate uint64, lockTime time.Ti
if w.makeBondTxErr != nil {
return nil, nil, w.makeBondTxErr
}
+ if w.makeBondTxRes != nil {
+ return w.makeBondTxRes, func() {}, nil
+ }
return &asset.Bond{
Version: ver,
AssetID: dcrBondAsset.ID,
@@ -1125,6 +1143,8 @@ func (w *TXCWallet) TransactionConfirmations(ctx context.Context, txID string) (
return 0, nil
}
+var _ asset.Bonder = (*TXCWallet)(nil)
+
type TAccountLocker struct {
*TXCWallet
reserveNRedemptions uint64
@@ -1149,6 +1169,46 @@ func newTAccountLocker(assetID uint32) (*xcWallet, *TAccountLocker) {
return xcWallet, accountLocker
}
+type TUpdateBonder struct {
+ *TXCWallet
+ lastUpdateBondTxParams *updateBondParams
+ updateBondTxRes []*asset.Bond
+ updateBondTxErr error
+}
+
+var _ asset.BondUpdater = (*TUpdateBonder)(nil)
+
+func newTUpdateBonder(assetID uint32) (*xcWallet, *TUpdateBonder) {
+ xcWallet, tWallet := newTWallet(assetID)
+ updateBonder := &TUpdateBonder{TXCWallet: tWallet}
+ xcWallet.Wallet = updateBonder
+ return xcWallet, updateBonder
+}
+
+type updateBondParams struct {
+ ver uint16
+ bonds []dex.Bytes
+ privKeys []*secp256k1.PrivateKey
+ amt uint64
+ lockTime time.Time
+}
+
+func (w *TUpdateBonder) UpdateBondTx(ver uint16, bondsToUpdate []dex.Bytes, privKeys []*secp256k1.PrivateKey, amt uint64, lockTime time.Time) ([]*asset.Bond, error) {
+ if w.updateBondTxErr != nil {
+ return nil, w.updateBondTxErr
+ }
+
+ w.lastUpdateBondTxParams = &updateBondParams{
+ ver: ver,
+ bonds: bondsToUpdate,
+ privKeys: privKeys,
+ amt: amt,
+ lockTime: lockTime,
+ }
+
+ return w.updateBondTxRes, nil
+}
+
func (w *TAccountLocker) ReserveNRedemptions(n uint64, ver uint32, maxFeeRate uint64) (uint64, error) {
return w.reserveNRedemptions, w.reserveNRedemptionsErr
}
@@ -1412,19 +1472,21 @@ func (rig *testRig) queueRegister(regRes *msgjson.RegisterResult) {
})
}
-func (rig *testRig) queuePrevalidateBond() {
+func (rig *testRig) queuePrevalidateBond(res *msgjson.PreValidateBondResult) {
rig.ws.queueResponse(msgjson.PreValidateBondRoute, func(msg *msgjson.Message, f msgFunc) error {
preEval := new(msgjson.PreValidateBond)
msg.Unmarshal(preEval)
- preEvalResult := &msgjson.PreValidateBondResult{
- AccountID: rig.dc.acct.id[:],
- AssetID: preEval.AssetID,
- Amount: dcrBondAsset.Amt,
- // Expiry: ,
+ if res == nil {
+ res = &msgjson.PreValidateBondResult{
+ AccountID: rig.dc.acct.id[:],
+ AssetID: preEval.AssetID,
+ Amount: dcrBondAsset.Amt,
+ // Expiry: ,
+ }
}
- sign(tDexPriv, preEvalResult)
- resp, _ := msgjson.NewResponse(msg.ID, preEvalResult, nil)
+ sign(tDexPriv, res)
+ resp, _ := msgjson.NewResponse(msg.ID, res, nil)
f(resp)
return nil
})
@@ -2110,7 +2172,7 @@ func TestPostBond(t *testing.T) {
}
queuePostBondSequence := func() {
- rig.queuePrevalidateBond()
+ rig.queuePrevalidateBond(nil)
rig.queuePostBond(postBondResult)
queueTipChange()
rig.queueNotifyFee()
@@ -10755,14 +10817,14 @@ func TestRotateBonds(t *testing.T) {
acct.maxBondedAmt = maxBondedPerTier * targetTier
acct.bondAsset = bondAsset.ID
tDcrWallet.bal = &asset.Balance{Available: bondAsset.Amt*targetTier + bondFeeBuffer}
- rig.queuePrevalidateBond()
+ rig.queuePrevalidateBond(nil)
run(1, 0, bondAsset.Amt+bondFeeBuffer)
// Post and then expire the bond. This first bond should move to expired and we
// should create another bond.
acct.bonds, acct.pendingBonds = acct.pendingBonds, nil
acct.bonds[0].LockTime = locktimeExpired
- rig.queuePrevalidateBond()
+ rig.queuePrevalidateBond(nil)
// The newly expired bond will be refunded in time to fund our next round,
// so we only need fees reserved.
run(1, 1, bondFeeBuffer)
@@ -10776,7 +10838,7 @@ func TestRotateBonds(t *testing.T) {
// Make the live bond weak. Should get a pending bond. Only fees reserves,
// because we still have an expired bond.
acct.bonds[0].LockTime = weakTimeThresh - 1
- rig.queuePrevalidateBond()
+ rig.queuePrevalidateBond(nil)
run(1, 1, bondFeeBuffer)
// Refund the expired bond
@@ -10787,7 +10849,7 @@ func TestRotateBonds(t *testing.T) {
acct.targetTier = 2
acct.bonds = nil
- rig.queuePrevalidateBond()
+ rig.queuePrevalidateBond(nil)
run(2, 0, bondAsset.Amt*2+bondFeeBuffer)
// Check that a new bond will be scheduled for merge with an existing bond
@@ -10795,7 +10857,7 @@ func TestRotateBonds(t *testing.T) {
acct.bonds = append(acct.bonds, acct.pendingBonds[0])
acct.pendingBonds = nil
acct.bonds[0].LockTime = mergeableLocktimeThresh + 5
- rig.queuePrevalidateBond()
+ rig.queuePrevalidateBond(nil)
run(1, 0, 2*bondAsset.Amt+bondFeeBuffer)
mergingBond := acct.pendingBonds[0]
if mergingBond.LockTime != acct.bonds[0].LockTime {
@@ -10805,10 +10867,294 @@ func TestRotateBonds(t *testing.T) {
// Same thing, but without the merge, just to check our threshold calc.
acct.pendingBonds = nil
acct.bonds[0].LockTime = mergeableLocktimeThresh - 1
- rig.queuePrevalidateBond()
+ rig.queuePrevalidateBond(nil)
run(1, 0, 2*bondAsset.Amt+bondFeeBuffer)
unmergingBond := acct.pendingBonds[0]
if unmergingBond.LockTime == acct.bonds[0].LockTime {
t.Fatalf("Unmergeable bond was scheduled for merged")
}
}
+
+func TestRotateBondsUpdater(t *testing.T) {
+ bondAmt := uint64(1e7)
+
+ bondAssets := map[string]*msgjson.BondAsset{
+ tUTXOAssetA.Symbol: {
+ Version: 0,
+ ID: tUTXOAssetA.ID,
+ Confs: 2,
+ Amt: bondAmt,
+ },
+ tUTXOAssetB.Symbol: {
+ Version: 0,
+ ID: tUTXOAssetB.ID,
+ Confs: 2,
+ Amt: bondAmt / 2,
+ },
+ }
+
+ bondIDs := make([]dex.Bytes, 0, 6)
+ for i := 0; i < 6; i++ {
+ bondIDs = append(bondIDs, encode.RandomBytes(32))
+ }
+
+ newBond := func(assetID uint32, coinID dex.Bytes, lockTime uint64, amt uint64) *db.Bond {
+ return &db.Bond{
+ AssetID: assetID,
+ CoinID: coinID,
+ LockTime: lockTime,
+ Amount: amt,
+ }
+ }
+
+ now := uint64(time.Now().Unix())
+ bondExpiry := uint64(60 * 60)
+ lockDur := minBondLifetime(dex.Mainnet, int64(bondExpiry))
+ lockTime := time.Now().Add(lockDur).Truncate(time.Second)
+ weakBondThreshold := uint64(time.Now().Unix() + int64(bondExpiry) + pendingBuffer(dex.Mainnet))
+
+ pk := func() *secp256k1.PrivateKey {
+ pk, _ := secp256k1.GeneratePrivateKey()
+ return pk
+ }
+
+ tests := []struct {
+ name string
+
+ bonds []*db.Bond
+ pendingBonds []*db.Bond
+ expiredBonds []*db.Bond
+ targetTier uint64
+ makeBondTxRes *asset.Bond
+ updateBondTxRes []*asset.Bond
+ maxBondedAmt uint64
+
+ expUpdateBondParams *updateBondParams
+ expExpiredBonds []*db.Bond
+ expPendingBonds []*db.Bond
+ expBonds []*db.Bond
+ }{
+ {
+ name: "no bonds to update",
+ targetTier: 4,
+ bonds: []*db.Bond{},
+ makeBondTxRes: &asset.Bond{
+ CoinID: bondIDs[0],
+ AssetID: tUTXOAssetA.ID,
+ Amount: 4 * bondAmt,
+ },
+ expPendingBonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[0], 0, 4*bondAmt),
+ },
+ },
+ {
+ name: "1 strong, 1 weak, need additional",
+ targetTier: 4,
+ bonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[0], weakBondThreshold+1, 2*bondAmt), // strong
+ newBond(tUTXOAssetA.ID, bondIDs[1], weakBondThreshold, 1*bondAmt), // weak
+ },
+ updateBondTxRes: []*asset.Bond{{
+ CoinID: bondIDs[2],
+ AssetID: tUTXOAssetA.ID,
+ Amount: 4 * bondAmt,
+ }},
+ expUpdateBondParams: &updateBondParams{
+ bonds: []dex.Bytes{
+ bondIDs[0], bondIDs[1],
+ },
+ lockTime: lockTime,
+ privKeys: []*secp256k1.PrivateKey{pk()},
+ amt: 4 * bondAmt,
+ },
+ expPendingBonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[2], 0, 4*bondAmt),
+ },
+ },
+ {
+ name: "1 strong, 1 weak, 1 expired, need change",
+ targetTier: 4,
+ bonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[0], weakBondThreshold+1, 2*bondAmt), // strong
+ newBond(tUTXOAssetA.ID, bondIDs[1], weakBondThreshold, bondAmt), // weak
+ },
+ expiredBonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[2], now, 2*bondAmt),
+ },
+ updateBondTxRes: []*asset.Bond{{
+ CoinID: bondIDs[3],
+ AssetID: tUTXOAssetA.ID,
+ Amount: 4 * bondAmt,
+ }},
+ expUpdateBondParams: &updateBondParams{
+ bonds: []dex.Bytes{
+ bondIDs[0], bondIDs[1], bondIDs[2],
+ },
+ lockTime: lockTime,
+ privKeys: []*secp256k1.PrivateKey{pk(), pk()},
+ amt: 4 * bondAmt,
+ },
+ expPendingBonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[3], 0, 4*bondAmt),
+ },
+ },
+ {
+ name: "1 strong, 1 weak, 1 expired, no additional, no change",
+ targetTier: 4,
+ bonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[0], weakBondThreshold+1, 2*bondAmt), // strong
+ newBond(tUTXOAssetA.ID, bondIDs[1], weakBondThreshold, bondAmt), // weak
+ },
+ expiredBonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[2], now, 1*bondAmt),
+ },
+ updateBondTxRes: []*asset.Bond{{
+ CoinID: bondIDs[3],
+ AssetID: tUTXOAssetA.ID,
+ Amount: 4 * bondAmt,
+ }},
+ expUpdateBondParams: &updateBondParams{
+ bonds: []dex.Bytes{
+ bondIDs[0], bondIDs[1], bondIDs[2],
+ },
+ lockTime: lockTime,
+ privKeys: []*secp256k1.PrivateKey{pk()},
+ amt: 4 * bondAmt,
+ },
+ expPendingBonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[3], 0, 4*bondAmt),
+ },
+ },
+ {
+ name: "ensure max bonded amt is respected",
+ maxBondedAmt: 4 * bondAmt,
+ targetTier: 5,
+ bonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[0], weakBondThreshold+1, 2*bondAmt), // strong
+ newBond(tUTXOAssetA.ID, bondIDs[1], weakBondThreshold, 1*bondAmt), // weak
+ },
+ updateBondTxRes: []*asset.Bond{{
+ CoinID: bondIDs[2],
+ AssetID: tUTXOAssetA.ID,
+ Amount: 4 * bondAmt,
+ }},
+ expUpdateBondParams: &updateBondParams{
+ bonds: []dex.Bytes{
+ bondIDs[0], bondIDs[1],
+ },
+ lockTime: lockTime,
+ privKeys: []*secp256k1.PrivateKey{pk()},
+ amt: 4 * bondAmt,
+ },
+ expPendingBonds: []*db.Bond{
+ newBond(tUTXOAssetA.ID, bondIDs[2], 0, 4*bondAmt),
+ },
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ rig := newTestRig()
+ defer rig.shutdown()
+ tCore := rig.core
+
+ dcrWallet, tDCRWallet := newTUpdateBonder(tUTXOAssetA.ID)
+ tCore.wallets[tUTXOAssetA.ID] = dcrWallet
+ tDCRWallet.contractExpired = true
+ tDCRWallet.refundBondCoin = &tCoin{id: encode.RandomBytes(32), val: 1e11}
+ tDCRWallet.updateBondTxRes = test.updateBondTxRes
+ tDCRWallet.makeBondTxRes = test.makeBondTxRes
+
+ err := rig.core.Login(tPW)
+ if err != nil {
+ t.Fatalf("initial Login error: %v", err)
+ }
+
+ dc := rig.core.conns[tDexHost]
+ dc.cfg = &msgjson.ConfigResult{
+ BondAssets: bondAssets,
+ BondExpiry: bondExpiry,
+ }
+ acct := rig.dc.acct
+ acct.isAuthed = true
+ acct.targetTier = test.targetTier
+ acct.expiredBonds = test.expiredBonds
+ acct.pendingBonds = test.pendingBonds
+ acct.bonds = test.bonds
+ acct.maxBondedAmt = test.maxBondedAmt
+ dc.acct.bondAsset = tUTXOAssetA.ID
+
+ var bondAmt uint64
+ if test.makeBondTxRes != nil {
+ bondAmt = test.makeBondTxRes.Amount
+ } else {
+ bondAmt = test.updateBondTxRes[len(test.updateBondTxRes)-1].Amount
+ }
+ rig.queuePrevalidateBond(&msgjson.PreValidateBondResult{
+ Amount: bondAmt,
+ })
+
+ rig.core.rotateBonds(rig.core.ctx)
+
+ exp := test.expUpdateBondParams
+ got := tDCRWallet.lastUpdateBondTxParams
+ if (exp == nil) != (got == nil) {
+ t.Fatalf("%s: expected %v, got %v", test.name, exp, got)
+ }
+ if test.expUpdateBondParams != nil {
+ if !reflect.DeepEqual(exp.bonds, got.bonds) {
+ t.Fatalf("expected %v, got %v", exp.bonds, got.bonds)
+ }
+ if got.lockTime.Before(exp.lockTime) || got.lockTime.After(exp.lockTime.Add(20*time.Second)) {
+ t.Fatalf("expected %v, got %v", exp.lockTime, got.lockTime)
+ }
+ if exp.amt != got.amt {
+ t.Fatalf("expected %v, got %v", exp.amt, got.amt)
+ }
+ if len(exp.privKeys) != len(got.privKeys) {
+ t.Fatalf("expected %v, got %v", len(exp.privKeys), len(got.privKeys))
+ }
+ }
+
+ bondsEqual := func(b1, b2 *db.Bond) bool {
+ if b1.Amount != b2.Amount {
+ return false
+ }
+ if b1.AssetID != b2.AssetID {
+ return false
+ }
+ if !bytes.Equal(b1.CoinID, b2.CoinID) {
+ return false
+ }
+ return true
+ }
+
+ if len(test.expExpiredBonds) != len(dc.acct.expiredBonds) {
+ t.Fatalf("expected %d expired bonds, got %d", len(test.expExpiredBonds), len(dc.acct.expiredBonds))
+ }
+ for i, bond := range test.expExpiredBonds {
+ if !bondsEqual(bond, dc.acct.expiredBonds[i]) {
+ t.Fatalf("expected expired bond %v, got %v", bond, dc.acct.expiredBonds[i])
+ }
+ }
+
+ if len(test.expPendingBonds) != len(dc.acct.pendingBonds) {
+ t.Fatalf("expected %d pending bonds, got %d", len(test.expPendingBonds), len(dc.acct.pendingBonds))
+ }
+ for i, bond := range test.expPendingBonds {
+ if !bondsEqual(bond, dc.acct.pendingBonds[i]) {
+ t.Fatalf("expected pending bond %v, got %v", bond, dc.acct.pendingBonds[i])
+ }
+ }
+
+ if len(test.expBonds) != len(dc.acct.bonds) {
+ t.Fatalf("expected %d bonds, got %d", len(test.expBonds), len(dc.acct.bonds))
+ }
+ for i, bond := range test.expBonds {
+ if !bondsEqual(bond, dc.acct.bonds[i]) {
+ t.Fatalf("expected bond %v, got %v", bond, dc.acct.bonds[i])
+ }
+ }
+ })
+ }
+}
diff --git a/client/core/wallet.go b/client/core/wallet.go
index 8e8f080143..c8037cccf4 100644
--- a/client/core/wallet.go
+++ b/client/core/wallet.go
@@ -571,6 +571,17 @@ func (w *xcWallet) BondsFeeBuffer(feeRate uint64) uint64 {
return bonder.BondsFeeBuffer(feeRate)
}
+// UpdateBondTx authors a transaction that uses previouly created bonds to
+// create a new DEX time-locked fidelity bond transaction. This only works
+// if the asset.Wallet implementation is a BondUpdater.
+func (w *xcWallet) UpdateBondTx(ver uint16, bondsToUpdate []dex.Bytes, privKeys []*secp256k1.PrivateKey, amt uint64, lockTime time.Time) ([]*asset.Bond, error) {
+ bonder, ok := w.Wallet.(asset.BondUpdater)
+ if !ok {
+ return nil, errors.New("wallet does not support updating bond transactions")
+ }
+ return bonder.UpdateBondTx(ver, bondsToUpdate, privKeys, amt, lockTime)
+}
+
// RefundBond will refund the bond if the asset.Wallet implementation is a
// Bonder. The lock time must be passed to spend the bond. LockTimeExpired
// should be used to check first.
@@ -582,6 +593,16 @@ func (w *xcWallet) RefundBond(ctx context.Context, ver uint16, coinID, script []
return bonder.RefundBond(ctx, ver, coinID, script, amt, priv)
}
+// BondConfirmations returns the amount of confirmations of a bond if the
+// asset.Wallet implementation is a Bonder.s
+func (w *xcWallet) BondConfirmations(ctx context.Context, bondID dex.Bytes) (uint32, error) {
+ bonder, ok := w.Wallet.(asset.Bonder)
+ if !ok {
+ return 0, errors.New("wallet does not support bond confirmations")
+ }
+ return bonder.BondConfirmations(ctx, bondID)
+}
+
// SendTransaction broadcasts a raw transaction if the wallet is a Broadcaster.
func (w *xcWallet) SendTransaction(tx []byte) ([]byte, error) {
bonder, ok := w.Wallet.(asset.Broadcaster)
diff --git a/client/db/bolt/db.go b/client/db/bolt/db.go
index 4a030294e3..0013107549 100644
--- a/client/db/bolt/db.go
+++ b/client/db/bolt/db.go
@@ -85,6 +85,7 @@ var (
confirmedKey = []byte("confirmed")
refundedKey = []byte("refunded")
lockTimeKey = []byte("lockTime")
+ replacedByKey = []byte("replacedBy")
dexKey = []byte("dex")
updateTimeKey = []byte("utime")
accountKey = []byte("account")
@@ -839,6 +840,11 @@ func (db *BoltDB) storeBond(bondBkt *bbolt.Bucket, bond *db.Bond) error {
return fmt.Errorf("lockTimeKey put error: %w", err)
}
+ err = bondBkt.Put(replacedByKey, bond.ReplacedBy)
+ if err != nil {
+ return fmt.Errorf("replacedByKey put error: %w", err)
+ }
+
return nil
}
@@ -867,6 +873,37 @@ func (db *BoltDB) AddBond(host string, bond *db.Bond) error {
})
}
+// AddBonds saves a slice of new Bonds or updates existing bonds for an existing
+// DEX account.
+func (db *BoltDB) AddBonds(host string, bondsSlice []*db.Bond) error {
+ acctKey := []byte(host)
+ return db.acctsUpdate(func(accts *bbolt.Bucket) error {
+ acct := accts.Bucket(acctKey)
+ if acct == nil {
+ return fmt.Errorf("account not found for %s", host)
+ }
+
+ bonds, err := acct.CreateBucketIfNotExists(bondsSubBucket)
+ if err != nil {
+ return fmt.Errorf("unable to access bonds sub-bucket for account for %s: %w", host, err)
+ }
+
+ for _, bond := range bondsSlice {
+ bondUID := bond.UniqueID()
+ bondBkt, err := bonds.CreateBucketIfNotExists(bondUID)
+ if err != nil {
+ return fmt.Errorf("failed to create bond %x bucket: %w", bondUID, err)
+ }
+
+ if err := db.storeBond(bondBkt, bond); err != nil {
+ return err
+ }
+ }
+
+ return nil
+ })
+}
+
func (db *BoltDB) setBondFlag(host string, assetID uint32, bondCoinID []byte, flagKey []byte) error {
acctKey := []byte(host)
return db.acctsUpdate(func(accts *bbolt.Bucket) error {
diff --git a/client/db/interface.go b/client/db/interface.go
index 6145587b2e..d781e41123 100644
--- a/client/db/interface.go
+++ b/client/db/interface.go
@@ -40,6 +40,8 @@ type DB interface {
UpdateAccountInfo(ai *AccountInfo) error
// AddBond saves a new Bond or updates an existing bond for a DEX.
AddBond(host string, bond *Bond) error
+ // AddBonds saves new bonds or updates existing bonds for a DEX.
+ AddBonds(host string, bondsSlice []*Bond) error
// NextBondKeyIndex returns the next bond key index and increments the
// stored value so that subsequent calls will always return a higher index.
NextBondKeyIndex(assetID uint32) (uint32, error)
diff --git a/client/db/types.go b/client/db/types.go
index 244808fe9e..cb30e10b38 100644
--- a/client/db/types.go
+++ b/client/db/types.go
@@ -106,6 +106,7 @@ type Bond struct {
LockTime uint64 `json:"lockTime"`
KeyIndex uint32 `json:"keyIndex"` // child key index for HD path: m / hdKeyPurposeBonds / assetID' / bondIndex
RefundTx dex.Bytes `json:"refundTx"` // pays to wallet that created it - only a backup for emergency!
+ ReplacedBy dex.Bytes `json:"replacedBy"`
Confirmed bool `json:"confirmed"` // if reached required confs according to server, not in serialization
Refunded bool `json:"refunded"` // not in serialization
@@ -120,7 +121,7 @@ func (b *Bond) UniqueID() []byte {
// Encode serialized the Bond. Confirmed and Refund are not included.
func (b *Bond) Encode() []byte {
- return versionedBytes(2).
+ return versionedBytes(3).
AddData(uint16Bytes(b.Version)).
AddData(uint32Bytes(b.AssetID)).
AddData(b.CoinID).
@@ -131,7 +132,8 @@ func (b *Bond) Encode() []byte {
AddData(uint64Bytes(b.LockTime)).
AddData(uint32Bytes(b.KeyIndex)).
AddData(b.RefundTx).
- AddData(uint32Bytes(b.Strength))
+ AddData(uint32Bytes(b.Strength)).
+ AddData(b.ReplacedBy)
// Confirmed and Refunded are not part of the encoding.
}
@@ -148,6 +150,8 @@ func DecodeBond(b []byte) (*Bond, error) {
return decodeBond_v1(pushes)
case 2:
return decodeBond_v2(pushes)
+ case 3:
+ return decodeBond_v3(pushes)
}
return nil, fmt.Errorf("unknown Bond version %d", ver)
}
@@ -181,19 +185,26 @@ func decodeBond_v0(pushes [][]byte) (*Bond, error) {
func decodeBond_v1(pushes [][]byte) (*Bond, error) {
if len(pushes) != 10 {
- return nil, fmt.Errorf("decodeBond_v0: expected 10 data pushes, got %d", len(pushes))
+ return nil, fmt.Errorf("decodeBond_v1: expected 10 data pushes, got %d", len(pushes))
}
return decodeBond_v2(append(pushes, []byte{0, 0, 0, 0} /* uint32 strength */))
}
func decodeBond_v2(pushes [][]byte) (*Bond, error) {
if len(pushes) != 11 {
- return nil, fmt.Errorf("decodeBond_v0: expected 10 data pushes, got %d", len(pushes))
+ return nil, fmt.Errorf("decodeBond_v2: expected 11 data pushes, got %d", len(pushes))
+ }
+ return decodeBond_v3(append(pushes, nil /* replacedBy */))
+}
+func decodeBond_v3(pushes [][]byte) (*Bond, error) {
+ if len(pushes) != 12 {
+ return nil, fmt.Errorf("decodeBond_v3: expected 12 data pushes, got %d", len(pushes))
}
ver, assetIDB, coinID := pushes[0], pushes[1], pushes[2]
utx, stx := pushes[3], pushes[4]
data, amtB, lockTimeB := pushes[5], pushes[6], pushes[7]
keyIndex, refundTx, strength := pushes[8], pushes[9], pushes[10]
+ replacedBy := pushes[11]
return &Bond{
Version: intCoder.Uint16(ver),
AssetID: intCoder.Uint32(assetIDB),
@@ -206,6 +217,7 @@ func decodeBond_v2(pushes [][]byte) (*Bond, error) {
KeyIndex: intCoder.Uint32(keyIndex),
RefundTx: refundTx,
Strength: intCoder.Uint32(strength),
+ ReplacedBy: replacedBy,
}, nil
}
diff --git a/client/webserver/locales/en-us.go b/client/webserver/locales/en-us.go
index 4e096a7a65..5f1787c83d 100644
--- a/client/webserver/locales/en-us.go
+++ b/client/webserver/locales/en-us.go
@@ -524,6 +524,11 @@ var EnUS = map[string]string{
"fee": "Fee",
"tx_id": "Transaction ID",
"bond_id": "Bond ID",
+ "change_bond_id": "Change Bond ID",
+ "value": "Value",
+ "replaced_bonds": "Replaced Bonds",
+ "change_bond_tooltip": `The new bond required is smaller than the combined value of the replaced bonds, so a change bond that can be refunded sooner is created.`,
+ "replaced_bonds_tooptip": "This asset allows existing bonds to fund new bonds without having to be refunded first.",
"locktime": "Lock Time",
"recipient": "Recipient",
"block": "Block",
diff --git a/client/webserver/site/src/css/wallets.scss b/client/webserver/site/src/css/wallets.scss
index 9f1cd8f706..8be6f2ec9b 100644
--- a/client/webserver/site/src/css/wallets.scss
+++ b/client/webserver/site/src/css/wallets.scss
@@ -370,7 +370,11 @@
transition: color 1s ease;
}
-#txDetailsBondSection, #txDetailsRecipientSection, #txDetailsNonceSection {
+#txDetailsBondSection,
+#txDetailsRecipientSection,
+#txDetailsNonceSection,
+#txDetailsChangeBondSection,
+#txDetailsReplacedBondsSection {
margin-top: 10px;
padding-top: 10px;
border-top: 1px solid #777;
diff --git a/client/webserver/site/src/html/wallets.tmpl b/client/webserver/site/src/html/wallets.tmpl
index 958c6bfff3..44e2f7cb29 100644
--- a/client/webserver/site/src/html/wallets.tmpl
+++ b/client/webserver/site/src/html/wallets.tmpl
@@ -1011,19 +1011,47 @@
+
+ [[[Account ID]]]
+
+
[[[bond_id]]]
+
+ [[[value]]]
+
+
[[[locktime]]]
-
- [[[Account ID]]]
-
+
+
+ [[[change_bond_id]]]
+
+
+
+ [[[value]]]
+
+
+
+ [[[locktime]]]
+
+
+ [[[replaced_bonds]]]
+
+
+
+
+
+
+