From 5a984e4ab34028c133748c42aefa11a163c60f9e Mon Sep 17 00:00:00 2001 From: Slyghtning Date: Tue, 3 Nov 2026 11:13:04 +0100 Subject: [PATCH 1/9] swapkit: Share Bitcoin script leaf builders Route existing HTLC, static address and reservation scripts through the same leaf serializers. Pin the quote templates so moving the serialization cannot change signed numbers or zero-hash fee estimates. --- go.mod | 2 +- instantout/reservation/script/script.go | 13 +++----- staticaddr/script/script.go | 12 +++---- swap/htlc.go | 27 +++++----------- swapkit/script.go | 42 +++++++++++++++++++++++++ swapkit/script_test.go | 30 ++++++++++++++++++ swapkit/swapkit.go | 4 +++ 7 files changed, 92 insertions(+), 38 deletions(-) create mode 100644 swapkit/script.go create mode 100644 swapkit/script_test.go create mode 100644 swapkit/swapkit.go diff --git a/go.mod b/go.mod index e55dcf2f6..72d366e22 100644 --- a/go.mod +++ b/go.mod @@ -38,6 +38,7 @@ require ( github.com/urfave/cli-docs/v3 v3.1.1-0.20251020101624-bec07369b4f6 github.com/urfave/cli/v3 v3.4.1 go.etcd.io/bbolt v1.4.3 + golang.org/x/crypto v0.55.0 golang.org/x/sync v0.22.0 google.golang.org/genproto/googleapis/rpc v0.0.0-20260803160001-6ac0973c030d google.golang.org/grpc v1.83.2 @@ -179,7 +180,6 @@ require ( go.uber.org/multierr v1.6.0 // indirect go.uber.org/zap v1.24.0 // indirect go.yaml.in/yaml/v3 v3.0.4 // indirect - golang.org/x/crypto v0.55.0 // indirect golang.org/x/exp v0.0.0-20250811191247-51f88131bc50 // indirect golang.org/x/mod v0.38.0 // indirect golang.org/x/net v0.58.0 // indirect diff --git a/instantout/reservation/script/script.go b/instantout/reservation/script/script.go index a86504f52..ee1892f83 100644 --- a/instantout/reservation/script/script.go +++ b/instantout/reservation/script/script.go @@ -7,6 +7,7 @@ import ( "github.com/btcsuite/btcd/btcec/v2/schnorr" "github.com/btcsuite/btcd/btcec/v2/schnorr/musig2" "github.com/btcsuite/btcd/txscript" + "github.com/lightninglabs/loop/swapkit" "github.com/lightningnetwork/lnd/input" ) @@ -94,15 +95,9 @@ func PayToWitnessTaprootScript(taprootKey *btcec.PublicKey) ([]byte, error) { func TaprootExpiryScript(expiry uint32, serverKey *btcec.PublicKey) (*txscript.TapLeaf, error) { - builder := txscript.NewScriptBuilder() - - builder.AddData(schnorr.SerializePubKey(serverKey)) - builder.AddOp(txscript.OP_CHECKSIGVERIFY) - - builder.AddInt64(int64(expiry)) - builder.AddOp(txscript.OP_CHECKLOCKTIMEVERIFY) - - script, err := builder.Script() + script, err := swapkit.CLTVTimeoutScript( + [32]byte(schnorr.SerializePubKey(serverKey)), int64(expiry), + ) if err != nil { return nil, err } diff --git a/staticaddr/script/script.go b/staticaddr/script/script.go index 37e78a072..d0204ebb6 100644 --- a/staticaddr/script/script.go +++ b/staticaddr/script/script.go @@ -6,6 +6,7 @@ import ( "github.com/btcsuite/btcd/chaincfg/chainhash" "github.com/btcsuite/btcd/txscript" "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" "github.com/lightningnetwork/lnd/input" ) @@ -116,14 +117,9 @@ func (s *StaticAddress) StaticAddressScript() ([]byte, error) { func GenTimeoutPathScript(clientKey *btcec.PublicKey, csvExpiry int64) ([]byte, error) { - builder := txscript.NewScriptBuilder() - - builder.AddData(schnorr.SerializePubKey(clientKey)) - builder.AddOp(txscript.OP_CHECKSIGVERIFY) - builder.AddInt64(csvExpiry) - builder.AddOp(txscript.OP_CHECKSEQUENCEVERIFY) - - return builder.Script() + return swapkit.CSVTimeoutScript( + [32]byte(schnorr.SerializePubKey(clientKey)), csvExpiry, + ) } // GenSuccessWitness returns the success witness to spend the static address diff --git a/swap/htlc.go b/swap/htlc.go index 2e87d8aee..3683cd8e4 100644 --- a/swap/htlc.go +++ b/swap/htlc.go @@ -14,6 +14,7 @@ import ( "github.com/btcsuite/btcd/txscript" "github.com/btcsuite/btcd/wire" secp "github.com/decred/dcrd/dcrec/secp256k1/v4" + "github.com/lightninglabs/loop/swapkit" "github.com/lightningnetwork/lnd/input" "github.com/lightningnetwork/lnd/lntypes" ) @@ -622,12 +623,9 @@ func newHTLCScriptV3(muSig2Version input.MuSig2Version, cltvExpiry int32, func GenTimeoutPathScript(senderHtlcKey *btcec.PublicKey, cltvExpiry int64) ( []byte, error) { - builder := txscript.NewScriptBuilder() - builder.AddData(schnorr.SerializePubKey(senderHtlcKey)) - builder.AddOp(txscript.OP_CHECKSIGVERIFY) - builder.AddInt64(cltvExpiry) - builder.AddOp(txscript.OP_CHECKLOCKTIMEVERIFY) - return builder.Script() + return swapkit.CLTVTimeoutScript( + [32]byte(schnorr.SerializePubKey(senderHtlcKey)), cltvExpiry, + ) } // GenSuccessPathScript constructs an HtlcScript for the success payment path. @@ -640,20 +638,9 @@ func GenTimeoutPathScript(senderHtlcKey *btcec.PublicKey, cltvExpiry int64) ( func GenSuccessPathScript(receiverHtlcKey *btcec.PublicKey, swapHash lntypes.Hash) ([]byte, error) { - builder := txscript.NewScriptBuilder() - - builder.AddData(schnorr.SerializePubKey(receiverHtlcKey)) - builder.AddOp(txscript.OP_CHECKSIGVERIFY) - builder.AddOp(txscript.OP_SIZE) - builder.AddInt64(32) - builder.AddOp(txscript.OP_EQUALVERIFY) - builder.AddOp(txscript.OP_HASH160) - builder.AddData(input.Ripemd160H(swapHash[:])) - builder.AddOp(txscript.OP_EQUALVERIFY) - builder.AddInt64(1) - builder.AddOp(txscript.OP_CHECKSEQUENCEVERIFY) - - return builder.Script() + return swapkit.HTLCSuccessScript( + [32]byte(schnorr.SerializePubKey(receiverHtlcKey)), [32]byte(swapHash), + ) } // genControlBlock constructs the control block with the depth 1 leaf of the diff --git a/swapkit/script.go b/swapkit/script.go new file mode 100644 index 000000000..7cd53bcff --- /dev/null +++ b/swapkit/script.go @@ -0,0 +1,42 @@ +package swapkit + +import ( + "github.com/btcsuite/btcd/txscript" + "golang.org/x/crypto/ripemd160" //nolint:gosec,staticcheck // OP_HASH160. +) + +// HTLCSuccessScript serializes Loop's Bitcoin HTLC success leaf. The key is +// x-only. This primitive accepts any payment hash, including the zero hash used +// for fee estimation; funded contract validation belongs to the caller. +func HTLCSuccessScript(receiver [32]byte, paymentHash Hash) ([]byte, error) { + // #nosec G406 -- Bitcoin OP_HASH160 requires RIPEMD160. + hash160 := ripemd160.New() + _, _ = hash160.Write(paymentHash[:]) + return txscript.NewScriptBuilder(). + AddData(receiver[:]). + AddOp(txscript.OP_CHECKSIGVERIFY). + AddOp(txscript.OP_SIZE).AddInt64(32). + AddOp(txscript.OP_EQUALVERIFY). + AddOp(txscript.OP_HASH160).AddData(hash160.Sum(nil)). + AddOp(txscript.OP_EQUALVERIFY).AddInt64(1). + AddOp(txscript.OP_CHECKSEQUENCEVERIFY).Script() +} + +// CSVTimeoutScript serializes Loop's Bitcoin deposit refund leaf. The key is +// x-only. It preserves the caller's signed script number without applying +// contract policy; callers must validate expiry before funding an output. +func CSVTimeoutScript(sender [32]byte, expiry int64) ([]byte, error) { + return timeoutScript(sender, expiry, txscript.OP_CHECKSEQUENCEVERIFY) +} + +// CLTVTimeoutScript serializes Loop's V3 Bitcoin HTLC refund leaf. Like +// CSVTimeoutScript, it leaves expiry validation to the contract caller. +func CLTVTimeoutScript(sender [32]byte, expiry int64) ([]byte, error) { + return timeoutScript(sender, expiry, txscript.OP_CHECKLOCKTIMEVERIFY) +} + +func timeoutScript(sender [32]byte, expiry int64, opcode byte) ([]byte, error) { + return txscript.NewScriptBuilder().AddData(sender[:]). + AddOp(txscript.OP_CHECKSIGVERIFY).AddInt64(expiry). + AddOp(opcode).Script() +} diff --git a/swapkit/script_test.go b/swapkit/script_test.go new file mode 100644 index 000000000..ee7aec914 --- /dev/null +++ b/swapkit/script_test.go @@ -0,0 +1,30 @@ +package swapkit + +import ( + "encoding/hex" + "strings" + "testing" + + "github.com/stretchr/testify/require" +) + +// TestQuoteLeafEncodings pins the unfunded templates used by existing +// callers, including a zero payment hash and signed script numbers. +func TestQuoteLeafEncodings(t *testing.T) { + var key [32]byte + prefix := "20" + strings.Repeat("00", 32) + "ad" + + success, err := HTLCSuccessScript(key, Hash{}) + require.NoError(t, err) + const zeroPaymentHash160 = "d1a70126ff7a149ca6f9b638db084480440ff842" + require.Equal(t, prefix+"82012088a914"+zeroPaymentHash160+"8851b2", + hex.EncodeToString(success)) + + csv, err := CSVTimeoutScript(key, -1) + require.NoError(t, err) + require.Equal(t, prefix+"4fb2", hex.EncodeToString(csv)) + + cltv, err := CLTVTimeoutScript(key, 0) + require.NoError(t, err) + require.Equal(t, prefix+"00b1", hex.EncodeToString(cltv)) +} diff --git a/swapkit/swapkit.go b/swapkit/swapkit.go new file mode 100644 index 000000000..a80157e2f --- /dev/null +++ b/swapkit/swapkit.go @@ -0,0 +1,4 @@ +package swapkit + +// Hash is a binary 32-byte commitment or payment hash. +type Hash = [32]byte From 749c8aa6e9c79db9a1ca13eba3ae9ffef273734e Mon Sep 17 00:00:00 2001 From: Slyghtning Date: Tue, 3 Nov 2026 11:13:07 +0100 Subject: [PATCH 2/9] swapkit: Define asset deposit, reservation and HTLC contracts Define the key roles, cooperative and unilateral paths, witnesses and weight estimates for both directions. Exercise the legacy vectors and execute the spend conditions against the Bitcoin script engine. --- swapkit/README.md | 68 ++++ swapkit/doc.go | 33 ++ swapkit/example_test.go | 71 +++++ swapkit/roles_test.go | 259 ++++++++++++++++ swapkit/swapkit.go | 669 ++++++++++++++++++++++++++++++++++++++++ swapkit/swapkit_test.go | 472 ++++++++++++++++++++++++++++ swapkit/weight.go | 46 +++ swapkit/weight_test.go | 155 ++++++++++ 8 files changed, 1773 insertions(+) create mode 100644 swapkit/README.md create mode 100644 swapkit/doc.go create mode 100644 swapkit/example_test.go create mode 100644 swapkit/roles_test.go create mode 100644 swapkit/swapkit_test.go create mode 100644 swapkit/weight.go create mode 100644 swapkit/weight_test.go diff --git a/swapkit/README.md b/swapkit/README.md new file mode 100644 index 000000000..935bf0126 --- /dev/null +++ b/swapkit/README.md @@ -0,0 +1,68 @@ +# Shared asset swap contracts + +This package uses the Bitcoin contracts and flow records from Kon's static +asset Loop In implementation as the common contract layer for both asset swap +directions. The old asset deposit, HTLC and sweep engines are replaced by these +contracts and the native SDK adapter in [`tapsdk`](tapsdk/README.md). + +The root package is pure Bitcoin policy: fixed-size public keys, leaves, +control blocks, spend constraints and witness stacks. It has no RPC clients, +wallet implementation or Tap SDK dependency. Weight helpers use lnd's +transaction estimator types. Ordinary Bitcoin HTLC, +static-address and reservation helpers call the same leaf serializers here. +The primitive serializers preserve signed expiry encodings and zero-hash quote +templates; funded constructors validate their keys, hashes and timelocks. + +| Constructor | Cooperative path | Unilateral refund | +| --- | --- | --- | +| `NewDepositKit` | Sorted MuSig2 | Sender CSV delay | +| `NewReservationKit` | Sorted MuSig2 | Server/sender CLTV height | +| `NewSwapKit(SwapHTLCLegacyCSV)` | Sorted MuSig2 | Sender CSV delay | +| `NewSwapKit(SwapHTLCStaticLoopInV3)` | Sorted MuSig2 | Sender CLTV height | + +Both HTLC policies share the receiver signature and correct 32-byte preimage +success path, including its existing one-block CSV. `SwapHTLCCLTV` is a +same-value, direction-neutral alias for `SwapHTLCStaticLoopInV3`. Policy values +and legacy contract vectors remain stable. + +Sender and receiver follow the direction of the on-chain assets. For Loop In, +the client sends and refunds, and the server claims with the preimage. For Loop +Out, the server sends and refunds, and the client claims. Internal keys control +the cooperative MuSig2 path; script keys control unilateral paths. A party may +reuse its own key across those roles, while cross-party x-only aliases are +rejected. + +`SwapKitParams` retains Kon's `SenderKey`, `ReceiverKey`, internal-key fields, +`PaymentHash` and policy-selected `Expiry`. `SenderScriptKey` and +`ReceiverScriptKey` are explicit script-role aliases; conflicting aliases are +rejected. `DepositKitParams` retains the original `ClientKey`/`ServerKey` form, +or accepts all four explicit roles. `ReservationKitParams` similarly accepts +`ServerKey`/`ClientKey`, or four roles, with a distinct `RefundHeight`. Mixing +the two-key convenience form and explicit roles is rejected. + +Supply a verified complete asset commitment root to construct spend +information, then compare its Bitcoin script with the authenticated prevout. +Apply the returned sequence and locktime before signing any inputs, including +fee inputs. CSV uses a relative block delay; CLTV uses a non-final sequence with +BIP68 disabled and an absolute height. New CLTV refunds use `0xfffffffd` +to signal RBF; already signed transactions keep their original sequence. Chain maturity, confirmation depth, +Lightning deadlines, invoice state and authority release remain owned by the +calling FSM. + +The [`tapsdk`](tapsdk/README.md) adapter owns conversion to native SDK requests, +proof validation and package handling. The SDK owns generic transfer +construction, allocation, virtual transitions, proof processing and sealed +recovery packages. LND and tapd retain their normal signing and publication +roles. The asset-level OP_TRUE descriptor is independent of the Bitcoin +contract; the fixed NUMS construction remains the policy for new contracts in +this integration, and funded outputs retain their original descriptor. + +`SwapAnchorSpendInfo.MaxSuccessWitnessSize` and `MaxTimeoutWitnessSize` +include the complete asset control block and a maximum 65-byte signature. +`AddSuccessToEstimator` and `AddTimeoutToEstimator` apply these sizes to lnd's +transaction weight estimator. They describe witnesses emitted by this kit, +without an annex. + +Run `go test ./swapkit` from the Loop module. Tests freeze legacy contract +vectors and execute valid and adversarial Bitcoin witnesses, including +independent key roles and server-funded CLTV reservations. diff --git a/swapkit/doc.go b/swapkit/doc.go new file mode 100644 index 000000000..b32ced21e --- /dev/null +++ b/swapkit/doc.go @@ -0,0 +1,33 @@ +// Package swapkit owns the Bitcoin policies and flow records shared by asset +// Loop In and Loop Out. It uses Kon's static asset Loop In contracts directly; +// swapkit/tapsdk adapts those contracts to the native Tap SDK transfer, signing +// request, proof and recovery APIs. This package itself has no SDK, wallet, +// tapd or lnd dependency. +// +// NewDepositKit constructs the cooperative MuSig2 deposit and sender CSV refund +// used by static Loop In. Its original ClientKey/ServerKey form remains valid; +// callers needing separate cooperative and script keys supply all four roles. +// NewReservationKit constructs a server-funded reservation with an absolute +// RefundHeight and sender CLTV refund. It never reinterprets a CSV delay. +// +// NewSwapKit requires an explicit HTLC policy. SwapHTLCLegacyCSV retains the +// original relative refund; SwapHTLCStaticLoopInV3 and its direction-neutral +// SwapHTLCCLTV alias select the absolute refund. Both retain the receiver's +// signature, 32-byte preimage and one-block CSV on success. Sender and receiver +// follow the on-chain asset direction: client/server for Loop In and +// server/client for Loop Out. Their cooperative internal and script signing +// roles remain separate. +// +// AnchorPlan supplies the cooperative key and Bitcoin policy tree. Spend +// information requires a verified complete asset commitment root, which is a +// sibling of that tree. Before signing any input, compare the returned script +// with the authenticated prevout and apply its sequence and locktime. CLTV +// spends use a non-final sequence with BIP68 disabled. These helpers do not +// establish chain maturity, Lightning deadlines, provenance or authorization +// to expose a preimage or a signature. The calling FSM owns those decisions. +// +// Asset script keys are selected by the SDK adapter, independently of these +// Bitcoin policies. The adapter retains the fixed NUMS OP_TRUE construction +// for existing contracts and must preserve the exact descriptor of any funded +// output throughout signing, publication, proof delivery and recovery. +package swapkit diff --git a/swapkit/example_test.go b/swapkit/example_test.go new file mode 100644 index 000000000..939d1f696 --- /dev/null +++ b/swapkit/example_test.go @@ -0,0 +1,71 @@ +package swapkit_test + +import ( + "crypto/sha256" + "fmt" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/lightninglabs/loop/swapkit" +) + +func ExampleNewSwapKit() { + _, client := btcec.PrivKeyFromBytes([]byte{1}) + _, server := btcec.PrivKeyFromBytes([]byte{2}) + clientKey := swapkit.PubKey(client.SerializeCompressed()) + serverKey := swapkit.PubKey(server.SerializeCompressed()) + preimage := [32]byte{42} + // In Loop Out the server sends assets and owns the refund path. + kit, err := swapkit.NewSwapKit(swapkit.SwapKitParams{ + Policy: swapkit.SwapHTLCCLTV, + SenderInternalKey: serverKey, ReceiverInternalKey: clientKey, + SenderScriptKey: serverKey, ReceiverScriptKey: clientKey, + PaymentHash: sha256.Sum256(preimage[:]), Expiry: 1_000_000, + }) + if err != nil { + panic(err) + } + spend, err := kit.TimeoutSpend(swapkit.Hash{1}) + if err != nil { + panic(err) + } + fmt.Println(spend.Sequence, spend.LockTime) + // Output: 4294967293 1000000 +} + +func ExampleNewDepositKit() { + _, client := btcec.PrivKeyFromBytes([]byte{1}) + _, server := btcec.PrivKeyFromBytes([]byte{2}) + kit, err := swapkit.NewDepositKit(swapkit.DepositKitParams{ + ClientKey: swapkit.PubKey(client.SerializeCompressed()), + ServerKey: swapkit.PubKey(server.SerializeCompressed()), + CSVExpiry: 144, + }) + if err != nil { + panic(err) + } + spend, err := kit.TimeoutSpend(swapkit.Hash{1}) + if err != nil { + panic(err) + } + fmt.Println(spend.Sequence, spend.LockTime) + // Output: 144 0 +} + +func ExampleNewReservationKit() { + _, client := btcec.PrivKeyFromBytes([]byte{1}) + _, server := btcec.PrivKeyFromBytes([]byte{2}) + kit, err := swapkit.NewReservationKit(swapkit.ReservationKitParams{ + ClientKey: swapkit.PubKey(client.SerializeCompressed()), + ServerKey: swapkit.PubKey(server.SerializeCompressed()), + RefundHeight: 1_000_000, + }) + if err != nil { + panic(err) + } + spend, err := kit.TimeoutSpend(swapkit.Hash{1}) + if err != nil { + panic(err) + } + fmt.Println(spend.Sequence, spend.LockTime) + // Output: 4294967293 1000000 +} diff --git a/swapkit/roles_test.go b/swapkit/roles_test.go new file mode 100644 index 000000000..5864cb976 --- /dev/null +++ b/swapkit/roles_test.go @@ -0,0 +1,259 @@ +package swapkit + +import ( + "bytes" + "crypto/sha256" + "encoding/hex" + "testing" + + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/stretchr/testify/require" +) + +// TestSwapKitIndependentRoles executes both HTLC versions in both on-chain +// directions with separate cooperative and unilateral signing keys. +func TestSwapKitIndependentRoles(t *testing.T) { + for _, policy := range []SwapHTLCPolicy{ + SwapHTLCLegacyCSV, SwapHTLCCLTV, + } { + for _, reverse := range []bool{false, true} { + name := swapKitTestName(policy, false, "loop in") + if reverse { + name = swapKitTestName(policy, false, "loop out") + } + t.Run(name, func(t *testing.T) { + params := swapKitTestParams(t) + params.Policy = policy + params.SenderKey, params.ReceiverKey = testKey(t, 3), testKey(t, 4) + sender, receiver := byte(3), byte(4) + senderInternal, receiverInternal := byte(1), byte(2) + if reverse { + params.SenderKey, params.ReceiverKey = params.ReceiverKey, params.SenderKey + params.SenderInternalKey, params.ReceiverInternalKey = + params.ReceiverInternalKey, params.SenderInternalKey + sender, receiver = receiver, sender + senderInternal, receiverInternal = receiverInternal, senderInternal + } + kit, err := NewSwapKit(params) + require.NoError(t, err) + root := swapKitTestAssetRoot() + for _, success := range []bool{false, true} { + spend, err := kit.TimeoutSpend(root) + key, wrong := sender, senderInternal + if success { + spend, err = kit.SuccessSpend(root) + key, wrong = receiver, receiverInternal + } + require.NoError(t, err) + for _, scalar := range []byte{key, wrong} { + tx, previous, signature := swapKitSignTestTx(t, spend, scalar, nil) + if success { + tx.TxIn[0].Witness, err = kit.SuccessWitness(root, + signature, [32]byte{42}) + } else { + tx.TxIn[0].Witness, err = kit.TimeoutWitness(root, signature) + } + require.NoError(t, err) + err = swapKitExecuteTestTx(tx, previous) + if scalar == key { + require.NoError(t, err) + } else { + require.Error(t, err) + } + } + } + }) + } + } +} + +func TestSwapKitKeyRoleValidation(t *testing.T) { + for _, opposite := range []bool{false, true} { + for _, internal := range []bool{false, true} { + params := swapKitTestParams(t) + params.SenderKey, params.ReceiverKey = testKey(t, 3), testKey(t, 4) + alias := params.SenderInternalKey + if internal { + alias = params.SenderKey + } + if opposite { + alias[0] ^= 1 + } + params.ReceiverKey = alias + _, err := NewSwapKit(params) + require.Error(t, err) + params.ReceiverKey = testKey(t, 4) + params.ReceiverInternalKey = alias + _, err = NewSwapKit(params) + require.Error(t, err) + } + } + params := swapKitTestParams(t) + params.SenderKey, params.ReceiverKey = PubKey{}, PubKey{} + params.SenderScriptKey, params.ReceiverScriptKey = testKey(t, 3), testKey(t, 4) + kit, err := NewSwapKit(params) + require.NoError(t, err) + require.Equal(t, params.SenderScriptKey, kit.Params().SenderKey) + require.Equal(t, params.ReceiverScriptKey, kit.Params().ReceiverKey) + params.SenderKey = testKey(t, 1) + _, err = NewSwapKit(params) + require.ErrorContains(t, err, "conflicting sender") + params.SenderKey = PubKey{} + params.ReceiverKey = testKey(t, 2) + _, err = NewSwapKit(params) + require.ErrorContains(t, err, "conflicting receiver") +} + +// TestDepositKitIndependentRoles retains the existing CSV deposit while +// separating its funder's cooperative key from its refund signer. +func TestDepositKitIndependentRoles(t *testing.T) { + params := DepositKitParams{ + SenderInternalKey: testKey(t, 1), ReceiverInternalKey: testKey(t, 2), + SenderScriptKey: testKey(t, 3), ReceiverScriptKey: testKey(t, 4), + CSVExpiry: 144, + } + kit, err := NewDepositKit(params) + require.NoError(t, err) + spend, err := kit.TimeoutSpend(swapKitTestAssetRoot()) + require.NoError(t, err) + require.Equal(t, [32]byte(params.SenderScriptKey[1:]), spend.RequiredSigner) + for _, scalar := range []byte{3, 1, 2, 4} { + tx, previous, signature := swapKitSignTestTx(t, spend, scalar, nil) + tx.TxIn[0].Witness, err = kit.TimeoutWitness(swapKitTestAssetRoot(), signature) + require.NoError(t, err) + err = swapKitExecuteTestTx(tx, previous) + if scalar == 3 { + require.NoError(t, err) + } else { + require.Error(t, err) + } + } + invalid := params + invalid.ClientKey = testKey(t, 1) + _, err = NewDepositKit(invalid) + require.ErrorContains(t, err, "cannot mix") + invalid = params + invalid.ReceiverScriptKey = PubKey{} + _, err = NewDepositKit(invalid) + require.Error(t, err) + invalid = params + invalid.ReceiverScriptKey = params.SenderInternalKey + _, err = NewDepositKit(invalid) + require.Error(t, err) +} + +// TestReservationKit executes the server-funded absolute refund independently +// of static deposits' CSV clock and rejects early or wrong-key refunds. +func TestReservationKit(t *testing.T) { + params := ReservationKitParams{ + ServerKey: testKey(t, 2), ClientKey: testKey(t, 1), RefundHeight: 1_000_000, + } + legacy, err := NewReservationKit(params) + require.NoError(t, err) + require.Equal(t, "20c6047f9441ed7d6d3045406e95c07cd85c778e"+ + "4b8cef3ca7abac09b95c709ee5ad0340420fb1", + hex.EncodeToString(legacy.TimeoutScript())) + spend, err := legacy.TimeoutSpend(swapKitTestAssetRoot()) + require.NoError(t, err) + require.Len(t, spend.ControlBlock, 65) + require.Equal(t, wire.MaxTxInSequenceNum-2, spend.Sequence) + require.Equal(t, params.RefundHeight, spend.LockTime) + require.Equal(t, [32]byte(params.ServerKey[1:]), spend.RequiredSigner) + for _, test := range []struct { + name string + mutate func(*wire.MsgTx) + key byte + valid bool + }{ + {name: "server refund", key: 2, valid: true}, + {name: "client cannot refund", key: 1}, + {name: "early", key: 2, mutate: func(tx *wire.MsgTx) { tx.LockTime-- }}, + {name: "later", key: 2, valid: true, mutate: func(tx *wire.MsgTx) { tx.LockTime++ }}, + {name: "final sequence", key: 2, mutate: func(tx *wire.MsgTx) { + tx.TxIn[0].Sequence = wire.MaxTxInSequenceNum + }}, + {name: "timestamp", key: 2, mutate: func(tx *wire.MsgTx) { + tx.LockTime = txscript.LockTimeThreshold + }}, + } { + t.Run(test.name, func(t *testing.T) { + tx, previous, signature := swapKitSignTestTx(t, spend, test.key, test.mutate) + tx.TxIn[0].Witness, err = legacy.TimeoutWitness(swapKitTestAssetRoot(), signature) + require.NoError(t, err) + err = swapKitExecuteTestTx(tx, previous) + if test.valid { + require.NoError(t, err) + } else { + require.Error(t, err) + } + }) + } + explicit, err := NewReservationKit(ReservationKitParams{ + SenderInternalKey: params.ServerKey, ReceiverInternalKey: params.ClientKey, + SenderScriptKey: testKey(t, 4), ReceiverScriptKey: testKey(t, 3), + RefundHeight: params.RefundHeight, + }) + require.NoError(t, err) + require.Equal(t, legacy.AnchorPlan().InternalKey, explicit.AnchorPlan().InternalKey) + spend, err = explicit.TimeoutSpend(swapKitTestAssetRoot()) + require.NoError(t, err) + for _, scalar := range []byte{4, 2} { + tx, previous, signature := swapKitSignTestTx(t, spend, scalar, nil) + tx.TxIn[0].Witness, err = explicit.TimeoutWitness(swapKitTestAssetRoot(), signature) + require.NoError(t, err) + err = swapKitExecuteTestTx(tx, previous) + if scalar == 4 { + require.NoError(t, err) + } else { + require.Error(t, err) + } + } +} + +func TestReservationKitValidation(t *testing.T) { + params := ReservationKitParams{ServerKey: testKey(t, 2), ClientKey: testKey(t, 1)} + for _, height := range []uint32{0, txscript.LockTimeThreshold, ^uint32(0)} { + params.RefundHeight = height + _, err := NewReservationKit(params) + require.Error(t, err) + } + for _, height := range []uint32{1, txscript.LockTimeThreshold - 1} { + params.RefundHeight = height + _, err := NewReservationKit(params) + require.NoError(t, err) + } + params.RefundHeight = 100 + params.SenderScriptKey = params.ServerKey + _, err := NewReservationKit(params) + require.ErrorContains(t, err, "cannot mix") + params.SenderScriptKey = PubKey{} + params.ClientKey = params.ServerKey + _, err = NewReservationKit(params) + require.Error(t, err) +} + +func TestSwapKitSnapshots(t *testing.T) { + params := swapKitTestParams(t) + kit, err := NewSwapKit(params) + require.NoError(t, err) + plan := kit.AnchorPlan() + plan.Leaves[0][0] ^= 1 + participants := kit.CooperativeParticipants() + participants[0][0] ^= 1 + copyParams := kit.Params() + copyParams.PaymentHash = sha256.Sum256([]byte{1}) + require.Equal(t, params, kit.Params()) + require.NotEqual(t, participants, kit.CooperativeParticipants()) + require.NotEqual(t, plan.Leaves, kit.AnchorPlan().Leaves) + spend, err := kit.SuccessSpend(swapKitTestAssetRoot()) + require.NoError(t, err) + spend.LeafScript[0] ^= 1 + spend.PkScript[0] ^= 1 + spend.ControlBlock[0] ^= 1 + fresh, err := kit.SuccessSpend(swapKitTestAssetRoot()) + require.NoError(t, err) + require.False(t, bytes.Equal(spend.LeafScript, fresh.LeafScript)) + require.NotEqual(t, spend.PkScript, fresh.PkScript) + require.NotEqual(t, spend.ControlBlock, fresh.ControlBlock) +} diff --git a/swapkit/swapkit.go b/swapkit/swapkit.go index a80157e2f..08f96f96f 100644 --- a/swapkit/swapkit.go +++ b/swapkit/swapkit.go @@ -1,4 +1,673 @@ package swapkit +import ( + "bytes" + "crypto/sha256" + "fmt" + "slices" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/btcec/v2/schnorr/musig2" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" +) + +// PubKey is a compressed secp256k1 key. It has no wallet dependency. +type PubKey = [33]byte + // Hash is a binary 32-byte commitment or payment hash. type Hash = [32]byte + +// AnchorPlan contains the aggregate Bitcoin internal key and policy leaves. +type AnchorPlan struct { + InternalKey PubKey + Leaves [][]byte +} + +// SwapHTLCPolicy identifies the immutable Bitcoin contract of an asset HTLC. +type SwapHTLCPolicy uint8 + +const ( + // SwapHTLCUnspecified forces callers to select a contract explicitly. + SwapHTLCUnspecified SwapHTLCPolicy = iota + + // SwapHTLCLegacyCSV preserves the original asset deposit HTLC scripts. + // Expiry is a relative refund delay in blocks. + SwapHTLCLegacyCSV + + // SwapHTLCStaticLoopInV3 uses Loop's V3 Bitcoin HTLC scripts. Expiry is + // an absolute refund block height in a separate on-chain contract. + SwapHTLCStaticLoopInV3 +) + +const ( + // SwapHTLCCLTV is the direction-neutral name of the same CLTV policy. + // Sender refunds and receiver claims follow the on-chain asset direction. + SwapHTLCCLTV = SwapHTLCStaticLoopInV3 +) + +// SwapKitParams specifies the Bitcoin policy for an asset HTLC. Asset identity, +// amounts, and the asset-level OP_TRUE descriptor are selected separately. +type SwapKitParams struct { + Policy SwapHTLCPolicy + + // SenderKey authorizes refunds; ReceiverKey authorizes preimage claims. + // The sender is the client for Loop In and the server for Loop Out. + SenderKey PubKey + ReceiverKey PubKey + + // SenderScriptKey and ReceiverScriptKey are explicit script-role aliases. + // They may replace SenderKey/ReceiverKey, or equal them when both are set. + SenderScriptKey PubKey + ReceiverScriptKey PubKey + + // Internal keys authorize the cooperative MuSig2 key path. They may + // equal the corresponding script keys, but must be supplied explicitly. + SenderInternalKey PubKey + ReceiverInternalKey PubKey + + // PaymentHash is SHA256 of the 32-byte success preimage. + PaymentHash Hash + + // Expiry is a block delay or height, as selected by Policy. + Expiry uint32 +} + +// SwapKit constructs an OP_TRUE asset HTLC whose authorization resides on its +// Bitcoin anchor. Its policy is immutable after construction. It does not own +// Lightning invoices, pricing, signing sessions, or preimage release policy. +type SwapKit struct { + params SwapKitParams + anchor swapAnchorPolicy + success []byte + timeout []byte +} + +// NewSwapKit validates and constructs an asset HTLC policy. +func NewSwapKit(params SwapKitParams) (*SwapKit, error) { + if params.SenderScriptKey != (PubKey{}) { + if params.SenderKey != (PubKey{}) && + params.SenderKey != params.SenderScriptKey { + + return nil, fmt.Errorf("conflicting sender script keys") + } + params.SenderKey = params.SenderScriptKey + } + if params.ReceiverScriptKey != (PubKey{}) { + if params.ReceiverKey != (PubKey{}) && + params.ReceiverKey != params.ReceiverScriptKey { + + return nil, fmt.Errorf("conflicting receiver script keys") + } + params.ReceiverKey = params.ReceiverScriptKey + } + if err := validateContractKeyRoles(params.SenderInternalKey, + params.ReceiverInternalKey, params.SenderKey, + params.ReceiverKey); err != nil { + return nil, fmt.Errorf("HTLC keys: %w", err) + } + if params.PaymentHash == (Hash{}) { + return nil, fmt.Errorf("payment hash is required") + } + + var timeoutOp byte + switch params.Policy { + case SwapHTLCLegacyCSV: + if err := validateSwapCSV(params.Expiry); err != nil { + return nil, err + } + if params.Expiry <= 1 { + return nil, fmt.Errorf("HTLC CSV expiry must exceed the " + + "one-block success delay") + } + timeoutOp = txscript.OP_CHECKSEQUENCEVERIFY + + case SwapHTLCStaticLoopInV3: + if params.Expiry == 0 || + params.Expiry >= txscript.LockTimeThreshold { + + return nil, fmt.Errorf("expiry must be a block height") + } + timeoutOp = txscript.OP_CHECKLOCKTIMEVERIFY + + default: + return nil, fmt.Errorf( + "unsupported HTLC policy %d", params.Policy, + ) + } + + success, err := GenSuccessScript(params.ReceiverKey, params.PaymentHash) + if err != nil { + return nil, err + } + timeout, err := swapTimeoutScript( + params.SenderKey, params.Expiry, timeoutOp, + ) + if err != nil { + return nil, err + } + anchor, err := newSwapAnchorPolicy( + params.SenderInternalKey, params.ReceiverInternalKey, + [][]byte{success, timeout}, + ) + if err != nil { + return nil, err + } + + return &SwapKit{ + params: params, + anchor: anchor, + success: success, + timeout: timeout, + }, nil +} + +// Params returns a value copy of the immutable contract parameters. +func (s *SwapKit) Params() SwapKitParams { + return s.params +} + +// AnchorPlan returns the cooperative internal key and Bitcoin HTLC leaves. +func (s *SwapKit) AnchorPlan() AnchorPlan { + return s.anchor.plan() +} + +// CooperativeParticipants returns the exact sorted MuSig2 participant order. +func (s *SwapKit) CooperativeParticipants() []PubKey { + return slices.Clone(s.anchor.participants) +} + +// SuccessScript returns an independent copy of the Bitcoin success leaf. +func (s *SwapKit) SuccessScript() []byte { + return bytes.Clone(s.success) +} + +// TimeoutScript returns an independent copy of the Bitcoin refund leaf. +func (s *SwapKit) TimeoutScript() []byte { + return bytes.Clone(s.timeout) +} + +// SuccessSpend constructs the receiver's Bitcoin script path. assetRoot must +// come from the verified custom-anchor output, not an ownership challenge. The +// spending transaction must have version >= 2 and sequence >= 1 block. +func (s *SwapKit) SuccessSpend(assetRoot Hash) (*SwapAnchorSpendInfo, error) { + return s.anchor.spend( + assetRoot, s.success, s.params.ReceiverKey, 1, 0, + ) +} + +// TimeoutSpend constructs the sender's Bitcoin refund path. Legacy policy +// requires CSV; StaticLoopInV3 requires nLockTime >= Expiry and a non-final +// input sequence. New CLTV refunds opt into replacement without enabling +// BIP68 relative locks. Maturity must also be checked against the chain. +func (s *SwapKit) TimeoutSpend(assetRoot Hash) (*SwapAnchorSpendInfo, error) { + sequence, lockTime := s.params.Expiry, uint32(0) + if s.params.Policy == SwapHTLCStaticLoopInV3 { + sequence, lockTime = wire.MaxTxInSequenceNum-2, s.params.Expiry + } + + return s.anchor.spend( + assetRoot, s.timeout, s.params.SenderKey, sequence, lockTime, + ) +} + +// SuccessWitness constructs the Bitcoin success witness after checking the +// preimage. The SDK signing flow verifies the signature against the actual +// transaction; this helper does not sign or release the preimage to a peer. +// ApplyScriptPathWitness accepts only the unlocking prefix: omit the final +// script and control block, which the SDK obtains from its sealed package. +func (s *SwapKit) SuccessWitness(assetRoot Hash, signature []byte, + preimage [32]byte) ([][]byte, error) { + + if sha256.Sum256(preimage[:]) != s.params.PaymentHash { + return nil, fmt.Errorf("preimage does not match payment hash") + } + spend, err := s.SuccessSpend(assetRoot) + if err != nil { + return nil, err + } + return spend.witness(signature, preimage[:]) +} + +// TimeoutWitness constructs the sender's Bitcoin refund witness. +// ApplyScriptPathWitness accepts only the signature, not the final script and +// control block, which the SDK obtains from its sealed package. +func (s *SwapKit) TimeoutWitness(assetRoot Hash, + signature []byte) ([][]byte, error) { + + spend, err := s.TimeoutSpend(assetRoot) + if err != nil { + return nil, err + } + return spend.witness(signature, nil) +} + +// DepositKitParams specifies a cooperative asset deposit with a unilateral, +// block-based CSV refund to the sender, matching Loop's static address. +type DepositKitParams struct { + // ClientKey and ServerKey preserve the original two-key constructor. + // Use these together, or supply all four explicit roles below. + ClientKey PubKey + ServerKey PubKey + + SenderInternalKey PubKey + ReceiverInternalKey PubKey + SenderScriptKey PubKey + ReceiverScriptKey PubKey + CSVExpiry uint32 +} + +// DepositKit constructs an asset deposit whose Bitcoin anchor requires both +// participants to spend cooperatively, or the sender after CSV expiry. The +// legacy two-key constructor makes the client the sender. +type DepositKit struct { + params DepositKitParams + anchor swapAnchorPolicy + senderScript PubKey + timeout []byte +} + +// NewDepositKit validates and constructs a static asset deposit policy. +func NewDepositKit(params DepositKitParams) (*DepositKit, error) { + if err := validateSwapCSV(params.CSVExpiry); err != nil { + return nil, err + } + keys, err := resolveFundingKeys(params.ClientKey, params.ServerKey, + params.SenderInternalKey, params.ReceiverInternalKey, + params.SenderScriptKey, params.ReceiverScriptKey) + if err != nil { + return nil, fmt.Errorf("deposit keys: %w", err) + } + timeout, err := swapTimeoutScript( + keys.senderScript, params.CSVExpiry, + txscript.OP_CHECKSEQUENCEVERIFY, + ) + if err != nil { + return nil, err + } + anchor, err := newSwapAnchorPolicy( + keys.senderInternal, keys.receiverInternal, [][]byte{timeout}, + ) + if err != nil { + return nil, err + } + + return &DepositKit{ + params: params, anchor: anchor, + senderScript: keys.senderScript, timeout: timeout, + }, nil +} + +// Params returns a value copy of the deposit parameters. +func (d *DepositKit) Params() DepositKitParams { + return d.params +} + +// AnchorPlan returns the cooperative internal key and Bitcoin refund leaf. +func (d *DepositKit) AnchorPlan() AnchorPlan { + return d.anchor.plan() +} + +// CooperativeParticipants returns the exact sorted MuSig2 participant order. +func (d *DepositKit) CooperativeParticipants() []PubKey { + return slices.Clone(d.anchor.participants) +} + +// TimeoutScript returns an independent copy of the Bitcoin refund leaf. +func (d *DepositKit) TimeoutScript() []byte { + return bytes.Clone(d.timeout) +} + +// TimeoutSpend constructs the sender's Bitcoin refund path. The transaction +// needs version >= 2 and sequence >= CSVExpiry blocks. Check chain maturity. +func (d *DepositKit) TimeoutSpend(assetRoot Hash) ( + *SwapAnchorSpendInfo, error) { + + return d.anchor.spend( + assetRoot, d.timeout, d.senderScript, d.params.CSVExpiry, 0, + ) +} + +// TimeoutWitness constructs the deposit's unilateral Bitcoin refund witness. +// ApplyScriptPathWitness accepts only the signature, not the final script and +// control block, which the SDK obtains from its sealed package. +func (d *DepositKit) TimeoutWitness(assetRoot Hash, + signature []byte) ([][]byte, error) { + + spend, err := d.TimeoutSpend(assetRoot) + if err != nil { + return nil, err + } + return spend.witness(signature, nil) +} + +// ReservationKitParams specifies a server-funded cooperative reservation with +// an absolute block-height refund. It never interprets a CSV delay as a height. +// ServerKey/ClientKey are the two-key convenience form; new callers may instead +// supply all four explicit roles, with the server as sender and refund signer. +type ReservationKitParams struct { + ServerKey PubKey + ClientKey PubKey + + SenderInternalKey PubKey + ReceiverInternalKey PubKey + SenderScriptKey PubKey + ReceiverScriptKey PubKey + RefundHeight uint32 +} + +// ReservationKit constructs the server-funded reservation policy. The server +// can refund after CLTV expiry; before that, spending requires cooperation. +type ReservationKit struct { + params ReservationKitParams + anchor swapAnchorPolicy + senderScript PubKey + timeout []byte +} + +// NewReservationKit validates and constructs a CLTV asset reservation. +func NewReservationKit(params ReservationKitParams) (*ReservationKit, error) { + if params.RefundHeight == 0 || + params.RefundHeight >= txscript.LockTimeThreshold { + + return nil, fmt.Errorf("reservation refund must be a block height") + } + keys, err := resolveFundingKeys(params.ServerKey, params.ClientKey, + params.SenderInternalKey, params.ReceiverInternalKey, + params.SenderScriptKey, params.ReceiverScriptKey) + if err != nil { + return nil, fmt.Errorf("reservation keys: %w", err) + } + timeout, err := swapTimeoutScript(keys.senderScript, + params.RefundHeight, txscript.OP_CHECKLOCKTIMEVERIFY) + if err != nil { + return nil, err + } + anchor, err := newSwapAnchorPolicy(keys.senderInternal, + keys.receiverInternal, [][]byte{timeout}) + if err != nil { + return nil, err + } + return &ReservationKit{params: params, anchor: anchor, + senderScript: keys.senderScript, timeout: timeout}, nil +} + +// Params returns a value copy of the immutable reservation parameters. +func (r *ReservationKit) Params() ReservationKitParams { return r.params } + +// AnchorPlan returns the cooperative internal key and reservation refund leaf. +func (r *ReservationKit) AnchorPlan() AnchorPlan { return r.anchor.plan() } + +// CooperativeParticipants returns the exact sorted MuSig2 participant order. +func (r *ReservationKit) CooperativeParticipants() []PubKey { + return slices.Clone(r.anchor.participants) +} + +// TimeoutScript returns an independent copy of the server's CLTV refund leaf. +func (r *ReservationKit) TimeoutScript() []byte { return bytes.Clone(r.timeout) } + +// TimeoutSpend constructs the server's refund path. Apply the height locktime +// and non-final input sequence before signing; the template opts into +// replacement without enabling BIP68. Check maturity against the chain. +func (r *ReservationKit) TimeoutSpend(assetRoot Hash) (*SwapAnchorSpendInfo, error) { + return r.anchor.spend(assetRoot, r.timeout, r.senderScript, + wire.MaxTxInSequenceNum-2, r.params.RefundHeight) +} + +// TimeoutWitness constructs the complete reservation refund witness. The SDK +// signing API instead takes only the signature prefix and adds script/control. +func (r *ReservationKit) TimeoutWitness(assetRoot Hash, + signature []byte) ([][]byte, error) { + + spend, err := r.TimeoutSpend(assetRoot) + if err != nil { + return nil, err + } + return spend.witness(signature, nil) +} + +// SwapAnchorSpendInfo contains Loop-owned Bitcoin script-path material. Compare +// PkScript with the authenticated prevout before signing. It does not prove +// issuance, provenance, amount, confirmation, or timelock maturity. +type SwapAnchorSpendInfo struct { + InternalKey PubKey + TaprootMerkleRoot Hash + PkScript []byte + LeafScript []byte + ControlBlock []byte + RequiredSigner [32]byte + Sequence uint32 + LockTime uint32 +} + +func (s *SwapAnchorSpendInfo) witness(signature, + preimage []byte) ([][]byte, error) { + + if err := validateSwapSignature(signature); err != nil { + return nil, err + } + witness := make([][]byte, 0, 4) + if preimage != nil { + witness = append(witness, bytes.Clone(preimage)) + } + return append( + witness, bytes.Clone(signature), bytes.Clone(s.LeafScript), + bytes.Clone(s.ControlBlock), + ), nil +} + +type swapAnchorPolicy struct { + internalKey PubKey + participants []PubKey + leaves [][]byte +} + +func newSwapAnchorPolicy(first, second PubKey, + leaves [][]byte) (swapAnchorPolicy, error) { + + if err := validateSwapKeyPair(first, second); err != nil { + return swapAnchorPolicy{}, fmt.Errorf("MuSig2 keys: %w", err) + } + participants := []PubKey{first, second} + slices.SortFunc(participants, func(first, second PubKey) int { + return bytes.Compare(first[:], second[:]) + }) + keys := make([]*btcec.PublicKey, len(participants)) + for i := range participants { + keys[i], _ = btcec.ParsePubKey(participants[i][:]) + } + aggregate, _, _, err := musig2.AggregateKeys(keys, false) + if err != nil { + return swapAnchorPolicy{}, fmt.Errorf("aggregate keys: %w", err) + } + key, err := parsePubKey(aggregate.PreTweakedKey.SerializeCompressed()) + if err != nil { + return swapAnchorPolicy{}, err + } + return swapAnchorPolicy{ + internalKey: key, participants: participants, leaves: leaves, + }, nil +} + +func (p swapAnchorPolicy) plan() AnchorPlan { + leaves := make([][]byte, len(p.leaves)) + for i := range p.leaves { + leaves[i] = bytes.Clone(p.leaves[i]) + } + return AnchorPlan{InternalKey: p.internalKey, Leaves: leaves} +} + +func (p swapAnchorPolicy) spend(assetRoot Hash, script []byte, signer PubKey, + sequence, lockTime uint32) (*SwapAnchorSpendInfo, error) { + + if assetRoot == (Hash{}) { + return nil, fmt.Errorf("asset commitment root is required") + } + leaves := make([]txscript.TapLeaf, len(p.leaves)) + for i := range p.leaves { + leaves[i] = txscript.NewBaseTapLeaf(p.leaves[i]) + } + tree := txscript.AssembleTaprootScriptTree(leaves...) + leafHash := txscript.NewBaseTapLeaf(script).TapHash() + proof := tree.LeafMerkleProofs[tree.LeafProofIndex[leafHash]] + internalKey, err := btcec.ParsePubKey(p.internalKey[:]) + if err != nil { + return nil, err + } + control := proof.ToControlBlock(internalKey) + control.InclusionProof = append( + bytes.Clone(control.InclusionProof), assetRoot[:]..., + ) + root := control.RootHash(script) + outputKey := txscript.ComputeTaprootOutputKey(internalKey, root) + control.OutputKeyYIsOdd = outputKey.SerializeCompressed()[0] == 0x03 + controlBytes, err := control.ToBytes() + if err != nil { + return nil, err + } + pkScript, err := txscript.PayToTaprootScript(outputKey) + if err != nil { + return nil, err + } + return &SwapAnchorSpendInfo{ + InternalKey: p.internalKey, + TaprootMerkleRoot: Hash(root), + PkScript: pkScript, + LeafScript: bytes.Clone(script), + ControlBlock: controlBytes, + RequiredSigner: [32]byte(signer[1:]), + Sequence: sequence, + LockTime: lockTime, + }, nil +} + +func swapTimeoutScript(key PubKey, expiry uint32, opcode byte) ([]byte, error) { + return timeoutScript([32]byte(key[1:]), int64(expiry), opcode) +} + +func validateSwapCSV(expiry uint32) error { + if expiry == 0 || expiry > wire.SequenceLockTimeMask { + return fmt.Errorf("CSV expiry must be 1 to 65535 blocks") + } + return nil +} + +func validateSwapKeyPair(first, second PubKey) error { + if err := validatePubKey("first key", first); err != nil { + return err + } + if err := validatePubKey("second key", second); err != nil { + return err + } + if bytes.Equal(first[1:], second[1:]) { + return fmt.Errorf("participant keys must differ") + } + return nil +} + +func validateSwapSignature(signature []byte) error { + if len(signature) != schnorr.SignatureSize && + len(signature) != schnorr.SignatureSize+1 { + + return fmt.Errorf("signature must be 64 or 65 bytes") + } + if len(signature) == schnorr.SignatureSize+1 { + switch txscript.SigHashType(signature[schnorr.SignatureSize]) { + case txscript.SigHashAll, txscript.SigHashNone, + txscript.SigHashSingle, + txscript.SigHashAll | txscript.SigHashAnyOneCanPay, + txscript.SigHashNone | txscript.SigHashAnyOneCanPay, + txscript.SigHashSingle | txscript.SigHashAnyOneCanPay: + + default: + return fmt.Errorf("invalid signature hash type") + } + } + _, err := schnorr.ParseSignature(signature[:schnorr.SignatureSize]) + if err != nil { + return fmt.Errorf("invalid Schnorr signature: %w", err) + } + return nil +} + +func parsePubKey(encoded []byte) (PubKey, error) { + if len(encoded) != 33 { + return PubKey{}, fmt.Errorf("public key must be 33 bytes") + } + if _, err := btcec.ParsePubKey(encoded); err != nil { + return PubKey{}, err + } + return PubKey(encoded), nil +} + +func validatePubKey(name string, key PubKey) error { + if _, err := parsePubKey(key[:]); err != nil { + return fmt.Errorf("%s: %w", name, err) + } + return nil +} + +// GenSuccessScript constructs the shared Bitcoin HTLC success leaf. +func GenSuccessScript(receiver PubKey, paymentHash Hash) ([]byte, error) { + if err := validatePubKey("receiver key", receiver); err != nil { + return nil, err + } + if paymentHash == (Hash{}) { + return nil, fmt.Errorf("payment hash is required") + } + return HTLCSuccessScript([32]byte(receiver[1:]), paymentHash) +} + +// GenCSVTimeoutScript constructs the shared block-based Bitcoin refund leaf. +func GenCSVTimeoutScript(sender PubKey, expiry uint32) ([]byte, error) { + if err := validatePubKey("sender key", sender); err != nil { + return nil, err + } + if err := validateSwapCSV(expiry); err != nil { + return nil, err + } + return swapTimeoutScript( + sender, expiry, txscript.OP_CHECKSEQUENCEVERIFY, + ) +} + +type fundingKeys struct { + senderInternal, receiverInternal PubKey + senderScript, receiverScript PubKey +} + +func resolveFundingKeys(legacySender, legacyReceiver, senderInternal, + receiverInternal, senderScript, receiverScript PubKey) (fundingKeys, error) { + + explicit := senderInternal != (PubKey{}) || receiverInternal != (PubKey{}) || + senderScript != (PubKey{}) || receiverScript != (PubKey{}) + if explicit { + if legacySender != (PubKey{}) || legacyReceiver != (PubKey{}) { + return fundingKeys{}, fmt.Errorf("cannot mix legacy and explicit key roles") + } + } else { + senderInternal, senderScript = legacySender, legacySender + receiverInternal, receiverScript = legacyReceiver, legacyReceiver + } + if err := validateContractKeyRoles(senderInternal, receiverInternal, + senderScript, receiverScript); err != nil { + return fundingKeys{}, err + } + return fundingKeys{senderInternal: senderInternal, + receiverInternal: receiverInternal, senderScript: senderScript, + receiverScript: receiverScript}, nil +} + +func validateContractKeyRoles(senderInternal, receiverInternal, + senderScript, receiverScript PubKey) error { + + for _, sender := range []PubKey{senderInternal, senderScript} { + for _, receiver := range []PubKey{receiverInternal, receiverScript} { + if err := validateSwapKeyPair(sender, receiver); err != nil { + return err + } + } + } + return nil +} diff --git a/swapkit/swapkit_test.go b/swapkit/swapkit_test.go new file mode 100644 index 000000000..0fb713184 --- /dev/null +++ b/swapkit/swapkit_test.go @@ -0,0 +1,472 @@ +package swapkit + +import ( + "bytes" + "crypto/sha256" + "encoding/hex" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/stretchr/testify/require" +) + +// TestSwapKitContractVectors freezes the Bitcoin contract vectors from Loop's +// shared-asset-kit HTLC tests, including the extra asset commitment sibling. +// V3 differs only in its CLTV refund opcode for these otherwise equal inputs. +func TestSwapKitContractVectors(t *testing.T) { + params := swapKitTestParams(t) + for i := range params.PaymentHash { + params.PaymentHash[i] = byte(i) + } + root := swapKitTestAssetRoot() + const successHex = "20c6047f9441ed7d6d3045406e95c07cd85c778e" + + "4b8cef3ca7abac09b95c709ee5ad82012088a914e6babb9619d7a812" + + "72711fc546a16b211dd939578851b2" + const timeoutPrefix = "2079be667ef9dcbbac55a06295ce870b07029bfcdb2d" + + "ce28d959f2815b16f81798ad029000" + const aggregateHex = "023b46d262d2f610e9038b44beabdfe97ab5a0feb" + + "89870acc2264edfb7f63ec2ec" + const successControlHex = "c13b46d262d2f610e9038b44beabdfe97ab5a0feb" + + "89" + + "870acc2264edfb7f63ec2eccbf40123d0ca1191c0dba575c7a92ea255" + + "f9e9fc81484e3929afeaa1a6f459d6a0a1a2a3a4a5a6a7a8a9aaab" + + "acadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf" + const timeoutControlHex = "c13b46d262d2f610e9038b44beabdfe97ab5a0feb" + + "89" + + "870acc2264edfb7f63ec2ec00114fbfd01b5de82dfa6f54f0f27af41" + + "d5a66ed39ac1a87d614fa12808f9adfa0a1a2a3a4a5a6a7a8a9aaab" + + "acadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf" + const anchorHex = "512021b15bddf2d991b8791ec7c2105fa69be61008d78" + + "b67d261451290d7a44dce5f" + + legacy, err := NewSwapKit(params) + require.NoError(t, err) + success, err := legacy.SuccessSpend(root) + require.NoError(t, err) + timeout, err := legacy.TimeoutSpend(root) + require.NoError(t, err) + require.Equal(t, successHex, hex.EncodeToString(success.LeafScript)) + require.Equal(t, timeoutPrefix+"b2", + hex.EncodeToString(timeout.LeafScript)) + anchorPlan := legacy.AnchorPlan() + require.Equal(t, aggregateHex, + hex.EncodeToString(anchorPlan.InternalKey[:])) + require.Equal(t, successControlHex, + hex.EncodeToString(success.ControlBlock)) + require.Equal(t, timeoutControlHex, + hex.EncodeToString(timeout.ControlBlock)) + require.Equal(t, anchorHex, hex.EncodeToString(success.PkScript)) + require.Equal(t, success.PkScript, timeout.PkScript) + + params.Policy = SwapHTLCStaticLoopInV3 + v3, err := NewSwapKit(params) + require.NoError(t, err) + v3Success, err := v3.SuccessSpend(root) + require.NoError(t, err) + v3Timeout, err := v3.TimeoutSpend(root) + require.NoError(t, err) + require.Equal(t, successHex, hex.EncodeToString(v3Success.LeafScript)) + require.Equal(t, timeoutPrefix+"b1", + hex.EncodeToString(v3Timeout.LeafScript)) + require.NotEqual(t, success.PkScript, v3Success.PkScript) + require.Equal(t, uint32(144), v3Timeout.LockTime) + require.Equal(t, wire.MaxTxInSequenceNum-2, v3Timeout.Sequence) + + deposit, err := NewDepositKit(DepositKitParams{ + ClientKey: params.SenderKey, ServerKey: params.ReceiverKey, + CSVExpiry: 144, + }) + require.NoError(t, err) + depositTimeout, err := deposit.TimeoutSpend(root) + require.NoError(t, err) + require.Equal(t, timeout.LeafScript, depositTimeout.LeafScript) + require.Equal(t, legacy.AnchorPlan().InternalKey, + deposit.AnchorPlan().InternalKey) + require.Len(t, depositTimeout.ControlBlock, 65) + require.Len(t, success.ControlBlock, 97) +} + +// TestSwapKitScriptExecution verifies authorization and timelock boundaries in +// the Bitcoin VM, signing each altered transaction afresh so a failed timelock +// cannot be masked by an unrelated invalid signature. +func TestSwapKitScriptExecution(t *testing.T) { + for _, policy := range []SwapHTLCPolicy{ + SwapHTLCLegacyCSV, SwapHTLCStaticLoopInV3, + } { + for _, success := range []bool{true, false} { + name := swapKitTestName(policy, success, "") + t.Run(name, func(t *testing.T) { + testSwapKitScriptExecution(t, policy, success) + }) + } + } +} + +func testSwapKitScriptExecution(t *testing.T, policy SwapHTLCPolicy, + success bool) { + + t.Helper() + params := swapKitTestParams(t) + params.Policy = policy + kit, err := NewSwapKit(params) + require.NoError(t, err) + type executionCase struct { + name string + mutateTx func(*wire.MsgTx) + mutate func([][]byte) + wrongKey bool + valid bool + } + tests := []executionCase{ + {name: "valid", valid: true}, + {name: "wrong signer", wrongKey: true}, + { + name: "wrong asset commitment", + mutate: func(w [][]byte) { + w[len(w)-1][len(w[len(w)-1])-1] ^= 1 + }, + }, + } + if success || policy == SwapHTLCLegacyCSV { + tests = append(tests, []executionCase{ + { + name: "early CSV", + mutateTx: func(tx *wire.MsgTx) { + tx.TxIn[0].Sequence-- + }, + }, + { + name: "version one", + mutateTx: func(tx *wire.MsgTx) { + tx.Version = 1 + }, + }, + { + name: "CSV disabled", + mutateTx: func(tx *wire.MsgTx) { + tx.TxIn[0].Sequence = 0x80000090 + }, + }, + { + name: "time-based CSV", + mutateTx: func(tx *wire.MsgTx) { + tx.TxIn[0].Sequence = 0x00400090 + }, + }, + }...) + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + root := swapKitTestAssetRoot() + spend, scalar := swapKitTestSpend(t, kit, root, success) + if test.wrongKey { + scalar = 3 + } + tx, prevOut, sig := swapKitSignTestTx( + t, spend, scalar, test.mutateTx, + ) + var witness [][]byte + var err error + if success { + witness, err = kit.SuccessWitness( + root, sig, [32]byte{42}, + ) + } else { + witness, err = kit.TimeoutWitness(root, sig) + } + require.NoError(t, err) + if test.mutate != nil { + test.mutate(witness) + } + tx.TxIn[0].Witness = witness + err = swapKitExecuteTestTx(tx, prevOut) + if test.valid { + require.NoError(t, err) + } else { + require.Error(t, err) + } + }) + } +} + +// TestSwapKitCLTVAndPreimage checks both on-chain enforcement and the kit's +// preimage boundary, including transaction locktime type and final sequences. +func TestSwapKitCLTVAndPreimage(t *testing.T) { + params := swapKitTestParams(t) + params.Policy = SwapHTLCStaticLoopInV3 + kit, err := NewSwapKit(params) + require.NoError(t, err) + root := swapKitTestAssetRoot() + spend, err := kit.TimeoutSpend(root) + require.NoError(t, err) + for _, test := range []struct { + name string + mutate func(*wire.MsgTx) + }{ + {"early height", func(tx *wire.MsgTx) { tx.LockTime-- }}, + {"time lock", func(tx *wire.MsgTx) { + tx.LockTime = 500_000_000 + }}, + {"final sequence", func(tx *wire.MsgTx) { + tx.TxIn[0].Sequence = wire.MaxTxInSequenceNum + }}, + } { + t.Run(test.name, func(t *testing.T) { + tx, prevOut, sig := swapKitSignTestTx( + t, spend, 1, test.mutate, + ) + tx.TxIn[0].Witness, err = kit.TimeoutWitness(root, sig) + require.NoError(t, err) + require.Error(t, swapKitExecuteTestTx(tx, prevOut)) + }) + } + + spend, err = kit.SuccessSpend(root) + require.NoError(t, err) + for _, preimage := range [][]byte{bytes.Repeat([]byte{7}, 32), {42}} { + tx, prevOut, sig := swapKitSignTestTx(t, spend, 2, nil) + witness, err := kit.SuccessWitness(root, sig, [32]byte{42}) + require.NoError(t, err) + witness[0] = preimage + tx.TxIn[0].Witness = witness + require.Error(t, swapKitExecuteTestTx(tx, prevOut)) + _, err = kit.SuccessWitness(root, sig, [32]byte{7}) + require.ErrorContains(t, err, "preimage does not match") + } +} + +// TestDepositKitScriptExecution verifies that the client alone can refund only +// with the correct version and block-based CSV sequence. +func TestDepositKitScriptExecution(t *testing.T) { + params := swapKitTestParams(t) + kit, err := NewDepositKit(DepositKitParams{ + ClientKey: params.SenderKey, ServerKey: params.ReceiverKey, + CSVExpiry: 144, + }) + require.NoError(t, err) + root := swapKitTestAssetRoot() + spend, err := kit.TimeoutSpend(root) + require.NoError(t, err) + for _, test := range []struct { + name string + mutate func(*wire.MsgTx) + key byte + valid bool + }{ + {name: "mature", key: 1, valid: true}, + {name: "server cannot refund", key: 2}, + {name: "early", key: 1, mutate: func(tx *wire.MsgTx) { + tx.TxIn[0].Sequence-- + }}, + {name: "version one", key: 1, mutate: func(tx *wire.MsgTx) { + tx.Version = 1 + }}, + {name: "CSV disabled", key: 1, mutate: func(tx *wire.MsgTx) { + tx.TxIn[0].Sequence |= wire.SequenceLockTimeDisabled + }}, + {name: "time-based CSV", key: 1, mutate: func(tx *wire.MsgTx) { + tx.TxIn[0].Sequence |= wire.SequenceLockTimeIsSeconds + }}, + } { + t.Run(test.name, func(t *testing.T) { + tx, prevOut, sig := swapKitSignTestTx( + t, spend, test.key, test.mutate, + ) + tx.TxIn[0].Witness, err = kit.TimeoutWitness(root, sig) + require.NoError(t, err) + err = swapKitExecuteTestTx(tx, prevOut) + if test.valid { + require.NoError(t, err) + } else { + require.Error(t, err) + } + }) + } +} + +// TestSwapKitValidation rejects malformed Bitcoin contract parameters. +func TestSwapKitValidation(t *testing.T) { + for _, test := range []struct { + name string + mutate func(*SwapKitParams) + }{ + {"no policy", func(p *SwapKitParams) { + p.Policy = SwapHTLCUnspecified + }}, + {"unknown policy", func(p *SwapKitParams) { p.Policy = 99 }}, + {"zero hash", func(p *SwapKitParams) { + p.PaymentHash = Hash{} + }}, + {"bad key", func(p *SwapKitParams) { + p.SenderKey = PubKey{} + }}, + {"same key", func(p *SwapKitParams) { + p.ReceiverKey = p.SenderKey + }}, + {"opposite key", func(p *SwapKitParams) { + p.ReceiverKey = p.SenderKey + p.ReceiverKey[0] ^= 1 + }}, + {"same internal key", func(p *SwapKitParams) { + p.ReceiverInternalKey = p.SenderInternalKey + }}, + {"zero expiry", func(p *SwapKitParams) { p.Expiry = 0 }}, + {"no claim margin", func(p *SwapKitParams) { p.Expiry = 1 }}, + {"large CSV", func(p *SwapKitParams) { p.Expiry = 65536 }}, + {"timestamp CLTV", func(p *SwapKitParams) { + p.Policy, p.Expiry = SwapHTLCStaticLoopInV3, 500_000_000 + }}, + } { + t.Run(test.name, func(t *testing.T) { + params := swapKitTestParams(t) + test.mutate(¶ms) + _, err := NewSwapKit(params) + require.Error(t, err) + }) + } + + kit, err := NewSwapKit(swapKitTestParams(t)) + require.NoError(t, err) + _, err = kit.SuccessSpend(Hash{}) + require.ErrorContains(t, err, "asset commitment root") + _, err = kit.TimeoutWitness(swapKitTestAssetRoot(), nil) + require.ErrorContains(t, err, "signature must be") +} + +// TestSwapKitSignatureEncoding rejects malformed Schnorr encodings and the +// forbidden explicit SIGHASH_DEFAULT byte; a valid explicit hash mode spends. +func TestSwapKitSignatureEncoding(t *testing.T) { + kit, err := NewSwapKit(swapKitTestParams(t)) + require.NoError(t, err) + root := swapKitTestAssetRoot() + spend, err := kit.TimeoutSpend(root) + require.NoError(t, err) + tx, prevOut, signature := swapKitSignTestTx(t, spend, 1, nil) + for _, invalid := range [][]byte{ + nil, signature[:63], append(bytes.Clone(signature), 0), + append(bytes.Clone(signature), 4), + append(bytes.Clone(signature), 0x80), + bytes.Repeat([]byte{0xff}, 64), + } { + _, err := kit.TimeoutWitness(root, invalid) + require.Error(t, err) + } + fetcher := txscript.NewCannedPrevOutputFetcher( + prevOut.PkScript, prevOut.Value, + ) + keyBytes := make([]byte, 32) + keyBytes[31] = 1 + key, _ := btcec.PrivKeyFromBytes(keyBytes) + signature, err = txscript.RawTxInTapscriptSignature( + tx, txscript.NewTxSigHashes(tx, fetcher), 0, prevOut.Value, + prevOut.PkScript, txscript.NewBaseTapLeaf(spend.LeafScript), + txscript.SigHashAll, key, + ) + require.NoError(t, err) + require.Len(t, signature, 65) + tx.TxIn[0].Witness, err = kit.TimeoutWitness(root, signature) + require.NoError(t, err) + require.NoError(t, swapKitExecuteTestTx(tx, prevOut)) + signature[0] ^= 1 + require.NotEqual(t, signature, tx.TxIn[0].Witness[0]) +} + +func swapKitTestParams(t *testing.T) SwapKitParams { + t.Helper() + sender := testKey(t, 1) + receiver := testKey(t, 2) + preimage := [32]byte{42} + return SwapKitParams{ + Policy: SwapHTLCLegacyCSV, + SenderKey: sender, ReceiverKey: receiver, + SenderInternalKey: sender, ReceiverInternalKey: receiver, + PaymentHash: sha256.Sum256(preimage[:]), + Expiry: 144, + } +} + +func swapKitTestAssetRoot() Hash { + var root Hash + for i := range root { + root[i] = byte(0xa0 + i) + } + return root +} + +func swapKitTestName(policy SwapHTLCPolicy, success bool, name string) string { + prefix := "legacy/" + if policy == SwapHTLCStaticLoopInV3 { + prefix = "v3/" + } + if success { + return prefix + "success/" + name + } + return prefix + "timeout/" + name +} + +func swapKitTestSpend(t *testing.T, kit *SwapKit, root Hash, + success bool) (*SwapAnchorSpendInfo, byte) { + + t.Helper() + if success { + spend, err := kit.SuccessSpend(root) + require.NoError(t, err) + return spend, 2 + } + spend, err := kit.TimeoutSpend(root) + require.NoError(t, err) + return spend, 1 +} + +func swapKitSignTestTx(t *testing.T, spend *SwapAnchorSpendInfo, + scalar byte, mutate func(*wire.MsgTx)) ( + *wire.MsgTx, *wire.TxOut, []byte) { + + t.Helper() + tx := wire.NewMsgTx(2) + tx.LockTime = spend.LockTime + tx.AddTxIn(wire.NewTxIn(&wire.OutPoint{Index: 1}, nil, nil)) + tx.TxIn[0].Sequence = spend.Sequence + tx.AddTxOut(&wire.TxOut{Value: 900, PkScript: spend.PkScript}) + prevOut := &wire.TxOut{Value: 1_000, PkScript: spend.PkScript} + if mutate != nil { + mutate(tx) + } + fetcher := txscript.NewCannedPrevOutputFetcher( + prevOut.PkScript, prevOut.Value, + ) + keyBytes := make([]byte, 32) + keyBytes[31] = scalar + key, _ := btcec.PrivKeyFromBytes(keyBytes) + sig, err := txscript.RawTxInTapscriptSignature( + tx, txscript.NewTxSigHashes(tx, fetcher), 0, prevOut.Value, + prevOut.PkScript, txscript.NewBaseTapLeaf(spend.LeafScript), + txscript.SigHashDefault, key, + ) + require.NoError(t, err) + return tx, prevOut, sig +} + +func swapKitExecuteTestTx(tx *wire.MsgTx, prevOut *wire.TxOut) error { + fetcher := txscript.NewCannedPrevOutputFetcher( + prevOut.PkScript, prevOut.Value, + ) + vm, err := txscript.NewEngine( + prevOut.PkScript, tx, 0, txscript.StandardVerifyFlags, nil, + txscript.NewTxSigHashes(tx, fetcher), prevOut.Value, fetcher, + ) + if err != nil { + return err + } + return vm.Execute() +} + +func testKey(t *testing.T, scalar byte) PubKey { + t.Helper() + encoded := make([]byte, 32) + encoded[31] = scalar + _, key := btcec.PrivKeyFromBytes(encoded) + return PubKey(key.SerializeCompressed()) +} diff --git a/swapkit/weight.go b/swapkit/weight.go new file mode 100644 index 000000000..aa8caf57b --- /dev/null +++ b/swapkit/weight.go @@ -0,0 +1,46 @@ +package swapkit + +import ( + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/wire" + "github.com/lightningnetwork/lnd/input" + "github.com/lightningnetwork/lnd/lntypes" +) + +// MaxSuccessWitnessSize returns the serialized size of a success witness with +// a 32-byte preimage and the largest accepted Schnorr signature, including its +// optional sighash byte. It uses the actual leaf and control block, including +// the asset commitment sibling. Witnesses produced by the kit have no annex. +func (s *SwapAnchorSpendInfo) MaxSuccessWitnessSize() lntypes.WeightUnit { + var signature [schnorr.SignatureSize + 1]byte + var preimage [32]byte + return lntypes.WeightUnit(wire.TxWitness{ + preimage[:], signature[:], s.LeafScript, s.ControlBlock, + }.SerializeSize()) +} + +// MaxTimeoutWitnessSize returns the serialized size of a refund witness with +// the largest accepted Schnorr signature, including its optional sighash byte. +// It uses the actual leaf and asset-aware control block and includes no annex. +func (s *SwapAnchorSpendInfo) MaxTimeoutWitnessSize() lntypes.WeightUnit { + var signature [schnorr.SignatureSize + 1]byte + return lntypes.WeightUnit(wire.TxWitness{ + signature[:], s.LeafScript, s.ControlBlock, + }.SerializeSize()) +} + +// AddSuccessToEstimator adds the complete success input to a weight estimate. +// Its leaf and asset commitment proof are already included in the witness size. +func (s *SwapAnchorSpendInfo) AddSuccessToEstimator( + estimator *input.TxWeightEstimator) { + + estimator.AddWitnessInput(s.MaxSuccessWitnessSize()) +} + +// AddTimeoutToEstimator adds the complete refund input to a weight estimate. +// Its leaf and asset commitment proof are already included in the witness size. +func (s *SwapAnchorSpendInfo) AddTimeoutToEstimator( + estimator *input.TxWeightEstimator) { + + estimator.AddWitnessInput(s.MaxTimeoutWitnessSize()) +} diff --git a/swapkit/weight_test.go b/swapkit/weight_test.go new file mode 100644 index 000000000..bae81a585 --- /dev/null +++ b/swapkit/weight_test.go @@ -0,0 +1,155 @@ +package swapkit + +import ( + "bytes" + "testing" + + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/lightningnetwork/lnd/input" + "github.com/lightningnetwork/lnd/lntypes" + "github.com/stretchr/testify/require" +) + +// TestAssetWitnessWeights compares both estimators with complete witnesses and +// transaction serializations for every supported asset anchor contract. +func TestAssetWitnessWeights(t *testing.T) { + root := swapKitTestAssetRoot() + params := swapKitTestParams(t) + type spendCase struct { + name string + spend *SwapAnchorSpendInfo + success bool + witness func([]byte) ([][]byte, error) + } + var cases []spendCase + for _, policy := range []SwapHTLCPolicy{ + SwapHTLCLegacyCSV, SwapHTLCCLTV, + } { + params.Policy = policy + kit, err := NewSwapKit(params) + require.NoError(t, err) + for _, success := range []bool{false, true} { + spend, _ := swapKitTestSpend(t, kit, root, success) + require.Len(t, spend.ControlBlock, 97) + witness := func(signature []byte) ([][]byte, error) { + return kit.TimeoutWitness(root, signature) + } + if success { + witness = func(signature []byte) ([][]byte, error) { + return kit.SuccessWitness(root, signature, [32]byte{42}) + } + } + cases = append(cases, spendCase{ + name: swapKitTestName(policy, success, ""), + spend: spend, success: success, witness: witness, + }) + } + } + deposit, err := NewDepositKit(DepositKitParams{ + ClientKey: params.SenderKey, ServerKey: params.ReceiverKey, + CSVExpiry: 144, + }) + require.NoError(t, err) + depositSpend, err := deposit.TimeoutSpend(root) + require.NoError(t, err) + require.Len(t, depositSpend.ControlBlock, 65) + cases = append(cases, spendCase{ + name: "deposit CSV refund", spend: depositSpend, + witness: func(signature []byte) ([][]byte, error) { + return deposit.TimeoutWitness(root, signature) + }, + }) + reservation, err := NewReservationKit(ReservationKitParams{ + ServerKey: params.SenderKey, ClientKey: params.ReceiverKey, + RefundHeight: 1_000_000, + }) + require.NoError(t, err) + reservationSpend, err := reservation.TimeoutSpend(root) + require.NoError(t, err) + require.Len(t, reservationSpend.ControlBlock, 65) + cases = append(cases, spendCase{ + name: "reservation CLTV refund", spend: reservationSpend, + witness: func(signature []byte) ([][]byte, error) { + return reservation.TimeoutWitness(root, signature) + }, + }) + + for _, test := range cases { + t.Run(test.name, func(t *testing.T) { + key := byte(1) + if test.success { + key = 2 + } + tx, _, signature := swapKitSignTestTx(t, test.spend, key, nil) + for _, explicitSighash := range []bool{false, true} { + signature := bytes.Clone(signature) + if explicitSighash { + signature = append(signature, byte(txscript.SigHashAll)) + } + tx.TxIn[0].Witness, err = test.witness(signature) + require.NoError(t, err) + var full, stripped bytes.Buffer + require.NoError(t, tx.Serialize(&full)) + require.NoError(t, tx.SerializeNoWitness(&stripped)) + witnessSize := tx.TxIn[0].Witness.SerializeSize() + require.Equal(t, witnessSize, full.Len()-stripped.Len()-2) + + var estimator input.TxWeightEstimator + maxSize := test.spend.MaxTimeoutWitnessSize() + if test.success { + maxSize = test.spend.MaxSuccessWitnessSize() + test.spend.AddSuccessToEstimator(&estimator) + } else { + test.spend.AddTimeoutToEstimator(&estimator) + } + estimator.AddTxOutput(tx.TxOut[0]) + padding := schnorr.SignatureSize + 1 - len(signature) + require.EqualValues(t, witnessSize+padding, maxSize) + weight := 3*stripped.Len() + full.Len() + padding + require.Equal(t, lntypes.WeightUnit(weight), estimator.Weight()) + } + }) + } +} + +// TestCLTVRefundRBFDefaults checks new templates signal replacement while the +// old non-RBF sequence still satisfies the same immutable funded contract. +func TestCLTVRefundRBFDefaults(t *testing.T) { + root := swapKitTestAssetRoot() + params := swapKitTestParams(t) + params.Policy = SwapHTLCCLTV + htlc, err := NewSwapKit(params) + require.NoError(t, err) + htlcSpend, err := htlc.TimeoutSpend(root) + require.NoError(t, err) + reservation, err := NewReservationKit(ReservationKitParams{ + ServerKey: params.SenderKey, ClientKey: params.ReceiverKey, + RefundHeight: params.Expiry, + }) + require.NoError(t, err) + reservationSpend, err := reservation.TimeoutSpend(root) + require.NoError(t, err) + for name, spend := range map[string]*SwapAnchorSpendInfo{ + "HTLC": htlcSpend, "reservation": reservationSpend, + } { + t.Run(name, func(t *testing.T) { + require.EqualValues(t, 0xfffffffd, spend.Sequence) + require.Less(t, spend.Sequence, wire.MaxTxInSequenceNum-1) + require.NotZero(t, spend.Sequence&wire.SequenceLockTimeDisabled) + for _, sequence := range []uint32{ + spend.Sequence, wire.MaxTxInSequenceNum - 1, + } { + tx, previous, signature := swapKitSignTestTx( + t, spend, 1, func(tx *wire.MsgTx) { + tx.TxIn[0].Sequence = sequence + }, + ) + tx.TxIn[0].Witness, err = spend.witness(signature, nil) + require.NoError(t, err) + require.NoError(t, swapKitExecuteTestTx(tx, previous)) + } + }) + } +} From 0d63469193bd8fd11282b4fb4f620461dfd0abd8 Mon Sep 17 00:00:00 2001 From: Slyghtning Date: Tue, 3 Nov 2026 11:13:14 +0100 Subject: [PATCH 3/9] tapsdk: Use tap-sdk v0.1.1 and require Taproot Assets v0.8.8 Build the adapter against released pre-btcd-v2 modules and retain the bounded legacy TLV decoder. Map contracts into SDK plans and reuse the authenticated wallet connection. Define the shared runtime version floor and operation-scoped checks. Warn about older backends during daemon initialization while leaving ordinary payments and offline witness construction available. --- .github/actions/lit-setup/action.yml | 8 + assets/tapd_version.go | 42 + assets/tapd_version_test.go | 131 ++ go.mod | 45 +- go.sum | 1264 ++++++++++++++++-- internal/assetpolicy/tapd_version.go | 142 ++ internal/assetpolicy/tapd_version_test.go | 71 + loopd/daemon.go | 9 + swapkit/asset_types.go | 10 + swapkit/tapsdk/asset.go | 106 ++ swapkit/tapsdk/asset_test.go | 119 ++ swapkit/tapsdk/binding_test.go | 7 + swapkit/tapsdk/builder_fixture_test.go | 128 ++ swapkit/tapsdk/client.go | 108 ++ swapkit/tapsdk/client_test.go | 207 +++ swapkit/tapsdk/proof_tlv_test.go | 53 + swapkit/tapsdk/swapkit.go | 74 + swapkit/tapsdk/swapkit_test.go | 147 ++ swapkit/tapsdk/testdata/builder_request.json | 385 ++++++ 19 files changed, 2923 insertions(+), 133 deletions(-) create mode 100644 assets/tapd_version.go create mode 100644 assets/tapd_version_test.go create mode 100644 internal/assetpolicy/tapd_version.go create mode 100644 internal/assetpolicy/tapd_version_test.go create mode 100644 swapkit/asset_types.go create mode 100644 swapkit/tapsdk/asset.go create mode 100644 swapkit/tapsdk/asset_test.go create mode 100644 swapkit/tapsdk/binding_test.go create mode 100644 swapkit/tapsdk/builder_fixture_test.go create mode 100644 swapkit/tapsdk/client.go create mode 100644 swapkit/tapsdk/client_test.go create mode 100644 swapkit/tapsdk/proof_tlv_test.go create mode 100644 swapkit/tapsdk/swapkit.go create mode 100644 swapkit/tapsdk/swapkit_test.go create mode 100644 swapkit/tapsdk/testdata/builder_request.json diff --git a/.github/actions/lit-setup/action.yml b/.github/actions/lit-setup/action.yml index a3f6a1704..bf8476f93 100644 --- a/.github/actions/lit-setup/action.yml +++ b/.github/actions/lit-setup/action.yml @@ -21,6 +21,14 @@ runs: go mod edit -replace=github.com/lightninglabs/loop=../ go mod edit -replace=github.com/lightninglabs/loop/looprpc=../looprpc go mod edit -replace=github.com/lightninglabs/loop/swapserverrpc=../swapserverrpc + # Module replacements are not inherited by the combined daemon. + # Keep its proof decoder and other source overrides aligned with Loop. + while IFS= read -r replacement; do + go mod edit "$replacement" + done < <(go mod edit -json ../go.mod | jq -r ' + .Replace[] | select(.New.Version != null) | + "-replace=\(.Old.Path)\(if .Old.Version then "@" + .Old.Version else "" end)=\(.New.Path)@\(.New.Version)" + ') go mod tidy shell: bash diff --git a/assets/tapd_version.go b/assets/tapd_version.go new file mode 100644 index 000000000..3a33da666 --- /dev/null +++ b/assets/tapd_version.go @@ -0,0 +1,42 @@ +package assets + +import ( + "context" + + policy "github.com/lightninglabs/loop/internal/assetpolicy" +) + +// MinOnchainSwapTapdVersion is the oldest tapd release that may create new +// shared-kit swap addresses or verify an untrusted HTLC/deposit history. The +// kit checks the running tapd at those RPC boundaries. It does not gate +// ordinary asset payments or local claim/refund witness construction. Recovery +// still needs valid proofs and compliant new transfers; no recovery manager is +// implemented by this version check. +// +// Taproot Assets v0.8.8 fixes asset invoice settlement. Keep the minimum +// in the shared policy used by the client, server, and SDK adapter. +const MinOnchainSwapTapdVersion = policy.MinOnchainSwapTapdVersion + +// ErrTapdVersionUnsupported is returned when tapd is older than +// MinOnchainSwapTapdVersion or reports a version that cannot be parsed. +var ErrTapdVersionUnsupported = policy.ErrTapdVersionUnsupported + +// CheckOnchainSwapTapdVersion checks a tapd GetInfo version against the shared +// kit's floor. Applications must also check it before offering or funding new +// swaps through APIs outside the kit. This function does not establish that an +// older backend can safely recover an existing swap. +func CheckOnchainSwapTapdVersion(version string) error { + return policy.CheckOnchainSwapTapdVersion(version) +} + +// TapdInfoClient is the narrow runtime version boundary shared with on-chain +// swap integrations that perform address creation, offering or funding outside +// the kit helpers. +type TapdInfoClient = policy.TapdInfoClient + +// RequireOnchainSwapTapd checks the connected tapd immediately before starting +// an on-chain asset swap operation outside the kit. It leaves ordinary asset +// payments and local recovery signing independent of the version floor. +func RequireOnchainSwapTapd(ctx context.Context, client TapdInfoClient) error { + return policy.RequireOnchainSwapTapd(ctx, client) +} diff --git a/assets/tapd_version_test.go b/assets/tapd_version_test.go new file mode 100644 index 000000000..185e664d5 --- /dev/null +++ b/assets/tapd_version_test.go @@ -0,0 +1,131 @@ +package assets + +import ( + "context" + "testing" + + "github.com/lightninglabs/taproot-assets/taprpc" + "github.com/stretchr/testify/require" + "google.golang.org/grpc" +) + +// TestCheckOnchainSwapTapdVersion checks the on-chain swap floor against the +// version strings that tapd reports in GetInfo. +func TestCheckOnchainSwapTapdVersion(t *testing.T) { + tests := []struct { + name string + version string + supported bool + }{ + { + name: "minimum release", + version: "0.8.8-alpha commit=v0.8.8", + supported: true, + }, + { + name: "prefixed minimum release", + version: "v0.8.8", + supported: true, + }, + { + name: "minimum release candidate", + version: "0.8.8-alpha.rc1 commit=v0.8.8-rc1", + }, + { + name: "newer patch", + version: "0.8.9-alpha", + supported: true, + }, + { + name: "newer minor", + version: "0.9.0-alpha", + supported: true, + }, + { + name: "newer major", + version: "1.0.0", + supported: true, + }, + { + name: "v0.8.6 settlement regression", + version: "0.8.6-alpha", + }, + { + name: "older patch", + version: "0.8.7-alpha commit=v0.8.7", + }, + { + name: "older minor", + version: "0.7.9", + }, + { + name: "empty", + version: "", + }, + { + name: "missing patch", + version: "0.8", + }, + { + name: "extra component", + version: "0.8.8.1", + }, + { + name: "negative component", + version: "0.-8.6", + }, + { + name: "not a version", + version: "garbage", + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + err := CheckOnchainSwapTapdVersion(test.version) + if test.supported { + require.NoError(t, err) + return + } + require.ErrorIs(t, err, ErrTapdVersionUnsupported) + }) + } +} + +// TestMinOnchainSwapTapdVersion checks that the floor itself is a parseable +// release, as an invalid floor would reject every tapd version. +func TestMinOnchainSwapTapdVersion(t *testing.T) { + require.Equal(t, "0.8.8", MinOnchainSwapTapdVersion) + require.NoError(t, CheckOnchainSwapTapdVersion( + MinOnchainSwapTapdVersion, + )) +} + +type tapdInfoClient struct { + version string +} + +func (c tapdInfoClient) GetInfo(context.Context, *taprpc.GetInfoRequest, + ...grpc.CallOption) (*taprpc.GetInfoResponse, error) { + + return &taprpc.GetInfoResponse{Version: c.version}, nil +} + +// TestRequireOnchainSwapTapd exercises the public runtime gate used by other +// applications before offering or funding a new swap through their own APIs. +func TestRequireOnchainSwapTapd(t *testing.T) { + for _, version := range []string{"0.8.7-alpha", "0.8.8-alpha"} { + t.Run(version, func(t *testing.T) { + err := RequireOnchainSwapTapd(t.Context(), tapdInfoClient{ + version: version, + }) + if version == "0.8.8-alpha" { + require.NoError(t, err) + return + } + require.ErrorIs(t, err, ErrTapdVersionUnsupported) + }) + } + require.ErrorIs(t, RequireOnchainSwapTapd(t.Context(), nil), + ErrTapdVersionUnsupported) +} diff --git a/go.mod b/go.mod index 72d366e22..1857034d2 100644 --- a/go.mod +++ b/go.mod @@ -7,7 +7,7 @@ require ( github.com/btcsuite/btcd/btcutil/psbt v1.1.10 github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 github.com/btcsuite/btclog/v2 v2.0.1-0.20250728225537-6090e87c6c5b - github.com/btcsuite/btcwallet v0.16.18 + github.com/btcsuite/btcwallet v0.16.19 github.com/btcsuite/btcwallet/wtxmgr v1.5.6 github.com/davecgh/go-spew v1.1.1 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 @@ -16,23 +16,24 @@ require ( github.com/google/go-cmp v0.7.0 github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 github.com/jackc/pgerrcode v0.0.0-20240316143900-6e2875d9b438 - github.com/jackc/pgx/v5 v5.9.2 + github.com/jackc/pgx/v5 v5.11.0 github.com/jessevdk/go-flags v1.6.1 github.com/lib/pq v1.10.9 github.com/lightninglabs/aperture v0.4.0 github.com/lightninglabs/lndclient v0.21.0-2 github.com/lightninglabs/loop/looprpc v1.0.17-0.20261021185954-333ed1efccdd github.com/lightninglabs/loop/swapserverrpc v1.0.14 - github.com/lightninglabs/taproot-assets v0.8.1 - github.com/lightninglabs/taproot-assets/taprpc v1.2.0 + github.com/lightninglabs/tap-sdk v0.1.1 + github.com/lightninglabs/taproot-assets v0.8.8 + github.com/lightninglabs/taproot-assets/taprpc v1.3.3 github.com/lightningnetwork/lightning-onion v1.3.0 - github.com/lightningnetwork/lnd v0.21.0-beta + github.com/lightningnetwork/lnd v0.21.3-beta github.com/lightningnetwork/lnd/cert v1.2.2 github.com/lightningnetwork/lnd/clock v1.1.1 github.com/lightningnetwork/lnd/queue v1.2.0 github.com/lightningnetwork/lnd/ticker v1.1.1 github.com/lightningnetwork/lnd/tlv v1.3.2 - github.com/lightningnetwork/lnd/tor v1.1.6 + github.com/lightningnetwork/lnd/tor v1.1.7 github.com/ory/dockertest/v3 v3.10.0 github.com/stretchr/testify v1.11.1 github.com/urfave/cli-docs/v3 v3.1.1-0.20251020101624-bec07369b4f6 @@ -45,7 +46,7 @@ require ( google.golang.org/protobuf v1.36.11 gopkg.in/macaroon-bakery.v2 v2.3.0 gopkg.in/macaroon.v2 v2.1.0 - modernc.org/sqlite v1.34.5 + modernc.org/sqlite v1.59.0 ) require ( @@ -86,7 +87,7 @@ require ( github.com/docker/go-connections v0.7.0 // indirect github.com/docker/go-units v0.5.0 // indirect github.com/dustin/go-humanize v1.0.1 // indirect - github.com/felixge/httpsnoop v1.0.4 // indirect + github.com/felixge/httpsnoop v1.1.0 // indirect github.com/fergusstrange/embedded-postgres v1.25.0 // indirect github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect @@ -95,7 +96,7 @@ require ( github.com/gogo/protobuf v1.3.2 // indirect github.com/golang-jwt/jwt/v4 v4.5.2 // indirect github.com/golang/protobuf v1.5.4 // indirect - github.com/golang/snappy v0.0.4 // indirect + github.com/golang/snappy v1.0.0 // indirect github.com/google/btree v1.0.1 // indirect github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect github.com/google/uuid v1.6.0 // indirect @@ -116,6 +117,7 @@ require ( github.com/kkdai/bstream v1.0.0 // indirect github.com/klauspost/compress v1.18.7 // indirect github.com/lightninglabs/gozmq v0.0.0-20191113021534-d20a764486bf // indirect + github.com/lightninglabs/lightning-node-connect/hashmailrpc v1.0.4-0.20250610182311-2f1d46ef18b7 // indirect github.com/lightninglabs/neutrino v0.17.1 // indirect github.com/lightninglabs/neutrino/cache v1.1.3 // indirect github.com/lightningnetwork/lnd/actor v0.0.6 // indirect @@ -124,8 +126,7 @@ require ( github.com/lightningnetwork/lnd/kvdb v1.5.1 // indirect github.com/lightningnetwork/lnd/sqldb v1.0.13 // indirect github.com/ltcsuite/ltcd v0.0.0-20190101042124-f37f8bf35796 // indirect - github.com/mattn/go-isatty v0.0.20 // indirect - github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect + github.com/mattn/go-isatty v0.0.24 // indirect github.com/miekg/dns v1.1.50 // indirect github.com/moby/docker-image-spec v1.3.1 // indirect github.com/moby/moby/api v1.54.2 // indirect @@ -134,15 +135,16 @@ require ( github.com/moby/term v0.5.2 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.2 // indirect - github.com/ncruces/go-strftime v0.1.9 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/ncruces/go-strftime v1.0.0 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect github.com/opencontainers/image-spec v1.1.1 // indirect github.com/opencontainers/runc v1.3.6 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/prometheus/client_golang v1.14.0 // indirect - github.com/prometheus/client_model v0.3.0 // indirect - github.com/prometheus/common v0.37.0 // indirect - github.com/prometheus/procfs v0.8.0 // indirect + github.com/prometheus/client_golang v1.23.2 // indirect + github.com/prometheus/client_model v0.6.2 // indirect + github.com/prometheus/common v0.66.1 // indirect + github.com/prometheus/procfs v0.16.1 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/rogpeppe/fastuuid v1.2.0 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect @@ -179,6 +181,7 @@ require ( go.uber.org/atomic v1.10.0 // indirect go.uber.org/multierr v1.6.0 // indirect go.uber.org/zap v1.24.0 // indirect + go.yaml.in/yaml/v2 v2.4.2 // indirect go.yaml.in/yaml/v3 v3.0.4 // indirect golang.org/x/exp v0.0.0-20250811191247-51f88131bc50 // indirect golang.org/x/mod v0.38.0 // indirect @@ -194,9 +197,9 @@ require ( gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - modernc.org/libc v1.55.3 // indirect - modernc.org/mathutil v1.6.0 // indirect - modernc.org/memory v1.8.0 // indirect + modernc.org/libc v1.75.7 // indirect + modernc.org/mathutil v1.7.1 // indirect + modernc.org/memory v1.12.1 // indirect pgregory.net/rapid v1.2.0 // indirect sigs.k8s.io/yaml v1.2.0 // indirect ) @@ -239,3 +242,7 @@ godebug multipathtcp=0 // vulnerable legacy pgx v4/pgproto3 dependency chain. Remove this replacement // once the required lnd version includes an sqldb release with that migration. replace github.com/lightningnetwork/lnd/sqldb v1.0.13 => github.com/lightningnetwork/lnd/sqldb v1.0.13-0.20260514041430-e9b422f78581 + +// Match the bounded legacy TLV decoder shipped with tapd v0.8.8. Replacements +// are not inherited: consuming binaries must include this pin as well. +replace github.com/lightningnetwork/lnd/tlv => github.com/lightninglabs/taproot-assets/third_party/lnd/tlv v0.0.0-20261022183431-6e0fef585a97 diff --git a/go.sum b/go.sum index f6325acd2..fb2df0c79 100644 --- a/go.sum +++ b/go.sum @@ -3,6 +3,7 @@ cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= @@ -13,30 +14,594 @@ cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKV cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= +cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= +cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= +cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= +cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= +cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY= +cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM= +cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY= +cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ= +cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI= +cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4= +cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc= +cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA= +cloud.google.com/go v0.100.1/go.mod h1:fs4QogzfH5n2pBXBP9vRiU+eCny7lD2vmFZy79Iuw1U= +cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A= +cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc= +cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU= +cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA= +cloud.google.com/go v0.105.0/go.mod h1:PrLgOJNe5nfE9UMxKxgXj4mD3voiP+YQ6gdt6KMFOKM= +cloud.google.com/go v0.107.0/go.mod h1:wpc2eNrD7hXUTy8EKS10jkxpZBjASrORK7goS+3YX2I= +cloud.google.com/go v0.110.0/go.mod h1:SJnCLqQ0FCFGSZMUNUf84MV3Aia54kn7pi8st7tMzaY= +cloud.google.com/go/accessapproval v1.4.0/go.mod h1:zybIuC3KpDOvotz59lFe5qxRZx6C75OtwbisN56xYB4= +cloud.google.com/go/accessapproval v1.5.0/go.mod h1:HFy3tuiGvMdcd/u+Cu5b9NkO1pEICJ46IR82PoUdplw= +cloud.google.com/go/accessapproval v1.6.0/go.mod h1:R0EiYnwV5fsRFiKZkPHr6mwyk2wxUJ30nL4j2pcFY2E= +cloud.google.com/go/accesscontextmanager v1.3.0/go.mod h1:TgCBehyr5gNMz7ZaH9xubp+CE8dkrszb4oK9CWyvD4o= +cloud.google.com/go/accesscontextmanager v1.4.0/go.mod h1:/Kjh7BBu/Gh83sv+K60vN9QE5NJcd80sU33vIe2IFPE= +cloud.google.com/go/accesscontextmanager v1.6.0/go.mod h1:8XCvZWfYw3K/ji0iVnp+6pu7huxoQTLmxAbVjbloTtM= +cloud.google.com/go/accesscontextmanager v1.7.0/go.mod h1:CEGLewx8dwa33aDAZQujl7Dx+uYhS0eay198wB/VumQ= +cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw= +cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY= +cloud.google.com/go/aiplatform v1.27.0/go.mod h1:Bvxqtl40l0WImSb04d0hXFU7gDOiq9jQmorivIiWcKg= +cloud.google.com/go/aiplatform v1.35.0/go.mod h1:7MFT/vCaOyZT/4IIFfxH4ErVg/4ku6lKv3w0+tFTgXQ= +cloud.google.com/go/aiplatform v1.36.1/go.mod h1:WTm12vJRPARNvJ+v6P52RDHCNe4AhvjcIZ/9/RRHy/k= +cloud.google.com/go/aiplatform v1.37.0/go.mod h1:IU2Cv29Lv9oCn/9LkFiiuKfwrRTq+QQMbW+hPCxJGZw= +cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI= +cloud.google.com/go/analytics v0.12.0/go.mod h1:gkfj9h6XRf9+TS4bmuhPEShsh3hH8PAZzm/41OOhQd4= +cloud.google.com/go/analytics v0.17.0/go.mod h1:WXFa3WSym4IZ+JiKmavYdJwGG/CvpqiqczmL59bTD9M= +cloud.google.com/go/analytics v0.18.0/go.mod h1:ZkeHGQlcIPkw0R/GW+boWHhCOR43xz9RN/jn7WcqfIE= +cloud.google.com/go/analytics v0.19.0/go.mod h1:k8liqf5/HCnOUkbawNtrWWc+UAzyDlW89doe8TtoDsE= +cloud.google.com/go/apigateway v1.3.0/go.mod h1:89Z8Bhpmxu6AmUxuVRg/ECRGReEdiP3vQtk4Z1J9rJk= +cloud.google.com/go/apigateway v1.4.0/go.mod h1:pHVY9MKGaH9PQ3pJ4YLzoj6U5FUDeDFBllIz7WmzJoc= +cloud.google.com/go/apigateway v1.5.0/go.mod h1:GpnZR3Q4rR7LVu5951qfXPJCHquZt02jf7xQx7kpqN8= +cloud.google.com/go/apigeeconnect v1.3.0/go.mod h1:G/AwXFAKo0gIXkPTVfZDd2qA1TxBXJ3MgMRBQkIi9jc= +cloud.google.com/go/apigeeconnect v1.4.0/go.mod h1:kV4NwOKqjvt2JYR0AoIWo2QGfoRtn/pkS3QlHp0Ni04= +cloud.google.com/go/apigeeconnect v1.5.0/go.mod h1:KFaCqvBRU6idyhSNyn3vlHXc8VMDJdRmwDF6JyFRqZ8= +cloud.google.com/go/apigeeregistry v0.4.0/go.mod h1:EUG4PGcsZvxOXAdyEghIdXwAEi/4MEaoqLMLDMIwKXY= +cloud.google.com/go/apigeeregistry v0.5.0/go.mod h1:YR5+s0BVNZfVOUkMa5pAR2xGd0A473vA5M7j247o1wM= +cloud.google.com/go/apigeeregistry v0.6.0/go.mod h1:BFNzW7yQVLZ3yj0TKcwzb8n25CFBri51GVGOEUcgQsc= +cloud.google.com/go/apikeys v0.4.0/go.mod h1:XATS/yqZbaBK0HOssf+ALHp8jAlNHUgyfprvNcBIszU= +cloud.google.com/go/apikeys v0.5.0/go.mod h1:5aQfwY4D+ewMMWScd3hm2en3hCj+BROlyrt3ytS7KLI= +cloud.google.com/go/apikeys v0.6.0/go.mod h1:kbpXu5upyiAlGkKrJgQl8A0rKNNJ7dQ377pdroRSSi8= +cloud.google.com/go/appengine v1.4.0/go.mod h1:CS2NhuBuDXM9f+qscZ6V86m1MIIqPj3WC/UoEuR1Sno= +cloud.google.com/go/appengine v1.5.0/go.mod h1:TfasSozdkFI0zeoxW3PTBLiNqRmzraodCWatWI9Dmak= +cloud.google.com/go/appengine v1.6.0/go.mod h1:hg6i0J/BD2cKmDJbaFSYHFyZkgBEfQrDg/X0V5fJn84= +cloud.google.com/go/appengine v1.7.0/go.mod h1:eZqpbHFCqRGa2aCdope7eC0SWLV1j0neb/QnMJVWx6A= +cloud.google.com/go/appengine v1.7.1/go.mod h1:IHLToyb/3fKutRysUlFO0BPt5j7RiQ45nrzEJmKTo6E= +cloud.google.com/go/area120 v0.5.0/go.mod h1:DE/n4mp+iqVyvxHN41Vf1CR602GiHQjFPusMFW6bGR4= +cloud.google.com/go/area120 v0.6.0/go.mod h1:39yFJqWVgm0UZqWTOdqkLhjoC7uFfgXRC8g/ZegeAh0= +cloud.google.com/go/area120 v0.7.0/go.mod h1:a3+8EUD1SX5RUcCs3MY5YasiO1z6yLiNLRiFrykbynY= +cloud.google.com/go/area120 v0.7.1/go.mod h1:j84i4E1RboTWjKtZVWXPqvK5VHQFJRF2c1Nm69pWm9k= +cloud.google.com/go/artifactregistry v1.6.0/go.mod h1:IYt0oBPSAGYj/kprzsBjZ/4LnG/zOcHyFHjWPCi6SAQ= +cloud.google.com/go/artifactregistry v1.7.0/go.mod h1:mqTOFOnGZx8EtSqK/ZWcsm/4U8B77rbcLP6ruDU2Ixk= +cloud.google.com/go/artifactregistry v1.8.0/go.mod h1:w3GQXkJX8hiKN0v+at4b0qotwijQbYUqF2GWkZzAhC0= +cloud.google.com/go/artifactregistry v1.9.0/go.mod h1:2K2RqvA2CYvAeARHRkLDhMDJ3OXy26h3XW+3/Jh2uYc= +cloud.google.com/go/artifactregistry v1.11.1/go.mod h1:lLYghw+Itq9SONbCa1YWBoWs1nOucMH0pwXN1rOBZFI= +cloud.google.com/go/artifactregistry v1.11.2/go.mod h1:nLZns771ZGAwVLzTX/7Al6R9ehma4WUEhZGWV6CeQNQ= +cloud.google.com/go/artifactregistry v1.12.0/go.mod h1:o6P3MIvtzTOnmvGagO9v/rOjjA0HmhJ+/6KAXrmYDCI= +cloud.google.com/go/artifactregistry v1.13.0/go.mod h1:uy/LNfoOIivepGhooAUpL1i30Hgee3Cu0l4VTWHUC08= +cloud.google.com/go/asset v1.5.0/go.mod h1:5mfs8UvcM5wHhqtSv8J1CtxxaQq3AdBxxQi2jGW/K4o= +cloud.google.com/go/asset v1.7.0/go.mod h1:YbENsRK4+xTiL+Ofoj5Ckf+O17kJtgp3Y3nn4uzZz5s= +cloud.google.com/go/asset v1.8.0/go.mod h1:mUNGKhiqIdbr8X7KNayoYvyc4HbbFO9URsjbytpUaW0= +cloud.google.com/go/asset v1.9.0/go.mod h1:83MOE6jEJBMqFKadM9NLRcs80Gdw76qGuHn8m3h8oHQ= +cloud.google.com/go/asset v1.10.0/go.mod h1:pLz7uokL80qKhzKr4xXGvBQXnzHn5evJAEAtZiIb0wY= +cloud.google.com/go/asset v1.11.1/go.mod h1:fSwLhbRvC9p9CXQHJ3BgFeQNM4c9x10lqlrdEUYXlJo= +cloud.google.com/go/asset v1.12.0/go.mod h1:h9/sFOa4eDIyKmH6QMpm4eUK3pDojWnUhTgJlk762Hg= +cloud.google.com/go/asset v1.13.0/go.mod h1:WQAMyYek/b7NBpYq/K4KJWcRqzoalEsxz/t/dTk4THw= +cloud.google.com/go/assuredworkloads v1.5.0/go.mod h1:n8HOZ6pff6re5KYfBXcFvSViQjDwxFkAkmUFffJRbbY= +cloud.google.com/go/assuredworkloads v1.6.0/go.mod h1:yo2YOk37Yc89Rsd5QMVECvjaMKymF9OP+QXWlKXUkXw= +cloud.google.com/go/assuredworkloads v1.7.0/go.mod h1:z/736/oNmtGAyU47reJgGN+KVoYoxeLBoj4XkKYscNI= +cloud.google.com/go/assuredworkloads v1.8.0/go.mod h1:AsX2cqyNCOvEQC8RMPnoc0yEarXQk6WEKkxYfL6kGIo= +cloud.google.com/go/assuredworkloads v1.9.0/go.mod h1:kFuI1P78bplYtT77Tb1hi0FMxM0vVpRC7VVoJC3ZoT0= +cloud.google.com/go/assuredworkloads v1.10.0/go.mod h1:kwdUQuXcedVdsIaKgKTp9t0UJkE5+PAVNhdQm4ZVq2E= +cloud.google.com/go/automl v1.5.0/go.mod h1:34EjfoFGMZ5sgJ9EoLsRtdPSNZLcfflJR39VbVNS2M0= +cloud.google.com/go/automl v1.6.0/go.mod h1:ugf8a6Fx+zP0D59WLhqgTDsQI9w07o64uf/Is3Nh5p8= +cloud.google.com/go/automl v1.7.0/go.mod h1:RL9MYCCsJEOmt0Wf3z9uzG0a7adTT1fe+aObgSpkCt8= +cloud.google.com/go/automl v1.8.0/go.mod h1:xWx7G/aPEe/NP+qzYXktoBSDfjO+vnKMGgsApGJJquM= +cloud.google.com/go/automl v1.12.0/go.mod h1:tWDcHDp86aMIuHmyvjuKeeHEGq76lD7ZqfGLN6B0NuU= +cloud.google.com/go/baremetalsolution v0.3.0/go.mod h1:XOrocE+pvK1xFfleEnShBlNAXf+j5blPPxrhjKgnIFc= +cloud.google.com/go/baremetalsolution v0.4.0/go.mod h1:BymplhAadOO/eBa7KewQ0Ppg4A4Wplbn+PsFKRLo0uI= +cloud.google.com/go/baremetalsolution v0.5.0/go.mod h1:dXGxEkmR9BMwxhzBhV0AioD0ULBmuLZI8CdwalUxuss= +cloud.google.com/go/batch v0.3.0/go.mod h1:TR18ZoAekj1GuirsUsR1ZTKN3FC/4UDnScjT8NXImFE= +cloud.google.com/go/batch v0.4.0/go.mod h1:WZkHnP43R/QCGQsZ+0JyG4i79ranE2u8xvjq/9+STPE= +cloud.google.com/go/batch v0.7.0/go.mod h1:vLZN95s6teRUqRQ4s3RLDsH8PvboqBK+rn1oevL159g= +cloud.google.com/go/beyondcorp v0.2.0/go.mod h1:TB7Bd+EEtcw9PCPQhCJtJGjk/7TC6ckmnSFS+xwTfm4= +cloud.google.com/go/beyondcorp v0.3.0/go.mod h1:E5U5lcrcXMsCuoDNyGrpyTm/hn7ne941Jz2vmksAxW8= +cloud.google.com/go/beyondcorp v0.4.0/go.mod h1:3ApA0mbhHx6YImmuubf5pyW8srKnCEPON32/5hj+RmM= +cloud.google.com/go/beyondcorp v0.5.0/go.mod h1:uFqj9X+dSfrheVp7ssLTaRHd2EHqSL4QZmH4e8WXGGU= cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/bigquery v1.42.0/go.mod h1:8dRTJxhtG+vwBKzE5OseQn/hiydoQN3EedCaOdYmxRA= +cloud.google.com/go/bigquery v1.43.0/go.mod h1:ZMQcXHsl+xmU1z36G2jNGZmKp9zNY5BUua5wDgmNCfw= +cloud.google.com/go/bigquery v1.44.0/go.mod h1:0Y33VqXTEsbamHJvJHdFmtqHvMIY28aK1+dFsvaChGc= +cloud.google.com/go/bigquery v1.47.0/go.mod h1:sA9XOgy0A8vQK9+MWhEQTY6Tix87M/ZurWFIxmF9I/E= +cloud.google.com/go/bigquery v1.48.0/go.mod h1:QAwSz+ipNgfL5jxiaK7weyOhzdoAy1zFm0Nf1fysJac= +cloud.google.com/go/bigquery v1.49.0/go.mod h1:Sv8hMmTFFYBlt/ftw2uN6dFdQPzBlREY9yBh7Oy7/4Q= +cloud.google.com/go/bigquery v1.50.0/go.mod h1:YrleYEh2pSEbgTBZYMJ5SuSr0ML3ypjRB1zgf7pvQLU= +cloud.google.com/go/billing v1.4.0/go.mod h1:g9IdKBEFlItS8bTtlrZdVLWSSdSyFUZKXNS02zKMOZY= +cloud.google.com/go/billing v1.5.0/go.mod h1:mztb1tBc3QekhjSgmpf/CV4LzWXLzCArwpLmP2Gm88s= +cloud.google.com/go/billing v1.6.0/go.mod h1:WoXzguj+BeHXPbKfNWkqVtDdzORazmCjraY+vrxcyvI= +cloud.google.com/go/billing v1.7.0/go.mod h1:q457N3Hbj9lYwwRbnlD7vUpyjq6u5U1RAOArInEiD5Y= +cloud.google.com/go/billing v1.12.0/go.mod h1:yKrZio/eu+okO/2McZEbch17O5CB5NpZhhXG6Z766ss= +cloud.google.com/go/billing v1.13.0/go.mod h1:7kB2W9Xf98hP9Sr12KfECgfGclsH3CQR0R08tnRlRbc= +cloud.google.com/go/binaryauthorization v1.1.0/go.mod h1:xwnoWu3Y84jbuHa0zd526MJYmtnVXn0syOjaJgy4+dM= +cloud.google.com/go/binaryauthorization v1.2.0/go.mod h1:86WKkJHtRcv5ViNABtYMhhNWRrD1Vpi//uKEy7aYEfI= +cloud.google.com/go/binaryauthorization v1.3.0/go.mod h1:lRZbKgjDIIQvzYQS1p99A7/U1JqvqeZg0wiI5tp6tg0= +cloud.google.com/go/binaryauthorization v1.4.0/go.mod h1:tsSPQrBd77VLplV70GUhBf/Zm3FsKmgSqgm4UmiDItk= +cloud.google.com/go/binaryauthorization v1.5.0/go.mod h1:OSe4OU1nN/VswXKRBmciKpo9LulY41gch5c68htf3/Q= +cloud.google.com/go/certificatemanager v1.3.0/go.mod h1:n6twGDvcUBFu9uBgt4eYvvf3sQ6My8jADcOVwHmzadg= +cloud.google.com/go/certificatemanager v1.4.0/go.mod h1:vowpercVFyqs8ABSmrdV+GiFf2H/ch3KyudYQEMM590= +cloud.google.com/go/certificatemanager v1.6.0/go.mod h1:3Hh64rCKjRAX8dXgRAyOcY5vQ/fE1sh8o+Mdd6KPgY8= +cloud.google.com/go/channel v1.8.0/go.mod h1:W5SwCXDJsq/rg3tn3oG0LOxpAo6IMxNa09ngphpSlnk= +cloud.google.com/go/channel v1.9.0/go.mod h1:jcu05W0my9Vx4mt3/rEHpfxc9eKi9XwsdDL8yBMbKUk= +cloud.google.com/go/channel v1.11.0/go.mod h1:IdtI0uWGqhEeatSB62VOoJ8FSUhJ9/+iGkJVqp74CGE= +cloud.google.com/go/channel v1.12.0/go.mod h1:VkxCGKASi4Cq7TbXxlaBezonAYpp1GCnKMY6tnMQnLU= +cloud.google.com/go/cloudbuild v1.3.0/go.mod h1:WequR4ULxlqvMsjDEEEFnOG5ZSRSgWOywXYDb1vPE6U= +cloud.google.com/go/cloudbuild v1.4.0/go.mod h1:5Qwa40LHiOXmz3386FrjrYM93rM/hdRr7b53sySrTqA= +cloud.google.com/go/cloudbuild v1.6.0/go.mod h1:UIbc/w9QCbH12xX+ezUsgblrWv+Cv4Tw83GiSMHOn9M= +cloud.google.com/go/cloudbuild v1.7.0/go.mod h1:zb5tWh2XI6lR9zQmsm1VRA+7OCuve5d8S+zJUul8KTg= +cloud.google.com/go/cloudbuild v1.9.0/go.mod h1:qK1d7s4QlO0VwfYn5YuClDGg2hfmLZEb4wQGAbIgL1s= +cloud.google.com/go/clouddms v1.3.0/go.mod h1:oK6XsCDdW4Ib3jCCBugx+gVjevp2TMXFtgxvPSee3OM= +cloud.google.com/go/clouddms v1.4.0/go.mod h1:Eh7sUGCC+aKry14O1NRljhjyrr0NFC0G2cjwX0cByRk= +cloud.google.com/go/clouddms v1.5.0/go.mod h1:QSxQnhikCLUw13iAbffF2CZxAER3xDGNHjsTAkQJcQA= +cloud.google.com/go/cloudtasks v1.5.0/go.mod h1:fD92REy1x5woxkKEkLdvavGnPJGEn8Uic9nWuLzqCpY= +cloud.google.com/go/cloudtasks v1.6.0/go.mod h1:C6Io+sxuke9/KNRkbQpihnW93SWDU3uXt92nu85HkYI= +cloud.google.com/go/cloudtasks v1.7.0/go.mod h1:ImsfdYWwlWNJbdgPIIGJWC+gemEGTBK/SunNQQNCAb4= +cloud.google.com/go/cloudtasks v1.8.0/go.mod h1:gQXUIwCSOI4yPVK7DgTVFiiP0ZW/eQkydWzwVMdHxrI= +cloud.google.com/go/cloudtasks v1.9.0/go.mod h1:w+EyLsVkLWHcOaqNEyvcKAsWp9p29dL6uL9Nst1cI7Y= +cloud.google.com/go/cloudtasks v1.10.0/go.mod h1:NDSoTLkZ3+vExFEWu2UJV1arUyzVDAiZtdWcsUyNwBs= +cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow= +cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM= +cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M= +cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s= +cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= +cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= +cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU= +cloud.google.com/go/compute v1.12.0/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.12.1/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.13.0/go.mod h1:5aPTS0cUNMIc1CE546K+Th6weJUNQErARyZtRXDJ8GE= +cloud.google.com/go/compute v1.14.0/go.mod h1:YfLtxrj9sU4Yxv+sXzZkyPjEyPBZfXHUvjxega5vAdo= +cloud.google.com/go/compute v1.15.1/go.mod h1:bjjoF/NtFUrkD/urWfdHaKuOPDR5nWIs63rR+SXhcpA= +cloud.google.com/go/compute v1.18.0/go.mod h1:1X7yHxec2Ga+Ss6jPyjxRxpu2uu7PLgsOVXvgU0yacs= +cloud.google.com/go/compute v1.19.0/go.mod h1:rikpw2y+UMidAe9tISo04EHNOIf42RLYF/q8Bs93scU= +cloud.google.com/go/compute v1.19.1/go.mod h1:6ylj3a05WF8leseCdIf77NK0g1ey+nj5IKd5/kvShxE= +cloud.google.com/go/compute/metadata v0.1.0/go.mod h1:Z1VN+bulIf6bt4P/C37K4DyZYZEXYonfTBHHFPO/4UU= +cloud.google.com/go/compute/metadata v0.2.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= +cloud.google.com/go/compute/metadata v0.2.1/go.mod h1:jgHgmJd2RKBGzXqF5LR2EZMGxBkeanZ9wwa75XHJgOM= +cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= +cloud.google.com/go/contactcenterinsights v1.3.0/go.mod h1:Eu2oemoePuEFc/xKFPjbTuPSj0fYJcPls9TFlPNnHHY= +cloud.google.com/go/contactcenterinsights v1.4.0/go.mod h1:L2YzkGbPsv+vMQMCADxJoT9YiTTnSEd6fEvCeHTYVck= +cloud.google.com/go/contactcenterinsights v1.6.0/go.mod h1:IIDlT6CLcDoyv79kDv8iWxMSTZhLxSCofVV5W6YFM/w= +cloud.google.com/go/container v1.6.0/go.mod h1:Xazp7GjJSeUYo688S+6J5V+n/t+G5sKBTFkKNudGRxg= +cloud.google.com/go/container v1.7.0/go.mod h1:Dp5AHtmothHGX3DwwIHPgq45Y8KmNsgN3amoYfxVkLo= +cloud.google.com/go/container v1.13.1/go.mod h1:6wgbMPeQRw9rSnKBCAJXnds3Pzj03C4JHamr8asWKy4= +cloud.google.com/go/container v1.14.0/go.mod h1:3AoJMPhHfLDxLvrlVWaK57IXzaPnLaZq63WX59aQBfM= +cloud.google.com/go/container v1.15.0/go.mod h1:ft+9S0WGjAyjDggg5S06DXj+fHJICWg8L7isCQe9pQA= +cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I= +cloud.google.com/go/containeranalysis v0.6.0/go.mod h1:HEJoiEIu+lEXM+k7+qLCci0h33lX3ZqoYFdmPcoO7s4= +cloud.google.com/go/containeranalysis v0.7.0/go.mod h1:9aUL+/vZ55P2CXfuZjS4UjQ9AgXoSw8Ts6lemfmxBxI= +cloud.google.com/go/containeranalysis v0.9.0/go.mod h1:orbOANbwk5Ejoom+s+DUCTTJ7IBdBQJDcSylAx/on9s= +cloud.google.com/go/datacatalog v1.3.0/go.mod h1:g9svFY6tuR+j+hrTw3J2dNcmI0dzmSiyOzm8kpLq0a0= +cloud.google.com/go/datacatalog v1.5.0/go.mod h1:M7GPLNQeLfWqeIm3iuiruhPzkt65+Bx8dAKvScX8jvs= +cloud.google.com/go/datacatalog v1.6.0/go.mod h1:+aEyF8JKg+uXcIdAmmaMUmZ3q1b/lKLtXCmXdnc0lbc= +cloud.google.com/go/datacatalog v1.7.0/go.mod h1:9mEl4AuDYWw81UGc41HonIHH7/sn52H0/tc8f8ZbZIE= +cloud.google.com/go/datacatalog v1.8.0/go.mod h1:KYuoVOv9BM8EYz/4eMFxrr4DUKhGIOXxZoKYF5wdISM= +cloud.google.com/go/datacatalog v1.8.1/go.mod h1:RJ58z4rMp3gvETA465Vg+ag8BGgBdnRPEMMSTr5Uv+M= +cloud.google.com/go/datacatalog v1.12.0/go.mod h1:CWae8rFkfp6LzLumKOnmVh4+Zle4A3NXLzVJ1d1mRm0= +cloud.google.com/go/datacatalog v1.13.0/go.mod h1:E4Rj9a5ZtAxcQJlEBTLgMTphfP11/lNaAshpoBgemX8= +cloud.google.com/go/dataflow v0.6.0/go.mod h1:9QwV89cGoxjjSR9/r7eFDqqjtvbKxAK2BaYU6PVk9UM= +cloud.google.com/go/dataflow v0.7.0/go.mod h1:PX526vb4ijFMesO1o202EaUmouZKBpjHsTlCtB4parQ= +cloud.google.com/go/dataflow v0.8.0/go.mod h1:Rcf5YgTKPtQyYz8bLYhFoIV/vP39eL7fWNcSOyFfLJE= +cloud.google.com/go/dataform v0.3.0/go.mod h1:cj8uNliRlHpa6L3yVhDOBrUXH+BPAO1+KFMQQNSThKo= +cloud.google.com/go/dataform v0.4.0/go.mod h1:fwV6Y4Ty2yIFL89huYlEkwUPtS7YZinZbzzj5S9FzCE= +cloud.google.com/go/dataform v0.5.0/go.mod h1:GFUYRe8IBa2hcomWplodVmUx/iTL0FrsauObOM3Ipr0= +cloud.google.com/go/dataform v0.6.0/go.mod h1:QPflImQy33e29VuapFdf19oPbE4aYTJxr31OAPV+ulA= +cloud.google.com/go/dataform v0.7.0/go.mod h1:7NulqnVozfHvWUBpMDfKMUESr+85aJsC/2O0o3jWPDE= +cloud.google.com/go/datafusion v1.4.0/go.mod h1:1Zb6VN+W6ALo85cXnM1IKiPw+yQMKMhB9TsTSRDo/38= +cloud.google.com/go/datafusion v1.5.0/go.mod h1:Kz+l1FGHB0J+4XF2fud96WMmRiq/wj8N9u007vyXZ2w= +cloud.google.com/go/datafusion v1.6.0/go.mod h1:WBsMF8F1RhSXvVM8rCV3AeyWVxcC2xY6vith3iw3S+8= +cloud.google.com/go/datalabeling v0.5.0/go.mod h1:TGcJ0G2NzcsXSE/97yWjIZO0bXj0KbVlINXMG9ud42I= +cloud.google.com/go/datalabeling v0.6.0/go.mod h1:WqdISuk/+WIGeMkpw/1q7bK/tFEZxsrFJOJdY2bXvTQ= +cloud.google.com/go/datalabeling v0.7.0/go.mod h1:WPQb1y08RJbmpM3ww0CSUAGweL0SxByuW2E+FU+wXcM= +cloud.google.com/go/dataplex v1.3.0/go.mod h1:hQuRtDg+fCiFgC8j0zV222HvzFQdRd+SVX8gdmFcZzA= +cloud.google.com/go/dataplex v1.4.0/go.mod h1:X51GfLXEMVJ6UN47ESVqvlsRplbLhcsAt0kZCCKsU0A= +cloud.google.com/go/dataplex v1.5.2/go.mod h1:cVMgQHsmfRoI5KFYq4JtIBEUbYwc3c7tXmIDhRmNNVQ= +cloud.google.com/go/dataplex v1.6.0/go.mod h1:bMsomC/aEJOSpHXdFKFGQ1b0TDPIeL28nJObeO1ppRs= +cloud.google.com/go/dataproc v1.7.0/go.mod h1:CKAlMjII9H90RXaMpSxQ8EU6dQx6iAYNPcYPOkSbi8s= +cloud.google.com/go/dataproc v1.8.0/go.mod h1:5OW+zNAH0pMpw14JVrPONsxMQYMBqJuzORhIBfBn9uI= +cloud.google.com/go/dataproc v1.12.0/go.mod h1:zrF3aX0uV3ikkMz6z4uBbIKyhRITnxvr4i3IjKsKrw4= +cloud.google.com/go/dataqna v0.5.0/go.mod h1:90Hyk596ft3zUQ8NkFfvICSIfHFh1Bc7C4cK3vbhkeo= +cloud.google.com/go/dataqna v0.6.0/go.mod h1:1lqNpM7rqNLVgWBJyk5NF6Uen2PHym0jtVJonplVsDA= +cloud.google.com/go/dataqna v0.7.0/go.mod h1:Lx9OcIIeqCrw1a6KdO3/5KMP1wAmTc0slZWwP12Qq3c= cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/datastore v1.10.0/go.mod h1:PC5UzAmDEkAmkfaknstTYbNpgE49HAgW2J1gcgUfmdM= +cloud.google.com/go/datastore v1.11.0/go.mod h1:TvGxBIHCS50u8jzG+AW/ppf87v1of8nwzFNgEZU1D3c= +cloud.google.com/go/datastream v1.2.0/go.mod h1:i/uTP8/fZwgATHS/XFu0TcNUhuA0twZxxQ3EyCUQMwo= +cloud.google.com/go/datastream v1.3.0/go.mod h1:cqlOX8xlyYF/uxhiKn6Hbv6WjwPPuI9W2M9SAXwaLLQ= +cloud.google.com/go/datastream v1.4.0/go.mod h1:h9dpzScPhDTs5noEMQVWP8Wx8AFBRyS0s8KWPx/9r0g= +cloud.google.com/go/datastream v1.5.0/go.mod h1:6TZMMNPwjUqZHBKPQ1wwXpb0d5VDVPl2/XoS5yi88q4= +cloud.google.com/go/datastream v1.6.0/go.mod h1:6LQSuswqLa7S4rPAOZFVjHIG3wJIjZcZrw8JDEDJuIs= +cloud.google.com/go/datastream v1.7.0/go.mod h1:uxVRMm2elUSPuh65IbZpzJNMbuzkcvu5CjMqVIUHrww= +cloud.google.com/go/deploy v1.4.0/go.mod h1:5Xghikd4VrmMLNaF6FiRFDlHb59VM59YoDQnOUdsH/c= +cloud.google.com/go/deploy v1.5.0/go.mod h1:ffgdD0B89tToyW/U/D2eL0jN2+IEV/3EMuXHA0l4r+s= +cloud.google.com/go/deploy v1.6.0/go.mod h1:f9PTHehG/DjCom3QH0cntOVRm93uGBDt2vKzAPwpXQI= +cloud.google.com/go/deploy v1.8.0/go.mod h1:z3myEJnA/2wnB4sgjqdMfgxCA0EqC3RBTNcVPs93mtQ= +cloud.google.com/go/dialogflow v1.15.0/go.mod h1:HbHDWs33WOGJgn6rfzBW1Kv807BE3O1+xGbn59zZWI4= +cloud.google.com/go/dialogflow v1.16.1/go.mod h1:po6LlzGfK+smoSmTBnbkIZY2w8ffjz/RcGSS+sh1el0= +cloud.google.com/go/dialogflow v1.17.0/go.mod h1:YNP09C/kXA1aZdBgC/VtXX74G/TKn7XVCcVumTflA+8= +cloud.google.com/go/dialogflow v1.18.0/go.mod h1:trO7Zu5YdyEuR+BhSNOqJezyFQ3aUzz0njv7sMx/iek= +cloud.google.com/go/dialogflow v1.19.0/go.mod h1:JVmlG1TwykZDtxtTXujec4tQ+D8SBFMoosgy+6Gn0s0= +cloud.google.com/go/dialogflow v1.29.0/go.mod h1:b+2bzMe+k1s9V+F2jbJwpHPzrnIyHihAdRFMtn2WXuM= +cloud.google.com/go/dialogflow v1.31.0/go.mod h1:cuoUccuL1Z+HADhyIA7dci3N5zUssgpBJmCzI6fNRB4= +cloud.google.com/go/dialogflow v1.32.0/go.mod h1:jG9TRJl8CKrDhMEcvfcfFkkpp8ZhgPz3sBGmAUYJ2qE= +cloud.google.com/go/dlp v1.6.0/go.mod h1:9eyB2xIhpU0sVwUixfBubDoRwP+GjeUoxxeueZmqvmM= +cloud.google.com/go/dlp v1.7.0/go.mod h1:68ak9vCiMBjbasxeVD17hVPxDEck+ExiHavX8kiHG+Q= +cloud.google.com/go/dlp v1.9.0/go.mod h1:qdgmqgTyReTz5/YNSSuueR8pl7hO0o9bQ39ZhtgkWp4= +cloud.google.com/go/documentai v1.7.0/go.mod h1:lJvftZB5NRiFSX4moiye1SMxHx0Bc3x1+p9e/RfXYiU= +cloud.google.com/go/documentai v1.8.0/go.mod h1:xGHNEB7CtsnySCNrCFdCyyMz44RhFEEX2Q7UD0c5IhU= +cloud.google.com/go/documentai v1.9.0/go.mod h1:FS5485S8R00U10GhgBC0aNGrJxBP8ZVpEeJ7PQDZd6k= +cloud.google.com/go/documentai v1.10.0/go.mod h1:vod47hKQIPeCfN2QS/jULIvQTugbmdc0ZvxxfQY1bg4= +cloud.google.com/go/documentai v1.16.0/go.mod h1:o0o0DLTEZ+YnJZ+J4wNfTxmDVyrkzFvttBXXtYRMHkM= +cloud.google.com/go/documentai v1.18.0/go.mod h1:F6CK6iUH8J81FehpskRmhLq/3VlwQvb7TvwOceQ2tbs= +cloud.google.com/go/domains v0.6.0/go.mod h1:T9Rz3GasrpYk6mEGHh4rymIhjlnIuB4ofT1wTxDeT4Y= +cloud.google.com/go/domains v0.7.0/go.mod h1:PtZeqS1xjnXuRPKE/88Iru/LdfoRyEHYA9nFQf4UKpg= +cloud.google.com/go/domains v0.8.0/go.mod h1:M9i3MMDzGFXsydri9/vW+EWz9sWb4I6WyHqdlAk0idE= +cloud.google.com/go/edgecontainer v0.1.0/go.mod h1:WgkZ9tp10bFxqO8BLPqv2LlfmQF1X8lZqwW4r1BTajk= +cloud.google.com/go/edgecontainer v0.2.0/go.mod h1:RTmLijy+lGpQ7BXuTDa4C4ssxyXT34NIuHIgKuP4s5w= +cloud.google.com/go/edgecontainer v0.3.0/go.mod h1:FLDpP4nykgwwIfcLt6zInhprzw0lEi2P1fjO6Ie0qbc= +cloud.google.com/go/edgecontainer v1.0.0/go.mod h1:cttArqZpBB2q58W/upSG++ooo6EsblxDIolxa3jSjbY= +cloud.google.com/go/errorreporting v0.3.0/go.mod h1:xsP2yaAp+OAW4OIm60An2bbLpqIhKXdWR/tawvl7QzU= +cloud.google.com/go/essentialcontacts v1.3.0/go.mod h1:r+OnHa5jfj90qIfZDO/VztSFqbQan7HV75p8sA+mdGI= +cloud.google.com/go/essentialcontacts v1.4.0/go.mod h1:8tRldvHYsmnBCHdFpvU+GL75oWiBKl80BiqlFh9tp+8= +cloud.google.com/go/essentialcontacts v1.5.0/go.mod h1:ay29Z4zODTuwliK7SnX8E86aUF2CTzdNtvv42niCX0M= +cloud.google.com/go/eventarc v1.7.0/go.mod h1:6ctpF3zTnaQCxUjHUdcfgcA1A2T309+omHZth7gDfmc= +cloud.google.com/go/eventarc v1.8.0/go.mod h1:imbzxkyAU4ubfsaKYdQg04WS1NvncblHEup4kvF+4gw= +cloud.google.com/go/eventarc v1.10.0/go.mod h1:u3R35tmZ9HvswGRBnF48IlYgYeBcPUCjkr4BTdem2Kw= +cloud.google.com/go/eventarc v1.11.0/go.mod h1:PyUjsUKPWoRBCHeOxZd/lbOOjahV41icXyUY5kSTvVY= +cloud.google.com/go/filestore v1.3.0/go.mod h1:+qbvHGvXU1HaKX2nD0WEPo92TP/8AQuCVEBXNY9z0+w= +cloud.google.com/go/filestore v1.4.0/go.mod h1:PaG5oDfo9r224f8OYXURtAsY+Fbyq/bLYoINEK8XQAI= +cloud.google.com/go/filestore v1.5.0/go.mod h1:FqBXDWBp4YLHqRnVGveOkHDf8svj9r5+mUDLupOWEDs= +cloud.google.com/go/filestore v1.6.0/go.mod h1:di5unNuss/qfZTw2U9nhFqo8/ZDSc466dre85Kydllg= +cloud.google.com/go/firestore v1.9.0/go.mod h1:HMkjKHNTtRyZNiMzu7YAsLr9K3X2udY2AMwDaMEQiiE= +cloud.google.com/go/functions v1.6.0/go.mod h1:3H1UA3qiIPRWD7PeZKLvHZ9SaQhR26XIJcC0A5GbvAk= +cloud.google.com/go/functions v1.7.0/go.mod h1:+d+QBcWM+RsrgZfV9xo6KfA1GlzJfxcfZcRPEhDDfzg= +cloud.google.com/go/functions v1.8.0/go.mod h1:RTZ4/HsQjIqIYP9a9YPbU+QFoQsAlYgrwOXJWHn1POY= +cloud.google.com/go/functions v1.9.0/go.mod h1:Y+Dz8yGguzO3PpIjhLTbnqV1CWmgQ5UwtlpzoyquQ08= +cloud.google.com/go/functions v1.10.0/go.mod h1:0D3hEOe3DbEvCXtYOZHQZmD+SzYsi1YbI7dGvHfldXw= +cloud.google.com/go/functions v1.12.0/go.mod h1:AXWGrF3e2C/5ehvwYo/GH6O5s09tOPksiKhz+hH8WkA= +cloud.google.com/go/functions v1.13.0/go.mod h1:EU4O007sQm6Ef/PwRsI8N2umygGqPBS/IZQKBQBcJ3c= +cloud.google.com/go/gaming v1.5.0/go.mod h1:ol7rGcxP/qHTRQE/RO4bxkXq+Fix0j6D4LFPzYTIrDM= +cloud.google.com/go/gaming v1.6.0/go.mod h1:YMU1GEvA39Qt3zWGyAVA9bpYz/yAhTvaQ1t2sK4KPUA= +cloud.google.com/go/gaming v1.7.0/go.mod h1:LrB8U7MHdGgFG851iHAfqUdLcKBdQ55hzXy9xBJz0+w= +cloud.google.com/go/gaming v1.8.0/go.mod h1:xAqjS8b7jAVW0KFYeRUxngo9My3f33kFmua++Pi+ggM= +cloud.google.com/go/gaming v1.9.0/go.mod h1:Fc7kEmCObylSWLO334NcO+O9QMDyz+TKC4v1D7X+Bc0= +cloud.google.com/go/gkebackup v0.2.0/go.mod h1:XKvv/4LfG829/B8B7xRkk8zRrOEbKtEam6yNfuQNH60= +cloud.google.com/go/gkebackup v0.3.0/go.mod h1:n/E671i1aOQvUxT541aTkCwExO/bTer2HDlj4TsBRAo= +cloud.google.com/go/gkebackup v0.4.0/go.mod h1:byAyBGUwYGEEww7xsbnUTBHIYcOPy/PgUWUtOeRm9Vg= +cloud.google.com/go/gkeconnect v0.5.0/go.mod h1:c5lsNAg5EwAy7fkqX/+goqFsU1Da/jQFqArp+wGNr/o= +cloud.google.com/go/gkeconnect v0.6.0/go.mod h1:Mln67KyU/sHJEBY8kFZ0xTeyPtzbq9StAVvEULYK16A= +cloud.google.com/go/gkeconnect v0.7.0/go.mod h1:SNfmVqPkaEi3bF/B3CNZOAYPYdg7sU+obZ+QTky2Myw= +cloud.google.com/go/gkehub v0.9.0/go.mod h1:WYHN6WG8w9bXU0hqNxt8rm5uxnk8IH+lPY9J2TV7BK0= +cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y977wO+hBH0= +cloud.google.com/go/gkehub v0.11.0/go.mod h1:JOWHlmN+GHyIbuWQPl47/C2RFhnFKH38jH9Ascu3n0E= +cloud.google.com/go/gkehub v0.12.0/go.mod h1:djiIwwzTTBrF5NaXCGv3mf7klpEMcST17VBTVVDcuaw= +cloud.google.com/go/gkemulticloud v0.3.0/go.mod h1:7orzy7O0S+5kq95e4Hpn7RysVA7dPs8W/GgfUtsPbrA= +cloud.google.com/go/gkemulticloud v0.4.0/go.mod h1:E9gxVBnseLWCk24ch+P9+B2CoDFJZTyIgLKSalC7tuI= +cloud.google.com/go/gkemulticloud v0.5.0/go.mod h1:W0JDkiyi3Tqh0TJr//y19wyb1yf8llHVto2Htf2Ja3Y= +cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc= +cloud.google.com/go/gsuiteaddons v1.3.0/go.mod h1:EUNK/J1lZEZO8yPtykKxLXI6JSVN2rg9bN8SXOa0bgM= +cloud.google.com/go/gsuiteaddons v1.4.0/go.mod h1:rZK5I8hht7u7HxFQcFei0+AtfS9uSushomRlg+3ua1o= +cloud.google.com/go/gsuiteaddons v1.5.0/go.mod h1:TFCClYLd64Eaa12sFVmUyG62tk4mdIsI7pAnSXRkcFo= +cloud.google.com/go/iam v0.1.0/go.mod h1:vcUNEa0pEm0qRVpmWepWaFMIAI8/hjB9mO8rNCJtF6c= +cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= +cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc= +cloud.google.com/go/iam v0.6.0/go.mod h1:+1AH33ueBne5MzYccyMHtEKqLE4/kJOibtffMHDMFMc= +cloud.google.com/go/iam v0.7.0/go.mod h1:H5Br8wRaDGNc8XP3keLc4unfUUZeyH3Sfl9XpQEYOeg= +cloud.google.com/go/iam v0.8.0/go.mod h1:lga0/y3iH6CX7sYqypWJ33hf7kkfXJag67naqGESjkE= +cloud.google.com/go/iam v0.11.0/go.mod h1:9PiLDanza5D+oWFZiH1uG+RnRCfEGKoyl6yo4cgWZGY= +cloud.google.com/go/iam v0.12.0/go.mod h1:knyHGviacl11zrtZUoDuYpDgLjvr28sLQaG0YB2GYAY= +cloud.google.com/go/iam v0.13.0/go.mod h1:ljOg+rcNfzZ5d6f1nAUJ8ZIxOaZUVoS14bKCtaLZ/D0= +cloud.google.com/go/iap v1.4.0/go.mod h1:RGFwRJdihTINIe4wZ2iCP0zF/qu18ZwyKxrhMhygBEc= +cloud.google.com/go/iap v1.5.0/go.mod h1:UH/CGgKd4KyohZL5Pt0jSKE4m3FR51qg6FKQ/z/Ix9A= +cloud.google.com/go/iap v1.6.0/go.mod h1:NSuvI9C/j7UdjGjIde7t7HBz+QTwBcapPE07+sSRcLk= +cloud.google.com/go/iap v1.7.0/go.mod h1:beqQx56T9O1G1yNPph+spKpNibDlYIiIixiqsQXxLIo= +cloud.google.com/go/iap v1.7.1/go.mod h1:WapEwPc7ZxGt2jFGB/C/bm+hP0Y6NXzOYGjpPnmMS74= +cloud.google.com/go/ids v1.1.0/go.mod h1:WIuwCaYVOzHIj2OhN9HAwvW+DBdmUAdcWlFxRl+KubM= +cloud.google.com/go/ids v1.2.0/go.mod h1:5WXvp4n25S0rA/mQWAg1YEEBBq6/s+7ml1RDCW1IrcY= +cloud.google.com/go/ids v1.3.0/go.mod h1:JBdTYwANikFKaDP6LtW5JAi4gubs57SVNQjemdt6xV4= +cloud.google.com/go/iot v1.3.0/go.mod h1:r7RGh2B61+B8oz0AGE+J72AhA0G7tdXItODWsaA2oLs= +cloud.google.com/go/iot v1.4.0/go.mod h1:dIDxPOn0UvNDUMD8Ger7FIaTuvMkj+aGk94RPP0iV+g= +cloud.google.com/go/iot v1.5.0/go.mod h1:mpz5259PDl3XJthEmh9+ap0affn/MqNSP4My77Qql9o= +cloud.google.com/go/iot v1.6.0/go.mod h1:IqdAsmE2cTYYNO1Fvjfzo9po179rAtJeVGUvkLN3rLE= +cloud.google.com/go/kms v1.4.0/go.mod h1:fajBHndQ+6ubNw6Ss2sSd+SWvjL26RNo/dr7uxsnnOA= +cloud.google.com/go/kms v1.5.0/go.mod h1:QJS2YY0eJGBg3mnDfuaCyLauWwBJiHRboYxJ++1xJNg= +cloud.google.com/go/kms v1.6.0/go.mod h1:Jjy850yySiasBUDi6KFUwUv2n1+o7QZFyuUJg6OgjA0= +cloud.google.com/go/kms v1.8.0/go.mod h1:4xFEhYFqvW+4VMELtZyxomGSYtSQKzM178ylFW4jMAg= +cloud.google.com/go/kms v1.9.0/go.mod h1:qb1tPTgfF9RQP8e1wq4cLFErVuTJv7UsSC915J8dh3w= +cloud.google.com/go/kms v1.10.0/go.mod h1:ng3KTUtQQU9bPX3+QGLsflZIHlkbn8amFAMY63m8d24= +cloud.google.com/go/kms v1.10.1/go.mod h1:rIWk/TryCkR59GMC3YtHtXeLzd634lBbKenvyySAyYI= +cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic= +cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI= +cloud.google.com/go/language v1.7.0/go.mod h1:DJ6dYN/W+SQOjF8e1hLQXMF21AkH2w9wiPzPCJa2MIE= +cloud.google.com/go/language v1.8.0/go.mod h1:qYPVHf7SPoNNiCL2Dr0FfEFNil1qi3pQEyygwpgVKB8= +cloud.google.com/go/language v1.9.0/go.mod h1:Ns15WooPM5Ad/5no/0n81yUetis74g3zrbeJBE+ptUY= +cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8= +cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08= +cloud.google.com/go/lifesciences v0.8.0/go.mod h1:lFxiEOMqII6XggGbOnKiyZ7IBwoIqA84ClvoezaA/bo= +cloud.google.com/go/logging v1.6.1/go.mod h1:5ZO0mHHbvm8gEmeEUHrmDlTDSu5imF6MUP9OfilNXBw= +cloud.google.com/go/logging v1.7.0/go.mod h1:3xjP2CjkM3ZkO73aj4ASA5wRPGGCRrPIAeNqVNkzY8M= +cloud.google.com/go/longrunning v0.1.1/go.mod h1:UUFxuDWkv22EuY93jjmDMFT5GPQKeFVJBIF6QlTqdsE= +cloud.google.com/go/longrunning v0.3.0/go.mod h1:qth9Y41RRSUE69rDcOn6DdK3HfQfsUI0YSmW3iIlLJc= +cloud.google.com/go/longrunning v0.4.1/go.mod h1:4iWDqhBZ70CvZ6BfETbvam3T8FMvLK+eFj0E6AaRQTo= +cloud.google.com/go/managedidentities v1.3.0/go.mod h1:UzlW3cBOiPrzucO5qWkNkh0w33KFtBJU281hacNvsdE= +cloud.google.com/go/managedidentities v1.4.0/go.mod h1:NWSBYbEMgqmbZsLIyKvxrYbtqOsxY1ZrGM+9RgDqInM= +cloud.google.com/go/managedidentities v1.5.0/go.mod h1:+dWcZ0JlUmpuxpIDfyP5pP5y0bLdRwOS4Lp7gMni/LA= +cloud.google.com/go/maps v0.1.0/go.mod h1:BQM97WGyfw9FWEmQMpZ5T6cpovXXSd1cGmFma94eubI= +cloud.google.com/go/maps v0.6.0/go.mod h1:o6DAMMfb+aINHz/p/jbcY+mYeXBoZoxTfdSQ8VAJaCw= +cloud.google.com/go/maps v0.7.0/go.mod h1:3GnvVl3cqeSvgMcpRlQidXsPYuDGQ8naBis7MVzpXsY= +cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4= +cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w= +cloud.google.com/go/mediatranslation v0.7.0/go.mod h1:LCnB/gZr90ONOIQLgSXagp8XUW1ODs2UmUMvcgMfI2I= +cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE= +cloud.google.com/go/memcache v1.5.0/go.mod h1:dk3fCK7dVo0cUU2c36jKb4VqKPS22BTkf81Xq617aWM= +cloud.google.com/go/memcache v1.6.0/go.mod h1:XS5xB0eQZdHtTuTF9Hf8eJkKtR3pVRCcvJwtm68T3rA= +cloud.google.com/go/memcache v1.7.0/go.mod h1:ywMKfjWhNtkQTxrWxCkCFkoPjLHPW6A7WOTVI8xy3LY= +cloud.google.com/go/memcache v1.9.0/go.mod h1:8oEyzXCu+zo9RzlEaEjHl4KkgjlNDaXbCQeQWlzNFJM= +cloud.google.com/go/metastore v1.5.0/go.mod h1:2ZNrDcQwghfdtCwJ33nM0+GrBGlVuh8rakL3vdPY3XY= +cloud.google.com/go/metastore v1.6.0/go.mod h1:6cyQTls8CWXzk45G55x57DVQ9gWg7RiH65+YgPsNh9s= +cloud.google.com/go/metastore v1.7.0/go.mod h1:s45D0B4IlsINu87/AsWiEVYbLaIMeUSoxlKKDqBGFS8= +cloud.google.com/go/metastore v1.8.0/go.mod h1:zHiMc4ZUpBiM7twCIFQmJ9JMEkDSyZS9U12uf7wHqSI= +cloud.google.com/go/metastore v1.10.0/go.mod h1:fPEnH3g4JJAk+gMRnrAnoqyv2lpUCqJPWOodSaf45Eo= +cloud.google.com/go/monitoring v1.7.0/go.mod h1:HpYse6kkGo//7p6sT0wsIC6IBDET0RhIsnmlA53dvEk= +cloud.google.com/go/monitoring v1.8.0/go.mod h1:E7PtoMJ1kQXWxPjB6mv2fhC5/15jInuulFdYYtlcvT4= +cloud.google.com/go/monitoring v1.12.0/go.mod h1:yx8Jj2fZNEkL/GYZyTLS4ZtZEZN8WtDEiEqG4kLK50w= +cloud.google.com/go/monitoring v1.13.0/go.mod h1:k2yMBAB1H9JT/QETjNkgdCGD9bPF712XiLTVr+cBrpw= +cloud.google.com/go/networkconnectivity v1.4.0/go.mod h1:nOl7YL8odKyAOtzNX73/M5/mGZgqqMeryi6UPZTk/rA= +cloud.google.com/go/networkconnectivity v1.5.0/go.mod h1:3GzqJx7uhtlM3kln0+x5wyFvuVH1pIBJjhCpjzSt75o= +cloud.google.com/go/networkconnectivity v1.6.0/go.mod h1:OJOoEXW+0LAxHh89nXd64uGG+FbQoeH8DtxCHVOMlaM= +cloud.google.com/go/networkconnectivity v1.7.0/go.mod h1:RMuSbkdbPwNMQjB5HBWD5MpTBnNm39iAVpC3TmsExt8= +cloud.google.com/go/networkconnectivity v1.10.0/go.mod h1:UP4O4sWXJG13AqrTdQCD9TnLGEbtNRqjuaaA7bNjF5E= +cloud.google.com/go/networkconnectivity v1.11.0/go.mod h1:iWmDD4QF16VCDLXUqvyspJjIEtBR/4zq5hwnY2X3scM= +cloud.google.com/go/networkmanagement v1.4.0/go.mod h1:Q9mdLLRn60AsOrPc8rs8iNV6OHXaGcDdsIQe1ohekq8= +cloud.google.com/go/networkmanagement v1.5.0/go.mod h1:ZnOeZ/evzUdUsnvRt792H0uYEnHQEMaz+REhhzJRcf4= +cloud.google.com/go/networkmanagement v1.6.0/go.mod h1:5pKPqyXjB/sgtvB5xqOemumoQNB7y95Q7S+4rjSOPYY= +cloud.google.com/go/networksecurity v0.5.0/go.mod h1:xS6fOCoqpVC5zx15Z/MqkfDwH4+m/61A3ODiDV1xmiQ= +cloud.google.com/go/networksecurity v0.6.0/go.mod h1:Q5fjhTr9WMI5mbpRYEbiexTzROf7ZbDzvzCrNl14nyU= +cloud.google.com/go/networksecurity v0.7.0/go.mod h1:mAnzoxx/8TBSyXEeESMy9OOYwo1v+gZ5eMRnsT5bC8k= +cloud.google.com/go/networksecurity v0.8.0/go.mod h1:B78DkqsxFG5zRSVuwYFRZ9Xz8IcQ5iECsNrPn74hKHU= +cloud.google.com/go/notebooks v1.2.0/go.mod h1:9+wtppMfVPUeJ8fIWPOq1UnATHISkGXGqTkxeieQ6UY= +cloud.google.com/go/notebooks v1.3.0/go.mod h1:bFR5lj07DtCPC7YAAJ//vHskFBxA5JzYlH68kXVdk34= +cloud.google.com/go/notebooks v1.4.0/go.mod h1:4QPMngcwmgb6uw7Po99B2xv5ufVoIQ7nOGDyL4P8AgA= +cloud.google.com/go/notebooks v1.5.0/go.mod h1:q8mwhnP9aR8Hpfnrc5iN5IBhrXUy8S2vuYs+kBJ/gu0= +cloud.google.com/go/notebooks v1.7.0/go.mod h1:PVlaDGfJgj1fl1S3dUwhFMXFgfYGhYQt2164xOMONmE= +cloud.google.com/go/notebooks v1.8.0/go.mod h1:Lq6dYKOYOWUCTvw5t2q1gp1lAp0zxAxRycayS0iJcqQ= +cloud.google.com/go/optimization v1.1.0/go.mod h1:5po+wfvX5AQlPznyVEZjGJTMr4+CAkJf2XSTQOOl9l4= +cloud.google.com/go/optimization v1.2.0/go.mod h1:Lr7SOHdRDENsh+WXVmQhQTrzdu9ybg0NecjHidBq6xs= +cloud.google.com/go/optimization v1.3.1/go.mod h1:IvUSefKiwd1a5p0RgHDbWCIbDFgKuEdB+fPPuP0IDLI= +cloud.google.com/go/orchestration v1.3.0/go.mod h1:Sj5tq/JpWiB//X/q3Ngwdl5K7B7Y0KZ7bfv0wL6fqVA= +cloud.google.com/go/orchestration v1.4.0/go.mod h1:6W5NLFWs2TlniBphAViZEVhrXRSMgUGDfW7vrWKvsBk= +cloud.google.com/go/orchestration v1.6.0/go.mod h1:M62Bevp7pkxStDfFfTuCOaXgaaqRAga1yKyoMtEoWPQ= +cloud.google.com/go/orgpolicy v1.4.0/go.mod h1:xrSLIV4RePWmP9P3tBl8S93lTmlAxjm06NSm2UTmKvE= +cloud.google.com/go/orgpolicy v1.5.0/go.mod h1:hZEc5q3wzwXJaKrsx5+Ewg0u1LxJ51nNFlext7Tanwc= +cloud.google.com/go/orgpolicy v1.10.0/go.mod h1:w1fo8b7rRqlXlIJbVhOMPrwVljyuW5mqssvBtU18ONc= +cloud.google.com/go/osconfig v1.7.0/go.mod h1:oVHeCeZELfJP7XLxcBGTMBvRO+1nQ5tFG9VQTmYS2Fs= +cloud.google.com/go/osconfig v1.8.0/go.mod h1:EQqZLu5w5XA7eKizepumcvWx+m8mJUhEwiPqWiZeEdg= +cloud.google.com/go/osconfig v1.9.0/go.mod h1:Yx+IeIZJ3bdWmzbQU4fxNl8xsZ4amB+dygAwFPlvnNo= +cloud.google.com/go/osconfig v1.10.0/go.mod h1:uMhCzqC5I8zfD9zDEAfvgVhDS8oIjySWh+l4WK6GnWw= +cloud.google.com/go/osconfig v1.11.0/go.mod h1:aDICxrur2ogRd9zY5ytBLV89KEgT2MKB2L/n6x1ooPw= +cloud.google.com/go/oslogin v1.4.0/go.mod h1:YdgMXWRaElXz/lDk1Na6Fh5orF7gvmJ0FGLIs9LId4E= +cloud.google.com/go/oslogin v1.5.0/go.mod h1:D260Qj11W2qx/HVF29zBg+0fd6YCSjSqLUkY/qEenQU= +cloud.google.com/go/oslogin v1.6.0/go.mod h1:zOJ1O3+dTU8WPlGEkFSh7qeHPPSoxrcMbbK1Nm2iX70= +cloud.google.com/go/oslogin v1.7.0/go.mod h1:e04SN0xO1UNJ1M5GP0vzVBFicIe4O53FOfcixIqTyXo= +cloud.google.com/go/oslogin v1.9.0/go.mod h1:HNavntnH8nzrn8JCTT5fj18FuJLFJc4NaZJtBnQtKFs= +cloud.google.com/go/phishingprotection v0.5.0/go.mod h1:Y3HZknsK9bc9dMi+oE8Bim0lczMU6hrX0UpADuMefr0= +cloud.google.com/go/phishingprotection v0.6.0/go.mod h1:9Y3LBLgy0kDTcYET8ZH3bq/7qni15yVUoAxiFxnlSUA= +cloud.google.com/go/phishingprotection v0.7.0/go.mod h1:8qJI4QKHoda/sb/7/YmMQ2omRLSLYSu9bU0EKCNI+Lk= +cloud.google.com/go/policytroubleshooter v1.3.0/go.mod h1:qy0+VwANja+kKrjlQuOzmlvscn4RNsAc0e15GGqfMxg= +cloud.google.com/go/policytroubleshooter v1.4.0/go.mod h1:DZT4BcRw3QoO8ota9xw/LKtPa8lKeCByYeKTIf/vxdE= +cloud.google.com/go/policytroubleshooter v1.5.0/go.mod h1:Rz1WfV+1oIpPdN2VvvuboLVRsB1Hclg3CKQ53j9l8vw= +cloud.google.com/go/policytroubleshooter v1.6.0/go.mod h1:zYqaPTsmfvpjm5ULxAyD/lINQxJ0DDsnWOP/GZ7xzBc= +cloud.google.com/go/privatecatalog v0.5.0/go.mod h1:XgosMUvvPyxDjAVNDYxJ7wBW8//hLDDYmnsNcMGq1K0= +cloud.google.com/go/privatecatalog v0.6.0/go.mod h1:i/fbkZR0hLN29eEWiiwue8Pb+GforiEIBnV9yrRUOKI= +cloud.google.com/go/privatecatalog v0.7.0/go.mod h1:2s5ssIFO69F5csTXcwBP7NPFTZvps26xGzvQ2PQaBYg= +cloud.google.com/go/privatecatalog v0.8.0/go.mod h1:nQ6pfaegeDAq/Q5lrfCQzQLhubPiZhSaNhIgfJlnIXs= cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/pubsub v1.26.0/go.mod h1:QgBH3U/jdJy/ftjPhTkyXNj543Tin1pRYcdcPRnFIRI= +cloud.google.com/go/pubsub v1.27.1/go.mod h1:hQN39ymbV9geqBnfQq6Xf63yNhUAhv9CZhzp5O6qsW0= +cloud.google.com/go/pubsub v1.28.0/go.mod h1:vuXFpwaVoIPQMGXqRyUQigu/AX1S3IWugR9xznmcXX8= +cloud.google.com/go/pubsub v1.30.0/go.mod h1:qWi1OPS0B+b5L+Sg6Gmc9zD1Y+HaM0MdUr7LsupY1P4= +cloud.google.com/go/pubsublite v1.5.0/go.mod h1:xapqNQ1CuLfGi23Yda/9l4bBCKz/wC3KIJ5gKcxveZg= +cloud.google.com/go/pubsublite v1.6.0/go.mod h1:1eFCS0U11xlOuMFV/0iBqw3zP12kddMeCbj/F3FSj9k= +cloud.google.com/go/pubsublite v1.7.0/go.mod h1:8hVMwRXfDfvGm3fahVbtDbiLePT3gpoiJYJY+vxWxVM= +cloud.google.com/go/recaptchaenterprise v1.3.1/go.mod h1:OdD+q+y4XGeAlxRaMn1Y7/GveP6zmq76byL6tjPE7d4= +cloud.google.com/go/recaptchaenterprise/v2 v2.1.0/go.mod h1:w9yVqajwroDNTfGuhmOjPDN//rZGySaf6PtFVcSCa7o= +cloud.google.com/go/recaptchaenterprise/v2 v2.2.0/go.mod h1:/Zu5jisWGeERrd5HnlS3EUGb/D335f9k51B/FVil0jk= +cloud.google.com/go/recaptchaenterprise/v2 v2.3.0/go.mod h1:O9LwGCjrhGHBQET5CA7dd5NwwNQUErSgEDit1DLNTdo= +cloud.google.com/go/recaptchaenterprise/v2 v2.4.0/go.mod h1:Am3LHfOuBstrLrNCBrlI5sbwx9LBg3te2N6hGvHn2mE= +cloud.google.com/go/recaptchaenterprise/v2 v2.5.0/go.mod h1:O8LzcHXN3rz0j+LBC91jrwI3R+1ZSZEWrfL7XHgNo9U= +cloud.google.com/go/recaptchaenterprise/v2 v2.6.0/go.mod h1:RPauz9jeLtB3JVzg6nCbe12qNoaa8pXc4d/YukAmcnA= +cloud.google.com/go/recaptchaenterprise/v2 v2.7.0/go.mod h1:19wVj/fs5RtYtynAPJdDTb69oW0vNHYDBTbB4NvMD9c= +cloud.google.com/go/recommendationengine v0.5.0/go.mod h1:E5756pJcVFeVgaQv3WNpImkFP8a+RptV6dDLGPILjvg= +cloud.google.com/go/recommendationengine v0.6.0/go.mod h1:08mq2umu9oIqc7tDy8sx+MNJdLG0fUi3vaSVbztHgJ4= +cloud.google.com/go/recommendationengine v0.7.0/go.mod h1:1reUcE3GIu6MeBz/h5xZJqNLuuVjNg1lmWMPyjatzac= +cloud.google.com/go/recommender v1.5.0/go.mod h1:jdoeiBIVrJe9gQjwd759ecLJbxCDED4A6p+mqoqDvTg= +cloud.google.com/go/recommender v1.6.0/go.mod h1:+yETpm25mcoiECKh9DEScGzIRyDKpZ0cEhWGo+8bo+c= +cloud.google.com/go/recommender v1.7.0/go.mod h1:XLHs/W+T8olwlGOgfQenXBTbIseGclClff6lhFVe9Bs= +cloud.google.com/go/recommender v1.8.0/go.mod h1:PkjXrTT05BFKwxaUxQmtIlrtj0kph108r02ZZQ5FE70= +cloud.google.com/go/recommender v1.9.0/go.mod h1:PnSsnZY7q+VL1uax2JWkt/UegHssxjUVVCrX52CuEmQ= +cloud.google.com/go/redis v1.7.0/go.mod h1:V3x5Jq1jzUcg+UNsRvdmsfuFnit1cfe3Z/PGyq/lm4Y= +cloud.google.com/go/redis v1.8.0/go.mod h1:Fm2szCDavWzBk2cDKxrkmWBqoCiL1+Ctwq7EyqBCA/A= +cloud.google.com/go/redis v1.9.0/go.mod h1:HMYQuajvb2D0LvMgZmLDZW8V5aOC/WxstZHiy4g8OiA= +cloud.google.com/go/redis v1.10.0/go.mod h1:ThJf3mMBQtW18JzGgh41/Wld6vnDDc/F/F35UolRZPM= +cloud.google.com/go/redis v1.11.0/go.mod h1:/X6eicana+BWcUda5PpwZC48o37SiFVTFSs0fWAJ7uQ= +cloud.google.com/go/resourcemanager v1.3.0/go.mod h1:bAtrTjZQFJkiWTPDb1WBjzvc6/kifjj4QBYuKCCoqKA= +cloud.google.com/go/resourcemanager v1.4.0/go.mod h1:MwxuzkumyTX7/a3n37gmsT3py7LIXwrShilPh3P1tR0= +cloud.google.com/go/resourcemanager v1.5.0/go.mod h1:eQoXNAiAvCf5PXxWxXjhKQoTMaUSNrEfg+6qdf/wots= +cloud.google.com/go/resourcemanager v1.6.0/go.mod h1:YcpXGRs8fDzcUl1Xw8uOVmI8JEadvhRIkoXXUNVYcVo= +cloud.google.com/go/resourcemanager v1.7.0/go.mod h1:HlD3m6+bwhzj9XCouqmeiGuni95NTrExfhoSrkC/3EI= +cloud.google.com/go/resourcesettings v1.3.0/go.mod h1:lzew8VfESA5DQ8gdlHwMrqZs1S9V87v3oCnKCWoOuQU= +cloud.google.com/go/resourcesettings v1.4.0/go.mod h1:ldiH9IJpcrlC3VSuCGvjR5of/ezRrOxFtpJoJo5SmXg= +cloud.google.com/go/resourcesettings v1.5.0/go.mod h1:+xJF7QSG6undsQDfsCJyqWXyBwUoJLhetkRMDRnIoXA= +cloud.google.com/go/retail v1.8.0/go.mod h1:QblKS8waDmNUhghY2TI9O3JLlFk8jybHeV4BF19FrE4= +cloud.google.com/go/retail v1.9.0/go.mod h1:g6jb6mKuCS1QKnH/dpu7isX253absFl6iE92nHwlBUY= +cloud.google.com/go/retail v1.10.0/go.mod h1:2gDk9HsL4HMS4oZwz6daui2/jmKvqShXKQuB2RZ+cCc= +cloud.google.com/go/retail v1.11.0/go.mod h1:MBLk1NaWPmh6iVFSz9MeKG/Psyd7TAgm6y/9L2B4x9Y= +cloud.google.com/go/retail v1.12.0/go.mod h1:UMkelN/0Z8XvKymXFbD4EhFJlYKRx1FGhQkVPU5kF14= +cloud.google.com/go/run v0.2.0/go.mod h1:CNtKsTA1sDcnqqIFR3Pb5Tq0usWxJJvsWOCPldRU3Do= +cloud.google.com/go/run v0.3.0/go.mod h1:TuyY1+taHxTjrD0ZFk2iAR+xyOXEA0ztb7U3UNA0zBo= +cloud.google.com/go/run v0.8.0/go.mod h1:VniEnuBwqjigv0A7ONfQUaEItaiCRVujlMqerPPiktM= +cloud.google.com/go/run v0.9.0/go.mod h1:Wwu+/vvg8Y+JUApMwEDfVfhetv30hCG4ZwDR/IXl2Qg= +cloud.google.com/go/scheduler v1.4.0/go.mod h1:drcJBmxF3aqZJRhmkHQ9b3uSSpQoltBPGPxGAWROx6s= +cloud.google.com/go/scheduler v1.5.0/go.mod h1:ri073ym49NW3AfT6DZi21vLZrG07GXr5p3H1KxN5QlI= +cloud.google.com/go/scheduler v1.6.0/go.mod h1:SgeKVM7MIwPn3BqtcBntpLyrIJftQISRrYB5ZtT+KOk= +cloud.google.com/go/scheduler v1.7.0/go.mod h1:jyCiBqWW956uBjjPMMuX09n3x37mtyPJegEWKxRsn44= +cloud.google.com/go/scheduler v1.8.0/go.mod h1:TCET+Y5Gp1YgHT8py4nlg2Sew8nUHMqcpousDgXJVQc= +cloud.google.com/go/scheduler v1.9.0/go.mod h1:yexg5t+KSmqu+njTIh3b7oYPheFtBWGcbVUYF1GGMIc= +cloud.google.com/go/secretmanager v1.6.0/go.mod h1:awVa/OXF6IiyaU1wQ34inzQNc4ISIDIrId8qE5QGgKA= +cloud.google.com/go/secretmanager v1.8.0/go.mod h1:hnVgi/bN5MYHd3Gt0SPuTPPp5ENina1/LxM+2W9U9J4= +cloud.google.com/go/secretmanager v1.9.0/go.mod h1:b71qH2l1yHmWQHt9LC80akm86mX8AL6X1MA01dW8ht4= +cloud.google.com/go/secretmanager v1.10.0/go.mod h1:MfnrdvKMPNra9aZtQFvBcvRU54hbPD8/HayQdlUgJpU= +cloud.google.com/go/security v1.5.0/go.mod h1:lgxGdyOKKjHL4YG3/YwIL2zLqMFCKs0UbQwgyZmfJl4= +cloud.google.com/go/security v1.7.0/go.mod h1:mZklORHl6Bg7CNnnjLH//0UlAlaXqiG7Lb9PsPXLfD0= +cloud.google.com/go/security v1.8.0/go.mod h1:hAQOwgmaHhztFhiQ41CjDODdWP0+AE1B3sX4OFlq+GU= +cloud.google.com/go/security v1.9.0/go.mod h1:6Ta1bO8LXI89nZnmnsZGp9lVoVWXqsVbIq/t9dzI+2Q= +cloud.google.com/go/security v1.10.0/go.mod h1:QtOMZByJVlibUT2h9afNDWRZ1G96gVywH8T5GUSb9IA= +cloud.google.com/go/security v1.12.0/go.mod h1:rV6EhrpbNHrrxqlvW0BWAIawFWq3X90SduMJdFwtLB8= +cloud.google.com/go/security v1.13.0/go.mod h1:Q1Nvxl1PAgmeW0y3HTt54JYIvUdtcpYKVfIB8AOMZ+0= +cloud.google.com/go/securitycenter v1.13.0/go.mod h1:cv5qNAqjY84FCN6Y9z28WlkKXyWsgLO832YiWwkCWcU= +cloud.google.com/go/securitycenter v1.14.0/go.mod h1:gZLAhtyKv85n52XYWt6RmeBdydyxfPeTrpToDPw4Auc= +cloud.google.com/go/securitycenter v1.15.0/go.mod h1:PeKJ0t8MoFmmXLXWm41JidyzI3PJjd8sXWaVqg43WWk= +cloud.google.com/go/securitycenter v1.16.0/go.mod h1:Q9GMaLQFUD+5ZTabrbujNWLtSLZIZF7SAR0wWECrjdk= +cloud.google.com/go/securitycenter v1.18.1/go.mod h1:0/25gAzCM/9OL9vVx4ChPeM/+DlfGQJDwBy/UC8AKK0= +cloud.google.com/go/securitycenter v1.19.0/go.mod h1:LVLmSg8ZkkyaNy4u7HCIshAngSQ8EcIRREP3xBnyfag= +cloud.google.com/go/servicecontrol v1.4.0/go.mod h1:o0hUSJ1TXJAmi/7fLJAedOovnujSEvjKCAFNXPQ1RaU= +cloud.google.com/go/servicecontrol v1.5.0/go.mod h1:qM0CnXHhyqKVuiZnGKrIurvVImCs8gmqWsDoqe9sU1s= +cloud.google.com/go/servicecontrol v1.10.0/go.mod h1:pQvyvSRh7YzUF2efw7H87V92mxU8FnFDawMClGCNuAA= +cloud.google.com/go/servicecontrol v1.11.0/go.mod h1:kFmTzYzTUIuZs0ycVqRHNaNhgR+UMUpw9n02l/pY+mc= +cloud.google.com/go/servicecontrol v1.11.1/go.mod h1:aSnNNlwEFBY+PWGQ2DoM0JJ/QUXqV5/ZD9DOLB7SnUk= +cloud.google.com/go/servicedirectory v1.4.0/go.mod h1:gH1MUaZCgtP7qQiI+F+A+OpeKF/HQWgtAddhTbhL2bs= +cloud.google.com/go/servicedirectory v1.5.0/go.mod h1:QMKFL0NUySbpZJ1UZs3oFAmdvVxhhxB6eJ/Vlp73dfg= +cloud.google.com/go/servicedirectory v1.6.0/go.mod h1:pUlbnWsLH9c13yGkxCmfumWEPjsRs1RlmJ4pqiNjVL4= +cloud.google.com/go/servicedirectory v1.7.0/go.mod h1:5p/U5oyvgYGYejufvxhgwjL8UVXjkuw7q5XcG10wx1U= +cloud.google.com/go/servicedirectory v1.8.0/go.mod h1:srXodfhY1GFIPvltunswqXpVxFPpZjf8nkKQT7XcXaY= +cloud.google.com/go/servicedirectory v1.9.0/go.mod h1:29je5JjiygNYlmsGz8k6o+OZ8vd4f//bQLtvzkPPT/s= +cloud.google.com/go/servicemanagement v1.4.0/go.mod h1:d8t8MDbezI7Z2R1O/wu8oTggo3BI2GKYbdG4y/SJTco= +cloud.google.com/go/servicemanagement v1.5.0/go.mod h1:XGaCRe57kfqu4+lRxaFEAuqmjzF0r+gWHjWqKqBvKFo= +cloud.google.com/go/servicemanagement v1.6.0/go.mod h1:aWns7EeeCOtGEX4OvZUWCCJONRZeFKiptqKf1D0l/Jc= +cloud.google.com/go/servicemanagement v1.8.0/go.mod h1:MSS2TDlIEQD/fzsSGfCdJItQveu9NXnUniTrq/L8LK4= +cloud.google.com/go/serviceusage v1.3.0/go.mod h1:Hya1cozXM4SeSKTAgGXgj97GlqUvF5JaoXacR1JTP/E= +cloud.google.com/go/serviceusage v1.4.0/go.mod h1:SB4yxXSaYVuUBYUml6qklyONXNLt83U0Rb+CXyhjEeU= +cloud.google.com/go/serviceusage v1.5.0/go.mod h1:w8U1JvqUqwJNPEOTQjrMHkw3IaIFLoLsPLvsE3xueec= +cloud.google.com/go/serviceusage v1.6.0/go.mod h1:R5wwQcbOWsyuOfbP9tGdAnCAc6B9DRwPG1xtWMDeuPA= +cloud.google.com/go/shell v1.3.0/go.mod h1:VZ9HmRjZBsjLGXusm7K5Q5lzzByZmJHf1d0IWHEN5X4= +cloud.google.com/go/shell v1.4.0/go.mod h1:HDxPzZf3GkDdhExzD/gs8Grqk+dmYcEjGShZgYa9URw= +cloud.google.com/go/shell v1.6.0/go.mod h1:oHO8QACS90luWgxP3N9iZVuEiSF84zNyLytb+qE2f9A= +cloud.google.com/go/spanner v1.41.0/go.mod h1:MLYDBJR/dY4Wt7ZaMIQ7rXOTLjYrmxLE/5ve9vFfWos= +cloud.google.com/go/spanner v1.44.0/go.mod h1:G8XIgYdOK+Fbcpbs7p2fiprDw4CaZX63whnSMLVBxjk= +cloud.google.com/go/spanner v1.45.0/go.mod h1:FIws5LowYz8YAE1J8fOS7DJup8ff7xJeetWEo5REA2M= +cloud.google.com/go/speech v1.6.0/go.mod h1:79tcr4FHCimOp56lwC01xnt/WPJZc4v3gzyT7FoBkCM= +cloud.google.com/go/speech v1.7.0/go.mod h1:KptqL+BAQIhMsj1kOP2la5DSEEerPDuOP/2mmkhHhZQ= +cloud.google.com/go/speech v1.8.0/go.mod h1:9bYIl1/tjsAnMgKGHKmBZzXKEkGgtU+MpdDPTE9f7y0= +cloud.google.com/go/speech v1.9.0/go.mod h1:xQ0jTcmnRFFM2RfX/U+rk6FQNUF6DQlydUSyoooSpco= +cloud.google.com/go/speech v1.14.1/go.mod h1:gEosVRPJ9waG7zqqnsHpYTOoAS4KouMRLDFMekpJ0J0= +cloud.google.com/go/speech v1.15.0/go.mod h1:y6oH7GhqCaZANH7+Oe0BhgIogsNInLlz542tg3VqeYI= cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= +cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y= +cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc= +cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s= +cloud.google.com/go/storage v1.28.1/go.mod h1:Qnisd4CqDdo6BGs2AD5LLnEsmSQ80wQ5ogcBBKhU86Y= +cloud.google.com/go/storage v1.29.0/go.mod h1:4puEjyTKnku6gfKoTfNOU/W+a9JyuVNxjpS5GBrB8h4= +cloud.google.com/go/storagetransfer v1.5.0/go.mod h1:dxNzUopWy7RQevYFHewchb29POFv3/AaBgnhqzqiK0w= +cloud.google.com/go/storagetransfer v1.6.0/go.mod h1:y77xm4CQV/ZhFZH75PLEXY0ROiS7Gh6pSKrM8dJyg6I= +cloud.google.com/go/storagetransfer v1.7.0/go.mod h1:8Giuj1QNb1kfLAiWM1bN6dHzfdlDAVC9rv9abHot2W4= +cloud.google.com/go/storagetransfer v1.8.0/go.mod h1:JpegsHHU1eXg7lMHkvf+KE5XDJ7EQu0GwNJbbVGanEw= +cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw= +cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g= +cloud.google.com/go/talent v1.3.0/go.mod h1:CmcxwJ/PKfRgd1pBjQgU6W3YBwiewmUzQYH5HHmSCmM= +cloud.google.com/go/talent v1.4.0/go.mod h1:ezFtAgVuRf8jRsvyE6EwmbTK5LKciD4KVnHuDEFmOOA= +cloud.google.com/go/talent v1.5.0/go.mod h1:G+ODMj9bsasAEJkQSzO2uHQWXHHXUomArjWQQYkqK6c= +cloud.google.com/go/texttospeech v1.4.0/go.mod h1:FX8HQHA6sEpJ7rCMSfXuzBcysDAuWusNNNvN9FELDd8= +cloud.google.com/go/texttospeech v1.5.0/go.mod h1:oKPLhR4n4ZdQqWKURdwxMy0uiTS1xU161C8W57Wkea4= +cloud.google.com/go/texttospeech v1.6.0/go.mod h1:YmwmFT8pj1aBblQOI3TfKmwibnsfvhIBzPXcW4EBovc= +cloud.google.com/go/tpu v1.3.0/go.mod h1:aJIManG0o20tfDQlRIej44FcwGGl/cD0oiRyMKG19IQ= +cloud.google.com/go/tpu v1.4.0/go.mod h1:mjZaX8p0VBgllCzF6wcU2ovUXN9TONFLd7iz227X2Xg= +cloud.google.com/go/tpu v1.5.0/go.mod h1:8zVo1rYDFuW2l4yZVY0R0fb/v44xLh3llq7RuV61fPM= +cloud.google.com/go/trace v1.3.0/go.mod h1:FFUE83d9Ca57C+K8rDl/Ih8LwOzWIV1krKgxg6N0G28= +cloud.google.com/go/trace v1.4.0/go.mod h1:UG0v8UBqzusp+z63o7FK74SdFE+AXpCLdFb1rshXG+Y= +cloud.google.com/go/trace v1.8.0/go.mod h1:zH7vcsbAhklH8hWFig58HvxcxyQbaIqMarMg9hn5ECA= +cloud.google.com/go/trace v1.9.0/go.mod h1:lOQqpE5IaWY0Ixg7/r2SjixMuc6lfTFeO4QGM4dQWOk= +cloud.google.com/go/translate v1.3.0/go.mod h1:gzMUwRjvOqj5i69y/LYLd8RrNQk+hOmIXTi9+nb3Djs= +cloud.google.com/go/translate v1.4.0/go.mod h1:06Dn/ppvLD6WvA5Rhdp029IX2Mi3Mn7fpMRLPvXT5Wg= +cloud.google.com/go/translate v1.5.0/go.mod h1:29YDSYveqqpA1CQFD7NQuP49xymq17RXNaUDdc0mNu0= +cloud.google.com/go/translate v1.6.0/go.mod h1:lMGRudH1pu7I3n3PETiOB2507gf3HnfLV8qlkHZEyos= +cloud.google.com/go/translate v1.7.0/go.mod h1:lMGRudH1pu7I3n3PETiOB2507gf3HnfLV8qlkHZEyos= +cloud.google.com/go/video v1.8.0/go.mod h1:sTzKFc0bUSByE8Yoh8X0mn8bMymItVGPfTuUBUyRgxk= +cloud.google.com/go/video v1.9.0/go.mod h1:0RhNKFRF5v92f8dQt0yhaHrEuH95m068JYOvLZYnJSw= +cloud.google.com/go/video v1.12.0/go.mod h1:MLQew95eTuaNDEGriQdcYn0dTwf9oWiA4uYebxM5kdg= +cloud.google.com/go/video v1.13.0/go.mod h1:ulzkYlYgCp15N2AokzKjy7MQ9ejuynOJdf1tR5lGthk= +cloud.google.com/go/video v1.14.0/go.mod h1:SkgaXwT+lIIAKqWAJfktHT/RbgjSuY6DobxEp0C5yTQ= +cloud.google.com/go/video v1.15.0/go.mod h1:SkgaXwT+lIIAKqWAJfktHT/RbgjSuY6DobxEp0C5yTQ= +cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU= +cloud.google.com/go/videointelligence v1.7.0/go.mod h1:k8pI/1wAhjznARtVT9U1llUaFNPh7muw8QyOUpavru4= +cloud.google.com/go/videointelligence v1.8.0/go.mod h1:dIcCn4gVDdS7yte/w+koiXn5dWVplOZkE+xwG9FgK+M= +cloud.google.com/go/videointelligence v1.9.0/go.mod h1:29lVRMPDYHikk3v8EdPSaL8Ku+eMzDljjuvRs105XoU= +cloud.google.com/go/videointelligence v1.10.0/go.mod h1:LHZngX1liVtUhZvi2uNS0VQuOzNi2TkY1OakiuoUOjU= +cloud.google.com/go/vision v1.2.0/go.mod h1:SmNwgObm5DpFBme2xpyOyasvBc1aPdjvMk2bBk0tKD0= +cloud.google.com/go/vision/v2 v2.2.0/go.mod h1:uCdV4PpN1S0jyCyq8sIM42v2Y6zOLkZs+4R9LrGYwFo= +cloud.google.com/go/vision/v2 v2.3.0/go.mod h1:UO61abBx9QRMFkNBbf1D8B1LXdS2cGiiCRx0vSpZoUo= +cloud.google.com/go/vision/v2 v2.4.0/go.mod h1:VtI579ll9RpVTrdKdkMzckdnwMyX2JILb+MhPqRbPsY= +cloud.google.com/go/vision/v2 v2.5.0/go.mod h1:MmaezXOOE+IWa+cS7OhRRLK2cNv1ZL98zhqFFZaaH2E= +cloud.google.com/go/vision/v2 v2.6.0/go.mod h1:158Hes0MvOS9Z/bDMSFpjwsUrZ5fPrdwuyyvKSGAGMY= +cloud.google.com/go/vision/v2 v2.7.0/go.mod h1:H89VysHy21avemp6xcf9b9JvZHVehWbET0uT/bcuY/0= +cloud.google.com/go/vmmigration v1.2.0/go.mod h1:IRf0o7myyWFSmVR1ItrBSFLFD/rJkfDCUTO4vLlJvsE= +cloud.google.com/go/vmmigration v1.3.0/go.mod h1:oGJ6ZgGPQOFdjHuocGcLqX4lc98YQ7Ygq8YQwHh9A7g= +cloud.google.com/go/vmmigration v1.5.0/go.mod h1:E4YQ8q7/4W9gobHjQg4JJSgXXSgY21nA5r8swQV+Xxc= +cloud.google.com/go/vmmigration v1.6.0/go.mod h1:bopQ/g4z+8qXzichC7GW1w2MjbErL54rk3/C843CjfY= +cloud.google.com/go/vmwareengine v0.1.0/go.mod h1:RsdNEf/8UDvKllXhMz5J40XxDrNJNN4sagiox+OI208= +cloud.google.com/go/vmwareengine v0.2.2/go.mod h1:sKdctNJxb3KLZkE/6Oui94iw/xs9PRNC2wnNLXsHvH8= +cloud.google.com/go/vmwareengine v0.3.0/go.mod h1:wvoyMvNWdIzxMYSpH/R7y2h5h3WFkx6d+1TIsP39WGY= +cloud.google.com/go/vpcaccess v1.4.0/go.mod h1:aQHVbTWDYUR1EbTApSVvMq1EnT57ppDmQzZ3imqIk4w= +cloud.google.com/go/vpcaccess v1.5.0/go.mod h1:drmg4HLk9NkZpGfCmZ3Tz0Bwnm2+DKqViEpeEpOq0m8= +cloud.google.com/go/vpcaccess v1.6.0/go.mod h1:wX2ILaNhe7TlVa4vC5xce1bCnqE3AeH27RV31lnmZes= +cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xXZmFiHmGE= +cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg= +cloud.google.com/go/webrisk v1.6.0/go.mod h1:65sW9V9rOosnc9ZY7A7jsy1zoHS5W9IAXv6dGqhMQMc= +cloud.google.com/go/webrisk v1.7.0/go.mod h1:mVMHgEYH0r337nmt1JyLthzMr6YxwN1aAIEc2fTcq7A= +cloud.google.com/go/webrisk v1.8.0/go.mod h1:oJPDuamzHXgUc+b8SiHRcVInZQuybnvEW72PqTc7sSg= +cloud.google.com/go/websecurityscanner v1.3.0/go.mod h1:uImdKm2wyeXQevQJXeh8Uun/Ym1VqworNDlBXQevGMo= +cloud.google.com/go/websecurityscanner v1.4.0/go.mod h1:ebit/Fp0a+FWu5j4JOmJEV8S8CzdTkAS77oDsiSqYWQ= +cloud.google.com/go/websecurityscanner v1.5.0/go.mod h1:Y6xdCPy81yi0SQnDY1xdNTNpfY1oAgXUlcfN3B3eSng= +cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0= +cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M= +cloud.google.com/go/workflows v1.8.0/go.mod h1:ysGhmEajwZxGn1OhGOGKsTXc5PyxOc0vfKf5Af+to4M= +cloud.google.com/go/workflows v1.9.0/go.mod h1:ZGkj1aFIOd9c8Gerkjjq7OW7I5+l6cSvT3ujaO/WwSA= +cloud.google.com/go/workflows v1.10.0/go.mod h1:fZ8LmRmZQWacon9UCX1r/g/DfAXx5VcPALq2CxzdePw= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +gioui.org v0.0.0-20210308172011-57750fc8a0a6/go.mod h1:RSH6KIUZ0p2xy5zHDxgAM4zumjgTw83q2ge/PI+yyw8= +git.sr.ht/~sbinet/gg v0.3.1/go.mod h1:KGYtlADtqsqANL9ueOFkWymvzUvLMQllU5Ixo+8v3pc= github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg= github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c h1:pxW6RcqyfI9/kWtOwnv/G+AzdKuy2ZrqINhenH4HyNs= github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c/go.mod h1:X0CRv0ky0k6m906ixxpzmDRLvX58TFUKS2eePweuyxk= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= github.com/NebulousLabs/fastrand v0.0.0-20181203155948-6fb6489aac4e h1:n+DcnTNkQnHlwpsrHoQtkrJIO7CBx029fw6oR4vIob4= @@ -45,24 +610,27 @@ github.com/NebulousLabs/go-upnp v0.0.0-20180202185039-29b680b06c82 h1:MG93+PZYs9 github.com/NebulousLabs/go-upnp v0.0.0-20180202185039-29b680b06c82/go.mod h1:GbuBk21JqF+driLX3XtJYNZjGa45YDoa9IqCTzNSfEc= github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw= github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk= +github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= github.com/Yawning/aez v0.0.0-20211027044916-e49e68abd344 h1:cDVUiFo+npB0ZASqnw4q90ylaVAbnYyx0JYqK4YcGok= github.com/Yawning/aez v0.0.0-20211027044916-e49e68abd344/go.mod h1:9pIqrY6SXNL8vjRQE5Hd/OL5GyK/9MrGUWs87z/eFfk= github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da h1:KjTM2ks9d14ZYCvmHS9iAKVt9AyzRSqNU1qabPih5BY= github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da/go.mod h1:eHEWzANqSiWQsof+nXEI9bUVUyV6F53Fp89EuCh2EAA= github.com/aead/siphash v1.0.1 h1:FwHfE/T45KPKYuuSAKyyvE+oPWcaQ+CUmFW0bPlM+kg= github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= -github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= -github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= -github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= -github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= -github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho= +github.com/ajstarks/deck v0.0.0-20200831202436-30c9fc6549a9/go.mod h1:JynElWSGnm/4RlzPXRlREEwqTHAN3T56Bv2ITsFT3gY= +github.com/ajstarks/deck/generate v0.0.0-20210309230005-c3f852c02e19/go.mod h1:T13YZdzov6OU0A1+RfKZiZN9ca6VeKdBdyDV+BY97Tk= +github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b/go.mod h1:1KcenG0jGWcpt8ov532z81sp/kMMUG485J2InIOyADM= +github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/apache/arrow/go/v10 v10.0.1/go.mod h1:YvhnlEePVnBS4+0z3fhPfUy7W1Ikj0Ih0vcRo/gZ1M0= +github.com/apache/arrow/go/v11 v11.0.0/go.mod h1:Eg5OsL5H+e299f7u5ssuXsuHQVEGC4xei5aX110hRiI= +github.com/apache/thrift v0.16.0/go.mod h1:PHK3hniurgQaNMZYaCLEqXKsYK8upmhPbmdP2FXSqgU= github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= -github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= -github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8= +github.com/boombuler/barcode v1.0.1/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8= github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= github.com/btcsuite/btcd v0.22.0-beta.0.20220111032746-97732e52810c/go.mod h1:tjmYdS6MLJ5/s0Fj4DbLgSbDHbEqLJrtnHecBFkdz5M= github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A= @@ -92,8 +660,8 @@ github.com/btcsuite/btclog v1.0.0/go.mod h1:w7xnGOhwT3lmrS4H3b/D1XAXxvh+tbhUm8xe github.com/btcsuite/btclog/v2 v2.0.1-0.20250728225537-6090e87c6c5b h1:MQ+Q6sDy37V1wP1Yu79A5KqJutolqUGwA99UZWQDWZM= github.com/btcsuite/btclog/v2 v2.0.1-0.20250728225537-6090e87c6c5b/go.mod h1:XItGUfVOxotJL8kkuk2Hj3EVow5KCugXl3wWfQ6K0AE= github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= -github.com/btcsuite/btcwallet v0.16.18 h1:6h0kMxij4igPu35jOPAWZbn22ceOC4me4L3jj8Za6Zk= -github.com/btcsuite/btcwallet v0.16.18/go.mod h1:4TTru0cgIPbCZpY4aRfAVwX87zrQw4GXM8MH6+A5xZw= +github.com/btcsuite/btcwallet v0.16.19 h1:F52y5luPecfjSDajteVm8qYR6H8vsZ40Ot+Mim8e3JA= +github.com/btcsuite/btcwallet v0.16.19/go.mod h1:u4908XXsJNEl8t8uYz01dEMZqGg6cMN4WCumcuHmbUE= github.com/btcsuite/btcwallet/wallet/txauthor v1.3.5 h1:Rr0njWI3r341nhSPesKQ2JF+ugDSzdPoeckS75SeDZk= github.com/btcsuite/btcwallet/wallet/txauthor v1.3.5/go.mod h1:+tXJ3Ym0nlQc/iHSwW1qzjmPs3ev+UVWMbGgfV1OZqU= github.com/btcsuite/btcwallet/wallet/txrules v1.2.2 h1:YEO+Lx1ZJJAtdRrjuhXjWrYsmAk26wLTlNzxt2q0lhk= @@ -120,8 +688,11 @@ github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyY github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM= github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw= +github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= @@ -129,6 +700,18 @@ github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5P github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20220314180256-7f1daf1720fc/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20230105202645-06c439db220b/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cockroachdb/datadriven v1.0.2 h1:H9MtNqVoVhvd9nCBwOyDjUEdZCREqbIdCJD93PBm/jA= github.com/cockroachdb/datadriven v1.0.2/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= github.com/containerd/continuity v0.3.0 h1:nisirsYROK15TAMVukJOUyGJjz4BNQJBVsNvAXZJ/eg= @@ -175,16 +758,30 @@ github.com/docker/go-connections v0.7.0 h1:6SsRfJddP22WMrCkj19x9WKjEDTB+ahsdiGYf github.com/docker/go-connections v0.7.0/go.mod h1:no1qkHdjq7kLMGUXYAduOhYPSJxxvgWBh7ogVvptn3Q= github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= +github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= +github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= +github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= +github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= +github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= +github.com/envoyproxy/go-control-plane v0.10.3/go.mod h1:fJJn/j26vwOu972OllsvAgJJM//w9BV6Fxbg2LuVd34= +github.com/envoyproxy/go-control-plane v0.11.1-0.20230524094728-9239064ad72f/go.mod h1:sfYdkwUW4BA3PbKjySwjJy+O4Pu0h62rlqCMHNk+K+Q= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= -github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/envoyproxy/protoc-gen-validate v0.6.7/go.mod h1:dyJXwwfPK2VSqiB9Klm1J6romD608Ba7Hij42vrOBCo= +github.com/envoyproxy/protoc-gen-validate v0.9.1/go.mod h1:OKNgG7TCp5pF4d6XftA0++PMirau2/yoOwVac3AbF2w= +github.com/envoyproxy/protoc-gen-validate v0.10.1/go.mod h1:DRjgyB0I43LtJapqN6NiRwroiAU2PaFuvk/vjgh61ss= +github.com/felixge/httpsnoop v1.1.0 h1:3YtUj32ZZkqZtt3sZZsClsymw/QDuVfpNhoA31zeORc= +github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9vDSi5UZCE= github.com/fergusstrange/embedded-postgres v1.25.0 h1:sa+k2Ycrtz40eCRPOzI7Ry7TtkWXXJ+YRsxpKMDhxK0= github.com/fergusstrange/embedded-postgres v1.25.0/go.mod h1:t/MLs0h9ukYM6FSt99R7InCHs1nW0ordoVCcnzmpTYw= +github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= github.com/frankban/quicktest v1.0.0/go.mod h1:R98jIehRai+d1/3Hv2//jOVCTJhW1VBavT6B6CuGq2k= @@ -198,17 +795,16 @@ github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4 github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI= github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/go-fonts/dejavu v0.1.0/go.mod h1:4Wt4I4OU2Nq9asgDCteaAaWZOV24E+0/Pwo0gppep4g= +github.com/go-fonts/latin-modern v0.2.0/go.mod h1:rQVLdDMK+mK1xscDwsqM5J8U2jrRa3T0ecnM9pNujks= +github.com/go-fonts/liberation v0.2.0/go.mod h1:K6qoJYypsmfVjWg8KOVDQhLc8UDgIK2HYqyqAO9z7GY= +github.com/go-fonts/stix v0.1.0/go.mod h1:w/c1f0ldAUlJmLBvlbkvVXLAD+tAMqobIIQpmnUIzUY= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= -github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= -github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= -github.com/go-kit/log v0.2.0/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0= -github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= -github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= +github.com/go-latex/latex v0.0.0-20210823091927-c0d11ff05a81/go.mod h1:SX0U8uGpxhq9o2S/CELCSUxEWWAuoCUcVCQWv7G2OCk= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= -github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= @@ -216,18 +812,23 @@ github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-macaroon-bakery/macaroonpb v1.0.0 h1:It9exBaRMZ9iix1iJ6gwzfwsDE6ExNuwtAJ9e09v6XE= github.com/go-macaroon-bakery/macaroonpb v1.0.0/go.mod h1:UzrGOcbiwTXISFP2XDLDPjfhMINZa+fX/7A2lMd31zc= +github.com/go-pdf/fpdf v0.5.0/go.mod h1:HzcnA+A23uwogo0tp9yU+l3V+KXhiESpt1PMayhOh5M= +github.com/go-pdf/fpdf v0.6.0/go.mod h1:HzcnA+A23uwogo0tp9yU+l3V+KXhiESpt1PMayhOh5M= github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE= github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= +github.com/goccy/go-json v0.9.11/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= -github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang-jwt/jwt/v4 v4.5.2 h1:YtQM7lnr8iZ+j5q71MGKkNw9Mn7AjHM68uc9g5fXeUI= github.com/golang-jwt/jwt/v4 v4.5.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= +github.com/golang/glog v1.1.0/go.mod h1:pfYeQZ3JWZoXTV5sFc986z3HTpwQs9At6P4ImfuP3NQ= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -238,6 +839,8 @@ github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= @@ -249,31 +852,47 @@ github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QD github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM= github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= -github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= +github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs= +github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/gonum/gonum v0.11.0 h1:Lffpf1Aq8WeVUJTbfiKHlOVlFm+c021iePrlwvE5woI= github.com/gonum/gonum v0.11.0/go.mod h1:fSG4YDCxxUZQJ7rKsQrj0gMOg00Il0Z96/qMA4bVQhA= +github.com/gonum/plot v0.10.1/go.mod h1:VZW5OlhkL1mysU9vaqNHnsy86inf6Ot+jB3r+BczCEo= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.1 h1:gK4Kx5IaGY9CD5sPJ36FHiBJ6ZXl0kilRiiCj+jdYp4= github.com/google/btree v1.0.1/go.mod h1:xXMiIv4Fb/0kKde4SpL7qlzvu5cMJDRkFDxJfI9uaxA= +github.com/google/flatbuffers v2.0.8+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.2.1-0.20190312032427-6f77996f0c42/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= +github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= +github.com/google/martian/v3 v3.3.2/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= @@ -281,25 +900,56 @@ github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hf github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd h1:gbpYu9NMq8jhDVbvlGkMFWCjLFlqqEZjEmObmhUy6Vo= -github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd/go.mod h1:kf6iHlnVGwgKolg33glAes7Yg/8iWP8ukqeldJSO7jw= +github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3 h1:LMLX+LgTNWpfvCBdFebv6EsYotImrt/Ppc5cXIriCSo= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3/go.mod h1:jl5iWTm0/hd5PjEYEOuwAJ57L/CibdZfrqZ5XA5GrCk= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg= +github.com/googleapis/enterprise-certificate-proxy v0.2.1/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= +github.com/googleapis/enterprise-certificate-proxy v0.2.3/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= +github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM= +github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM= +github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM= +github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c= +github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo= +github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY= +github.com/googleapis/gax-go/v2 v2.7.0/go.mod h1:TEop28CZZQ2y+c0VxMUmu1lV+fQx57QpBWsYpwqHJx8= +github.com/googleapis/gax-go/v2 v2.7.1/go.mod h1:4orTrqY6hXxxaUL4LHIPl6lGo8vAE38/qKbhSAKP6QI= +github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4= +github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI= github.com/grpc-ecosystem/go-grpc-middleware v1.4.0/go.mod h1:g5qyo/la0ALbONm6Vbp88Yd8NsDy6rZz+RcrMPxvld8= +github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.0.0-rc.0 h1:mdLirNAJBxnGgyB6pjZLcs6ue/6eZGBui6gXspfq4ks= +github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.0.0-rc.0/go.mod h1:kdXbOySqcQeTxiqglW7aahTmWZy3Pgi6SYL36yvKeyA= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.0.0-rc.3 h1:o95KDiV/b1xdkumY5YbLR0/n2+wBxUpgf3HgfKgTyLI= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.0.0-rc.3/go.mod h1:hTxjzRcX49ogbTGVJ1sM5mz5s+SSgiGIyL3jjPxl32E= github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 h1:Ovs26xHkKqVztRpIrF/92BcuyuQ/YW4NSIpoGtfXNho= github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3/go.mod h1:o//XUCC/F+yRGJoPO/VU0GSB0f8Nhgmxx0VIRUvaC0w= github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 h1:5VipnvEpbqr2gA2VbM+nYVbkIF28c5ZQfqCBQ5g2xfk= github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0/go.mod h1:Hyl3n6Twe1hvtd9XUXDec4pTvgMSEixRuQKPTMH2bNs= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= @@ -308,9 +958,14 @@ github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brv github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8= github.com/jackc/chunkreader/v2 v2.0.1/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk= github.com/jackc/pgconn v1.14.3 h1:bVoTr12EGANZz66nZPkMInAV/KHD2TxH9npjXXgiB3w= @@ -325,8 +980,8 @@ github.com/jackc/pgproto3/v2 v2.3.3 h1:1HLSx5H+tXR9pW3in3zaztoEwQYRC9SQaYUHjTSUO github.com/jackc/pgproto3/v2 v2.3.3/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA= github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= -github.com/jackc/pgx/v5 v5.9.2 h1:3ZhOzMWnR4yJ+RW1XImIPsD1aNSz4T4fyP7zlQb56hw= -github.com/jackc/pgx/v5 v5.9.2/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= github.com/jackpal/gateway v1.0.5 h1:qzXWUJfuMdlLMtt0a3Dgt+xkWQiA5itDEITVJtuSwMc= @@ -339,13 +994,9 @@ github.com/jessevdk/go-flags v1.6.1 h1:Cvu5U8UGrLay1rZfv/zP7iLpSHGUZ/Ou68T0iX1bB github.com/jessevdk/go-flags v1.6.1/go.mod h1:Mk8T1hIAWpOiJiHa9rJASDK2UGWji0EuPGBnNLMooyc= github.com/jonboulle/clockwork v0.2.2 h1:UOGuzwb1PwsrDAObMuhUnj0p5ULPj8V/xJ7Kx9qUBdQ= github.com/jonboulle/clockwork v0.2.2/go.mod h1:Pkfl5aHPm1nk2H9h0bjmnJD/BcgbGXUBGnn1kMkgxc8= -github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4= github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= github.com/jrick/logrotate v1.1.2 h1:6ePk462NCX7TfKtNp5JJ7MbA2YIslkpfgP03TlTYMN0= github.com/jrick/logrotate v1.1.2/go.mod h1:f9tdWggSVK3iqavGpyvegq5IhNois7KXmasU6/N96OQ= -github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= -github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= -github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= @@ -356,25 +1007,31 @@ github.com/juju/qthttptest v0.0.1/go.mod h1://LCf/Ls22/rPw2u1yWukUJvYtfPY4nYpWUl github.com/juju/schema v1.0.0/go.mod h1:Y+ThzXpUJ0E7NYYocAbuvJ7vTivXfrof/IfRPq/0abI= github.com/juju/webbrowser v0.0.0-20160309143629-54b8c57083b4/go.mod h1:G6PCelgkM6cuvyD10iYJsjLBsSadVXtJ+nBxFAxE2BU= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= -github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= +github.com/jung-kurt/gofpdf v1.0.0/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= +github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= github.com/kkdai/bstream v1.0.0 h1:Se5gHwgp2VT2uHfDrkbbgbgEvV9cimLELwrPJctSjg8= github.com/kkdai/bstream v1.0.0/go.mod h1:FDnDOHt5Yx4p3FaHcioFT0QjDOtgUpvjeZqAs+NVZZA= +github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE= +github.com/klauspost/compress v1.15.9/go.mod h1:PhcZ0MbTNciWF3rruxRgKxI5NkcHHrHUDtV4Yw2GlzU= github.com/klauspost/compress v1.18.7 h1:aUyZsS4kH3QTKurYhAOwAHxllVPnOthb3vPfnF1Ehjw= github.com/klauspost/compress v1.18.7/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/lib/pq v1.3.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw= @@ -395,14 +1052,18 @@ github.com/lightninglabs/neutrino/cache v1.1.3 h1:rgnabC41W+XaPuBTQrdeFjFCCAVKh1 github.com/lightninglabs/neutrino/cache v1.1.3/go.mod h1:qxkJb+pUxR5p84jl5uIGFCR4dGdFkhNUwMSxw3EUWls= github.com/lightninglabs/protobuf-go-hex-display v1.34.2-hex-display h1:w7FM5LH9Z6CpKxl13mS48idsu6F+cEZf0lkyiV+Dq9g= github.com/lightninglabs/protobuf-go-hex-display v1.34.2-hex-display/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= -github.com/lightninglabs/taproot-assets v0.8.1 h1:E0xbHcQ/B+KmMZz6o3nqiYSMcDs2Vu0aWd+FuomDFYg= -github.com/lightninglabs/taproot-assets v0.8.1/go.mod h1:iq4ZybixussUx6NUaMYyo20uXMptibhbVLM3y/0ihIc= -github.com/lightninglabs/taproot-assets/taprpc v1.2.0 h1:CDiGyo19DTUyJcZTdhp5d6AQBz94N+mpGQNO0kEcnPk= -github.com/lightninglabs/taproot-assets/taprpc v1.2.0/go.mod h1:RkBWxHKN8JpPtoa/yBK5qZW5svz5pR9GAOT2rUP7oOI= +github.com/lightninglabs/tap-sdk v0.1.1 h1:y4qqkIw46/C/h9z+gQoez3L9X36VyiS59CwXvf8j+oM= +github.com/lightninglabs/tap-sdk v0.1.1/go.mod h1:YGGIq/EGyCzBMnJCJGMvW4cJ2CptEqvdztYWT3OOON8= +github.com/lightninglabs/taproot-assets v0.8.8 h1:4c95GFwOuhJSvjZRVaX0GmCEH1scHKF/3pCmYDn3AqU= +github.com/lightninglabs/taproot-assets v0.8.8/go.mod h1:6cuyFnJr8CCLn2bzjOzxebbqRf6MCNZOt+RSllwhqe0= +github.com/lightninglabs/taproot-assets/taprpc v1.3.3 h1:KwscIMQ7Nyy8SleDiUUTWPCgixpgrN9nunM+QwM/KJQ= +github.com/lightninglabs/taproot-assets/taprpc v1.3.3/go.mod h1:0dBS6jLkddm8EvpJSpJjPUMWr294/YRoM/IAzdfo3pw= +github.com/lightninglabs/taproot-assets/third_party/lnd/tlv v0.0.0-20261022183431-6e0fef585a97 h1:0X9Tw7cjmRPsT/NWWwae59tnYCIdbl7pSMC2g6W+yNg= +github.com/lightninglabs/taproot-assets/third_party/lnd/tlv v0.0.0-20261022183431-6e0fef585a97/go.mod h1:pJuiBj1ecr1WWLOtcZ+2+hu9Ey25aJWFIsjmAoPPnmc= github.com/lightningnetwork/lightning-onion v1.3.0 h1:FqILgHjD6euc/Muo1VOzZ4+XDPuFnw6EYROBq0rR/5c= github.com/lightningnetwork/lightning-onion v1.3.0/go.mod h1:nP85zMHG7c0si/eHBbSQpuDCtnIXfSvFrK3tW6YWzmU= -github.com/lightningnetwork/lnd v0.21.0-beta h1:bDP5UH15E7DVGTztsmBPQLqgyilq5EXDrglvQFmRc3U= -github.com/lightningnetwork/lnd v0.21.0-beta/go.mod h1:HcKq9DyxbVEZXuR28TIyGbIIgAjANCxI+N6dqOnRBAA= +github.com/lightningnetwork/lnd v0.21.3-beta h1:Tp1YdwnP0daq/wenwObkaCqe0hckIRnxibN2QKoUv9Y= +github.com/lightningnetwork/lnd v0.21.3-beta/go.mod h1:cUmbodV1/27JGrM/aKib8mXfz8bFxT9iGm0WJi647ds= github.com/lightningnetwork/lnd/actor v0.0.6 h1:Ge8N2wivARG+27qJBwTlB0vwsypStZYZy8vk4Zl38sU= github.com/lightningnetwork/lnd/actor v0.0.6/go.mod h1:YAsoniSbY/cAM9HTVNfZLvt7RI6swDxy6wzPspTcMZg= github.com/lightningnetwork/lnd/cert v1.2.2 h1:71YK6hogeJtxSxw2teq3eGeuy4rHGKcFf0d0Uy4qBjI= @@ -421,20 +1082,24 @@ github.com/lightningnetwork/lnd/sqldb v1.0.13-0.20260514041430-e9b422f78581 h1:s github.com/lightningnetwork/lnd/sqldb v1.0.13-0.20260514041430-e9b422f78581/go.mod h1:PQvrB+2SlYuyAoe0ac/SUIMZ9rP73jYlanIN8O7/eA0= github.com/lightningnetwork/lnd/ticker v1.1.1 h1:J/b6N2hibFtC7JLV77ULQp++QLtCwT6ijJlbdiZFbSM= github.com/lightningnetwork/lnd/ticker v1.1.1/go.mod h1:waPTRAAcwtu7Ji3+3k+u/xH5GHovTsCoSVpho0KDvdA= -github.com/lightningnetwork/lnd/tlv v1.3.2 h1:MO4FCk7F4k5xPMqVZF6Nb/kOpxlwPrUQpYjmyKny5s0= -github.com/lightningnetwork/lnd/tlv v1.3.2/go.mod h1:pJuiBj1ecr1WWLOtcZ+2+hu9Ey25aJWFIsjmAoPPnmc= -github.com/lightningnetwork/lnd/tor v1.1.6 h1:WHUumk7WgU6BUFsqHuqszI9P6nfhMeIG+rjJBlVE6OE= -github.com/lightningnetwork/lnd/tor v1.1.6/go.mod h1:qSRB8llhAK+a6kaTPWOLLXSZc6Hg8ZC0mq1sUQ/8JfI= +github.com/lightningnetwork/lnd/tor v1.1.7 h1:BfY1KQGz3LVaeaAGI4XYGYCwDQR1ADFD1P/uXsS2dQc= +github.com/lightningnetwork/lnd/tor v1.1.7/go.mod h1:DANQ6QCQBiR+CqrM+mKudgkMy6CR/RS4ALDbjb2W4FU= github.com/ltcsuite/ltcd v0.0.0-20190101042124-f37f8bf35796 h1:sjOGyegMIhvgfq5oaue6Td+hxZuf3tDC8lAPrFldqFw= github.com/ltcsuite/ltcd v0.0.0-20190101042124-f37f8bf35796/go.mod h1:3p7ZTf9V1sNPI5H8P3NkTFF4LuwMdPl2DodF60qAKqY= github.com/ltcsuite/ltcutil v0.0.0-20181217130922-17f3b04680b6/go.mod h1:8Vg/LTOO0KYa/vlHWJ6XZAevPQThGH5sufO0Hrou/lA= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= -github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI= -github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/lukechampine/uint128 v1.2.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= +github.com/lyft/protoc-gen-star v0.6.0/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= +github.com/lyft/protoc-gen-star v0.6.1/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= +github.com/lyft/protoc-gen-star/v2 v2.0.1/go.mod h1:RcCdONR2ScXaYnQC5tUzxzlpA3WVYF7/opLeUgcQs/o= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI= +github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A= +github.com/mattn/go-sqlite3 v1.14.14/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= github.com/miekg/dns v1.1.50 h1:DQUfb9uc6smULcREF09Uc+/Gd46YWqJd5DbpPE9xkcA= github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME= +github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8/go.mod h1:mC1jAcsrzbxHt8iiaC+zU4b1ylILSosueou12R++wfY= +github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3/go.mod h1:RagcQ7I8IeTMnF8JTXieKnO4Z6JCsikNEzj0DwauVzE= github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= github.com/moby/moby/api v1.54.2 h1:wiat9QAhnDQjA7wk1kh/TqHz2I1uUA7M7t9SAl/JNXg= @@ -448,16 +1113,14 @@ github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFL github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= -github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= -github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= -github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= -github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w= +github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= @@ -482,55 +1145,53 @@ github.com/opencontainers/runc v1.3.6/go.mod h1:o1wyv76EDlTkcf0KTFgN8bMWLPvgF/Hf github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/ory/dockertest/v3 v3.10.0 h1:4K3z2VMe8Woe++invjaTB7VRyQXQy5UY+loujO4aNE4= github.com/ory/dockertest/v3 v3.10.0/go.mod h1:nr57ZbRWMqfsdGdFNLHz5jjNdDb7VVFnzAeW1n5N1Lg= -github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/phpdave11/gofpdf v1.4.2/go.mod h1:zpO6xFn9yxo3YLyMvW8HcKWVdbNqgIfOOp2dXMnm1mY= +github.com/phpdave11/gofpdi v1.0.12/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI= +github.com/phpdave11/gofpdi v1.0.13/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI= +github.com/pierrec/lz4/v4 v4.1.15/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= +github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= -github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= -github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M= -github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0= -github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY= -github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw= -github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y= -github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= -github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= +github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.3.0 h1:UBgGFHqYdG/TPFD1B1ogZywDqEkwp3fBMvqdiQ7Xew4= github.com/prometheus/client_model v0.3.0/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= -github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= -github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= -github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc= -github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= -github.com/prometheus/common v0.37.0 h1:ccBbHCgIiT9uSoFY0vX8H3zsNR5eLt17/RQLUvn8pXE= -github.com/prometheus/common v0.37.0/go.mod h1:phzohg0JFMnBEFGxTDbfu3QyL5GI8gTQJFhYO5B3mfA= -github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= -github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= -github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= -github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= -github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= -github.com/prometheus/procfs v0.8.0 h1:ODq8ZFEaYeCaZOJlZZdJA2AbQR98dSHSM1KW/You5mo= -github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4= +github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= +github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= +github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs= +github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA= +github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg= +github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is= +github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v1.2.0 h1:Ppwyp6VYCF1nvBTXL3trRso7mXMlRrw9ooo375wvi2s= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w= +github.com/ruudk/golang-pdf417 v0.0.0-20201230142125-a7e3863a1245/go.mod h1:pQAZKsJ8yyVxGRWYNEm9oFB8ieLgKFnamEyDmSA0BRk= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= -github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/soheilhy/cmux v0.1.5 h1:jjzc5WVemNEDTLwv9tlmemhC73tI08BNOIGwBOo10Js= github.com/soheilhy/cmux v0.1.5/go.mod h1:T7TcVDs9LWfQgPlPsdngu6I6QIoyIFZDDC6sNE1GqG0= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= +github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= +github.com/spf13/afero v1.9.2/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y= github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY= github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= @@ -542,9 +1203,13 @@ github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/ github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= @@ -573,6 +1238,10 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= +github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= gitlab.com/yawning/bsaes.git v0.0.0-20190805113838-0a714cd429ec h1:FpfFs4EhNehiVfzQttTuxanPIT43FtkkCFypIod8LHo= gitlab.com/yawning/bsaes.git v0.0.0-20190805113838-0a714cd429ec/go.mod h1:BZ1RAoRPbCxum9Grlv5aeksu2H8BiKehBYooU2LFiOQ= go.etcd.io/bbolt v1.4.3 h1:dEadXpI6G79deX5prL3QRNP6JB8UxVkqo4UPnHaNXJo= @@ -596,6 +1265,9 @@ go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= +go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 h1:4Pp6oUg3+e/6M4C0A/3kJ2VYa++dsWVTtGgLVj5xtHg= @@ -616,6 +1288,9 @@ go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJj go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= +go.opentelemetry.io/proto/otlp v0.19.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= go.opentelemetry.io/proto/otlp v1.11.0 h1:5rrYs0Ykyj50sdU/JU0x8etU+LubXWb+gED6TbEdMIk= go.opentelemetry.io/proto/otlp v1.11.0/go.mod h1:SmVizdCOAm3XBtG1g1NnOdhW6jtddT72hLMhv8VwA8E= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= @@ -629,33 +1304,49 @@ go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9i go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= go.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60= go.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg= +go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI= +go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU= go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20180723164146-c126467f60eb/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= -golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190404164418-38d8ce5564a5/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191002040644-a1355ae1e2c3/go.mod h1:NOZ3BPKG0ec/BKJQgnvsSFpcKLM5xXVWnvZS97DWHgE= golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/exp v0.0.0-20220827204233-334a2380cb91/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= golang.org/x/exp v0.0.0-20250811191247-51f88131bc50 h1:3yiSh9fhy5/RhCSntf4Sy0Tnx50DmMpQ4MQdKKk4yg4= golang.org/x/exp v0.0.0-20250811191247-51f88131bc50/go.mod h1:rT6SFzZ7oxADUDx58pcaKFTcZ+inxAa9fTrYx/uVYwg= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200119044424-58c23975cae1/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200430140353-33d19683fad8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200618115811-c13761719519/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20201208152932-35266b937fa6/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20210607152325-775e3b0c77b9/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20211028202545-6944b10bf410/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20220302094943-723b81ca9867/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= @@ -666,6 +1357,8 @@ golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= @@ -674,7 +1367,15 @@ golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzB golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= golang.org/x/net v0.0.0-20150829230318-ea47fc708ee3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -682,7 +1383,6 @@ golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= @@ -690,7 +1390,6 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= -golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -711,12 +1410,38 @@ golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81R golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220617184016-355a448f1bc9/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221012135044-0b7e1fb9d458/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= +golang.org/x/net v0.4.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE= +golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -724,8 +1449,30 @@ golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4Iltr golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221006150949-b44042a4b9c1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.4.0/go.mod h1:RznEsdpjGAINPTOF0UH/t+xJ75L18YO3Ho6Pyn+uRec= +golang.org/x/oauth2 v0.5.0/go.mod h1:9/XBHVqLaWO3/BRHs5jbpYCnOZVjj5V0ndyaAM7KB4I= +golang.org/x/oauth2 v0.6.0/go.mod h1:ycmewcwgD4Rpr3eZJLSB4Kyyljb3qDh40vJ8STE5HKw= +golang.org/x/oauth2 v0.7.0/go.mod h1:hPLQkd9LyjfXTiRohC/41GhcFqxisoUQ99sCUOHO9x4= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -737,12 +1484,15 @@ golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -760,8 +1510,8 @@ golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -774,29 +1524,71 @@ golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210304124612-50617c2ba197/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= +golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA= +golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U= +golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -804,13 +1596,25 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= +golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20220922220347-f3bd1da661af/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0= golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -828,6 +1632,7 @@ golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgw golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190927191325-030b2cf1153e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -856,14 +1661,36 @@ golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roY golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= +golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201124115921-2c860bdd6e78/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.7.0/go.mod h1:4pg6aUX35JBAogB10C9AtvVL+qowtN4pT3CGSQex14s= golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE= golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= @@ -880,12 +1707,54 @@ google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0M google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= +google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= +google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= +google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= +google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= +google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= +google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo= +google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4= +google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw= +google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU= +google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k= +google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI= +google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I= +google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo= +google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g= +google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA= +google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8= +google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs= +google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.77.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw= +google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg= +google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o= +google.golang.org/api v0.85.0/go.mod h1:AqZf8Ep9uZ2pyTvgL+x0D3Zt0eoT9b5E8fmzfu6FO2g= +google.golang.org/api v0.90.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.93.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.95.0/go.mod h1:eADj+UBuxkh5zlrSntJghuNeg8HwQ1w5lTKkuqaETEI= +google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.99.0/go.mod h1:1YOf74vkVndF7pG6hIHuINsM7eWwpVTAfNMNiL91A08= +google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70= +google.golang.org/api v0.102.0/go.mod h1:3VFl6/fzoA+qNuS1N1/VfXY4LjoXN/wzeIp7TweWwGo= +google.golang.org/api v0.103.0/go.mod h1:hGtW6nK1AC+d9si/UBhw8Xli+QMOf6xyNAyJw4qU9w0= +google.golang.org/api v0.106.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.107.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.108.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.110.0/go.mod h1:7FC4Vvx1Mooxh8C5HWjzZHcavuS2f6pmJpZx60ca7iI= +google.golang.org/api v0.111.0/go.mod h1:qtFHvU9mhgTJegR31csQ+rwxyUTHOKFqCKWp1J0fdw0= +google.golang.org/api v0.114.0/go.mod h1:ifYI2ZsFK6/uGddGfAD5BMxlnkBqCmqHSDUVi45N5Yg= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= @@ -912,10 +1781,113 @@ google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfG google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A= +google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24= +google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w= +google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E= +google.golang.org/genproto v0.0.0-20220329172620-7be39ac1afc7/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220502173005-c8bf987b8c21/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220722212130-b98a9ff5e252/go.mod h1:GkXuJDJ6aQ7lnJcRF+SJVgFdQhypqgl3LB1C9vabdRE= +google.golang.org/genproto v0.0.0-20220801145646-83ce21fca29f/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc= +google.golang.org/genproto v0.0.0-20220815135757-37a418bb8959/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220817144833-d7fd3f11b9b1/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829144015-23454907ede3/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829175752-36a9c930ecbf/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220913154956-18f8339a66a5/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220914142337-ca0e39ece12f/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220915135415-7fd63a7952de/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220916172020-2692e8806bfa/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw= +google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U= +google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221024153911-1573dae28c9c/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221024183307-1bc688fe9f3e/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221027153422-115e99e71e1c/go.mod h1:CGI5F/G+E5bKwmfYo09AXuVN4dD894kIKUFmVbP2/Fo= +google.golang.org/genproto v0.0.0-20221109142239-94d6d90a7d66/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221114212237-e4508ebdbee1/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221117204609-8f9c96812029/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221118155620-16455021b5e6/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221201164419-0e50fba7f41c/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221201204527-e3fa12d562f3/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221202195650-67e5cbc046fd/go.mod h1:cTsE614GARnxrLsqKREzmNYJACSWWpAWdNMwnD7c2BE= +google.golang.org/genproto v0.0.0-20221227171554-f9683d7f8bef/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230112194545-e10362b5ecf9/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230113154510-dbe35b8444a5/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230123190316-2c411cf9d197/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230124163310-31e0e69b6fc2/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230125152338-dcaf20b6aeaa/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230127162408-596548ed4efa/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230216225411-c8e22ba71e44/go.mod h1:8B0gmkoRebU8ukX6HP+4wrVQUY1+6PkQ44BSyIlflHA= +google.golang.org/genproto v0.0.0-20230222225845-10f96fb3dbec/go.mod h1:3Dl5ZL0q0isWJt+FVcfpQyirqemEuLAK/iFvg1UP1Hw= +google.golang.org/genproto v0.0.0-20230223222841-637eb2293923/go.mod h1:3Dl5ZL0q0isWJt+FVcfpQyirqemEuLAK/iFvg1UP1Hw= +google.golang.org/genproto v0.0.0-20230303212802-e74f57abe488/go.mod h1:TvhZT5f700eVlTNwND1xoEZQeWTB2RY/65kplwl/bFA= +google.golang.org/genproto v0.0.0-20230306155012-7f2fa6fef1f4/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= +google.golang.org/genproto v0.0.0-20230320184635-7606e756e683/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= +google.golang.org/genproto v0.0.0-20230323212658-478b75c54725/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230330154414-c0448cd141ea/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230331144136-dcfb400f0633/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1/go.mod h1:nKE/iIaLqn2bQwXBg8f1g2Ylh6r5MN5CmZvuzZCgsCU= google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9 h1:9+tzLLstTlPTRyJTh+ah5wIMsBW5c4tQwGTN3thOW9Y= google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9/go.mod h1:mqHbVIp48Muh7Ywss/AD6I5kNVKZMmAa/QEW58Gxp2s= google.golang.org/genproto/googleapis/api v0.0.0-20260803160001-6ac0973c030d h1:FarXi840EJWSHYTN3ERkADbPWjl307+FGrA22KAVjjc= @@ -934,13 +1906,40 @@ google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKa google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= +google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= +google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= +google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.51.0/go.mod h1:wgNDFcnuBGmxLKI/qn4T+m5BtEBYXJPvibbUPsAIPww= +google.golang.org/grpc v1.52.3/go.mod h1:pu6fVzoFb+NBYNAvQL08ic+lvB2IojljRYuun5vorUY= +google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw= +google.golang.org/grpc v1.54.0/go.mod h1:PUSEXI6iWghWaB6lXM4knEgpJNu2qUcKfDtNci3EC2g= +google.golang.org/grpc v1.56.3/go.mod h1:I9bI3vqKfayGqPUAwGdOSu7kt6oIJLixfffKrpXqQ9s= google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= -gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= +google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/errgo.v1 v1.0.0/go.mod h1:CxwszS/Xz1C49Ucd2i6Zil5UToP1EmyrFhKaMVbg1mk= @@ -963,7 +1962,6 @@ gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= @@ -981,33 +1979,71 @@ honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWh honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -modernc.org/cc/v4 v4.21.4 h1:3Be/Rdo1fpr8GrQ7IVw9OHtplU4gWbb+wNgeoBMmGLQ= -modernc.org/cc/v4 v4.21.4/go.mod h1:HM7VJTZbUCR3rV8EYBi9wxnJ0ZBRiGE5OeGXNA0IsLQ= -modernc.org/ccgo/v4 v4.19.2 h1:lwQZgvboKD0jBwdaeVCTouxhxAyN6iawF3STraAal8Y= -modernc.org/ccgo/v4 v4.19.2/go.mod h1:ysS3mxiMV38XGRTTcgo0DQTeTmAO4oCmJl1nX9VFI3s= -modernc.org/fileutil v1.3.0 h1:gQ5SIzK3H9kdfai/5x41oQiKValumqNTDXMvKo62HvE= -modernc.org/fileutil v1.3.0/go.mod h1:XatxS8fZi3pS8/hKG2GH/ArUogfxjpEKs3Ku3aK4JyQ= -modernc.org/gc/v2 v2.4.1 h1:9cNzOqPyMJBvrUipmynX0ZohMhcxPtMccYgGOJdOiBw= -modernc.org/gc/v2 v2.4.1/go.mod h1:wzN5dK1AzVGoH6XOzc3YZ+ey/jPgYHLuVckd62P0GYU= -modernc.org/libc v1.55.3 h1:AzcW1mhlPNrRtjS5sS+eW2ISCgSOLLNyFzRh/V3Qj/U= -modernc.org/libc v1.55.3/go.mod h1:qFXepLhz+JjFThQ4kzwzOjA/y/artDeg+pcYnY+Q83w= -modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= -modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= -modernc.org/memory v1.8.0 h1:IqGTL6eFMaDZZhEWwcREgeMXYwmW83LYW8cROZYkg+E= -modernc.org/memory v1.8.0/go.mod h1:XPZ936zp5OMKGWPqbD3JShgd/ZoQ7899TUuQqxY+peU= -modernc.org/opt v0.1.3 h1:3XOZf2yznlhC+ibLltsDGzABUGVx8J6pnFMS3E4dcq4= +honnef.co/go/tools v0.1.3/go.mod h1:NgwopIslSNH47DimFoV78dnkksY2EFtX0ajyb3K/las= +modernc.org/cc/v3 v3.36.0/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/cc/v3 v3.36.2/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/cc/v3 v3.36.3/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/cc/v4 v4.29.2 h1:h6+9ciCnPKutf4I03CvheAvDLX7+IHlqR6Iy6J+cgd8= +modernc.org/cc/v4 v4.29.2/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= +modernc.org/ccgo/v3 v3.0.0-20220428102840-41399a37e894/go.mod h1:eI31LL8EwEBKPpNpA4bU1/i+sKOwOrQy8D87zWUcRZc= +modernc.org/ccgo/v3 v3.0.0-20220430103911-bc99d88307be/go.mod h1:bwdAnOoaIt8Ax9YdWGjxWsdkPcZyRPHqrOvJxaKAKGw= +modernc.org/ccgo/v3 v3.16.4/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ= +modernc.org/ccgo/v3 v3.16.6/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ= +modernc.org/ccgo/v3 v3.16.8/go.mod h1:zNjwkizS+fIFDrDjIAgBSCLkWbJuHF+ar3QRn+Z9aws= +modernc.org/ccgo/v3 v3.16.9/go.mod h1:zNMzC9A9xeNUepy6KuZBbugn3c0Mc9TeiJO4lgvkJDo= +modernc.org/ccgo/v4 v4.35.0 h1:F+TUsmw09QxLzmi3aeYYGxjAXarmZaKgj3mKQHNaA8w= +modernc.org/ccgo/v4 v4.35.0/go.mod h1:qrVGs9S3Sr2Ztcg9ve+kTAYMp5a3YvWjo+SoN06kJ5I= +modernc.org/ccorpus v1.11.6/go.mod h1:2gEUTrWqdpH2pXsmTM1ZkjeSrUWDpjMu2T6m29L/ErQ= +modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= +modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= +modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= +modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= +modernc.org/gc/v3 v3.1.5 h1:21ldfPfRYE31Tb7B3mwAK8gy1AxP4+dKjrOQPfqakoc= +modernc.org/gc/v3 v3.1.5/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= +modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= +modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= +modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM= +modernc.org/libc v0.0.0-20220428101251-2d5f3daf273b/go.mod h1:p7Mg4+koNjc8jkqwcoFBJx7tXkpj00G77X7A72jXPXA= +modernc.org/libc v1.16.0/go.mod h1:N4LD6DBE9cf+Dzf9buBlzVJndKr/iJHG97vGLHYnb5A= +modernc.org/libc v1.16.1/go.mod h1:JjJE0eu4yeK7tab2n4S1w8tlWd9MxXLRzheaRnAKymU= +modernc.org/libc v1.16.17/go.mod h1:hYIV5VZczAmGZAnG15Vdngn5HSF5cSkbvfz2B7GRuVU= +modernc.org/libc v1.16.19/go.mod h1:p7Mg4+koNjc8jkqwcoFBJx7tXkpj00G77X7A72jXPXA= +modernc.org/libc v1.17.0/go.mod h1:XsgLldpP4aWlPlsjqKRdHPqCxCjISdHfM/yeWC5GyW0= +modernc.org/libc v1.17.1/go.mod h1:FZ23b+8LjxZs7XtFMbSzL/EhPxNbfZbErxEHc7cbD9s= +modernc.org/libc v1.75.7 h1:o3DTP9/0p9pKmY2WCKQaySW6wIiZhNM7wc2lUoyhfew= +modernc.org/libc v1.75.7/go.mod h1:bO5o2ztHxBb2rjz0PgdHN0sSMw57CgxGFLZ3Qd/QpVQ= +modernc.org/mathutil v1.2.2/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/mathutil v1.4.1/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= +modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= +modernc.org/memory v1.1.1/go.mod h1:/0wo5ibyrQiaoUoH7f9D8dnglAmILJ5/cxZlRECf+Nw= +modernc.org/memory v1.2.0/go.mod h1:/0wo5ibyrQiaoUoH7f9D8dnglAmILJ5/cxZlRECf+Nw= +modernc.org/memory v1.2.1/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU= +modernc.org/memory v1.12.1 h1:nFMiWrpStgZczNl6XI9GnIk/rWhYIyHGUaR04pGbp9g= +modernc.org/memory v1.12.1/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= +modernc.org/opt v0.1.1/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= -modernc.org/sortutil v1.2.0 h1:jQiD3PfS2REGJNzNCMMaLSp/wdMNieTbKX920Cqdgqc= -modernc.org/sortutil v1.2.0/go.mod h1:TKU2s7kJMf1AE84OoiGppNHJwvB753OYfNl2WRb++Ss= -modernc.org/sqlite v1.34.5 h1:Bb6SR13/fjp15jt70CL4f18JIN7p7dnMExd+UFnF15g= -modernc.org/sqlite v1.34.5/go.mod h1:YLuNmX9NKs8wRNK2ko1LW1NGYcc9FkBO69JOt1AR9JE= -modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA= -modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0= +modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= +modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= +modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= +modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= +modernc.org/sqlite v1.18.1/go.mod h1:6ho+Gow7oX5V+OiOQ6Tr4xeqbx13UZ6t+Fw9IRUG4d4= +modernc.org/sqlite v1.59.0 h1:X1es1GpqBlS/5T+vbM4HLUdaa8OtQx468DF2vrx+38A= +modernc.org/sqlite v1.59.0/go.mod h1:+paeT2A3iPRHkQDwG7oA6Tk0zQd5woMEI8q7orfry8k= +modernc.org/strutil v1.1.1/go.mod h1:DE+MQQ/hjKBZS2zNInV5hhcipt5rLPWkmpbGeW5mmdw= +modernc.org/strutil v1.1.3/go.mod h1:MEHNA7PdEnEwLvspRMtWTNnp2nnyvMfkimT1NKNAGbw= +modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= +modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= +modernc.org/tcl v1.13.1/go.mod h1:XOLfOwzhkljL4itZkK6T72ckMgvj0BDsnKNdZVUOecw= +modernc.org/token v1.0.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= +modernc.org/z v1.5.1/go.mod h1:eWFB510QWW5Th9YGZT81s+LwvaAs3Q2yr4sP0rmLkv8= pgregory.net/rapid v1.2.0 h1:keKAYRcjm+e1F0oAuU5F5+YPAWcyxNNRK2wud503Gnk= pgregory.net/rapid v1.2.0/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= +rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q= diff --git a/internal/assetpolicy/tapd_version.go b/internal/assetpolicy/tapd_version.go new file mode 100644 index 000000000..f996a976c --- /dev/null +++ b/internal/assetpolicy/tapd_version.go @@ -0,0 +1,142 @@ +package policy + +import ( + "context" + "errors" + "fmt" + "strconv" + "strings" + + "github.com/lightninglabs/taproot-assets/taprpc" + "google.golang.org/grpc" +) + +// MinOnchainSwapTapdVersion is the oldest tapd release that may create new +// on-chain asset swap addresses or verify an untrusted HTLC/deposit history. +// Local transaction and witness builders remain available for recovery of +// existing contracts; this does not implement an application recovery manager. +// +// Taproot Assets v0.8.8 fixes a regression introduced in v0.8.6 that +// could prevent asset invoices from settling. New on-chain swaps rely on +// that fix as well as tapd's activation and Taproot proof validation. +const MinOnchainSwapTapdVersion = "0.8.8" + +// ErrTapdVersionUnsupported is returned when tapd is older than +// MinOnchainSwapTapdVersion or reports a version that cannot be parsed. +var ErrTapdVersionUnsupported = errors.New("unsupported tapd version") + +// tapdVersion is the release number of a tapd version. +type tapdVersion struct { + major uint64 + minor uint64 + patch uint64 + qualifier string +} + +// String returns the release number in its vMAJOR.MINOR.PATCH form. +func (v tapdVersion) String() string { + release := fmt.Sprintf("v%d.%d.%d", v.major, v.minor, v.patch) + if v.qualifier != "" { + return release + "-" + v.qualifier + } + return release +} + +// atLeast returns true if the release number is not older than other. +func (v tapdVersion) atLeast(other tapdVersion) bool { + if v.major != other.major { + return v.major > other.major + } + if v.minor != other.minor { + return v.minor > other.minor + } + + if v.patch != other.patch { + return v.patch > other.patch + } + // The v0.8.8 release identifies itself as 0.8.8-alpha. + return v.qualifier == "" || v.qualifier == "alpha" +} + +// parseTapdVersion parses the release number of a version string as tapd +// reports it in GetInfo, such as "0.8.8-alpha commit=v0.8.8". +func parseTapdVersion(version string) (tapdVersion, bool) { + fields := strings.Fields(version) + if len(fields) == 0 { + return tapdVersion{}, false + } + + release, qualifier, _ := strings.Cut(strings.TrimPrefix(fields[0], "v"), "-") + parts := strings.Split(release, ".") + if len(parts) != 3 { + return tapdVersion{}, false + } + + var numbers [3]uint64 + for idx, part := range parts { + number, err := strconv.ParseUint(part, 10, 32) + if err != nil { + return tapdVersion{}, false + } + numbers[idx] = number + } + + return tapdVersion{ + major: numbers[0], + minor: numbers[1], + patch: numbers[2], + qualifier: qualifier, + }, true +} + +// CheckOnchainSwapTapdVersion returns an error wrapping +// ErrTapdVersionUnsupported unless the version that tapd reports in GetInfo is +// at least MinOnchainSwapTapdVersion. +func CheckOnchainSwapTapdVersion(version string) error { + floor, ok := parseTapdVersion(MinOnchainSwapTapdVersion) + if !ok { + return fmt.Errorf("invalid minimum tapd version %q", + MinOnchainSwapTapdVersion) + } + + actual, ok := parseTapdVersion(version) + if !ok { + return fmt.Errorf("%w: cannot parse %q", ErrTapdVersionUnsupported, + version) + } + if !actual.atLeast(floor) { + return fmt.Errorf("%w: %v is older than %v", + ErrTapdVersionUnsupported, actual, floor) + } + + return nil +} + +// TapdInfoClient is the tapd boundary needed to check the running verifier and +// address backend, independently of any module version used to build a caller. +type TapdInfoClient interface { + GetInfo(context.Context, *taprpc.GetInfoRequest, + ...grpc.CallOption) (*taprpc.GetInfoResponse, error) +} + +// RequireOnchainSwapTapd checks the running backend immediately before an +// address-creation or untrusted-history acceptance operation. It is not a +// daemon-wide startup gate: ordinary asset payments and local recovery +// signing do not use this boundary. +func RequireOnchainSwapTapd(ctx context.Context, client TapdInfoClient) error { + if client == nil { + return fmt.Errorf("%w: tapd client is required", + ErrTapdVersionUnsupported) + } + + info, err := client.GetInfo(ctx, &taprpc.GetInfoRequest{}) + if err != nil { + return fmt.Errorf("unable to get tapd version: %w", err) + } + if info == nil { + return fmt.Errorf("%w: tapd returned no version", + ErrTapdVersionUnsupported) + } + + return CheckOnchainSwapTapdVersion(info.Version) +} diff --git a/internal/assetpolicy/tapd_version_test.go b/internal/assetpolicy/tapd_version_test.go new file mode 100644 index 000000000..6ddf9da8a --- /dev/null +++ b/internal/assetpolicy/tapd_version_test.go @@ -0,0 +1,71 @@ +package policy + +import ( + "context" + "errors" + "testing" + + "github.com/lightninglabs/taproot-assets/taprpc" + "github.com/stretchr/testify/require" + "google.golang.org/grpc" +) + +type infoClient struct { + response *taprpc.GetInfoResponse + err error +} + +func (c infoClient) GetInfo(context.Context, *taprpc.GetInfoRequest, + ...grpc.CallOption) (*taprpc.GetInfoResponse, error) { + + return c.response, c.err +} + +// TestRequireOnchainSwapTapd fails closed when the running backend's version +// is unavailable, malformed, or older than the required verifier. +func TestRequireOnchainSwapTapd(t *testing.T) { + rpcErr := errors.New("tapd unavailable") + for _, test := range []struct { + name string + client infoClient + err error + }{ + { + name: "minimum", + client: infoClient{response: &taprpc.GetInfoResponse{ + Version: "0.8.8-alpha", + }}, + }, + { + name: "older verifier", + client: infoClient{response: &taprpc.GetInfoResponse{ + Version: "0.8.7-alpha", + }}, + err: ErrTapdVersionUnsupported, + }, + { + name: "unparseable", + client: infoClient{response: &taprpc.GetInfoResponse{ + Version: "unknown", + }}, + err: ErrTapdVersionUnsupported, + }, + { + name: "missing response", + err: ErrTapdVersionUnsupported, + }, + { + name: "RPC failure", client: infoClient{err: rpcErr}, + err: rpcErr, + }, + } { + t.Run(test.name, func(t *testing.T) { + err := RequireOnchainSwapTapd(t.Context(), test.client) + if test.err == nil { + require.NoError(t, err) + return + } + require.ErrorIs(t, err, test.err) + }) + } +} diff --git a/loopd/daemon.go b/loopd/daemon.go index 530514d30..36164ce5d 100644 --- a/loopd/daemon.go +++ b/loopd/daemon.go @@ -487,6 +487,15 @@ func (d *Daemon) initialize(withMacaroonService bool) error { } infof("Using asset client with version %v", getInfo.Version) + + // The shared kit checks its running backend before address + // creation and full-history proof acceptance. This warning is + // informational; no on-chain asset swap manager is wired here. + err = assets.CheckOnchainSwapTapdVersion(getInfo.Version) + if err != nil { + warnf("Shared asset kit address creation and proof "+ + "acceptance require an upgraded tapd: %v", err) + } } // Create an instance of the loop client library. diff --git a/swapkit/asset_types.go b/swapkit/asset_types.go new file mode 100644 index 000000000..aad7dee9c --- /dev/null +++ b/swapkit/asset_types.go @@ -0,0 +1,10 @@ +package swapkit + +import ( + "errors" +) + +var ( + ErrInvalid = errors.New("invalid asset transaction") + ErrPending = errors.New("asset transaction pending") +) diff --git a/swapkit/tapsdk/asset.go b/swapkit/tapsdk/asset.go new file mode 100644 index 000000000..7cedffd98 --- /dev/null +++ b/swapkit/tapsdk/asset.go @@ -0,0 +1,106 @@ +package tapsdk + +import ( + "bytes" + + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/txscript" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/asset" +) + +// LegacyOPTrueDescriptor returns the unchanged NUMS/single-OP_TRUE asset tree. +// Keys are x-only at the asset boundary. The control block retains the actual +// tweaked output parity, and every returned byte slice is independently owned. +func LegacyOPTrueDescriptor() (sdk.ScriptKey, + *sdk.CustomAssetOPTrueSpendInfo, error) { + + internal := *asset.NUMSPubKey + leaf := txscript.NewBaseTapLeaf([]byte{txscript.OP_TRUE}) + tree := txscript.AssembleTaprootScriptTree(leaf) + root := tree.RootNode.TapHash() + output := txscript.ComputeTaprootOutputKey(&internal, root[:]) + even, err := schnorr.ParsePubKey(schnorr.SerializePubKey(output)) + if err != nil { + return sdk.ScriptKey{}, nil, err + } + key, err := sdk.ParsePubKey(even.SerializeCompressed()) + if err != nil { + return sdk.ScriptKey{}, nil, err + } + raw, err := sdk.ParsePubKey(internal.SerializeCompressed()) + if err != nil { + return sdk.ScriptKey{}, nil, err + } + control := tree.LeafMerkleProofs[0].ToControlBlock(&internal) + encoded, err := control.ToBytes() + if err != nil { + return sdk.ScriptKey{}, nil, err + } + spend := &sdk.CustomAssetOPTrueSpendInfo{ + LeafScript: bytes.Clone(leaf.Script), + LeafVersion: uint8(leaf.LeafVersion), + ControlBlock: encoded, InternalKey: raw, + } + if err := spend.Validate(key); err != nil { + return sdk.ScriptKey{}, nil, err + } + return sdk.ScriptKey{PubKey: key, + KeyDesc: sdk.KeyDescriptor{RawKeyBytes: raw}, + TapTweak: bytes.Clone(root[:])}, spend, nil +} + +// LegacyOPTrueOutput binds an allocation to the existing asset script policy. +// Native SDK External mode preserves the exact key and derivation. No wallet +// key or asset-ID leaf is added; selecting SDKOPTrueOutput is a separate choice. +func LegacyOPTrueOutput(output sdk.CustomAssetOutput, + anchor swapkit.AnchorPlan) (sdk.CustomAssetOutput, error) { + + key, _, err := LegacyOPTrueDescriptor() + if err != nil { + return sdk.CustomAssetOutput{}, err + } + output.Script = sdk.CustomAssetScriptPlan{ + Mode: sdk.CustomAssetScriptExternal, + External: &sdk.CustomAssetExternalScriptPlan{ScriptKey: key}, + } + output.Anchor = AnchorPlan(anchor) + return output, nil +} + +// SDKOPTrueOutput explicitly selects the SDK's supplied-key/asset-ID tree. +// Existing funded outputs always retain their saved key and witness instead. +func SDKOPTrueOutput(output sdk.CustomAssetOutput, key sdk.KeyDescriptor, + anchor swapkit.AnchorPlan) sdk.CustomAssetOutput { + + return OPTrueOutput(output, key, anchor) +} + +// OPTrueSpendInfo validates a saved SDK descriptor or reconstructs only the +// exact legacy External tree. An ordinary wallet External key is never treated +// as OP_TRUE, and native sealed package summaries are never modified. +func OPTrueSpendInfo(output sdk.CustomAnchorAssetOutputSummary) ( + *sdk.CustomAssetOPTrueSpendInfo, error) { + + if output.OPTrueSpend != nil { + if err := output.OPTrueSpend.Validate(output.ScriptKey); err != nil { + return nil, err + } + return output.OPTrueSpend.Clone(), nil + } + if output.ScriptMode != sdk.CustomAssetScriptExternal { + return nil, swapkit.ErrInvalid + } + key, spend, err := LegacyOPTrueDescriptor() + if err != nil { + return nil, err + } + if !bytes.Equal(key.PubKey[1:], output.ScriptKey[1:]) { + return nil, swapkit.ErrInvalid + } + if err := spend.Validate(output.ScriptKey); err != nil { + return nil, err + } + return spend, nil +} diff --git a/swapkit/tapsdk/asset_test.go b/swapkit/tapsdk/asset_test.go new file mode 100644 index 000000000..aa9eb6b7b --- /dev/null +++ b/swapkit/tapsdk/asset_test.go @@ -0,0 +1,119 @@ +package tapsdk + +import ( + "encoding/hex" + "testing" + + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +// These vectors freeze the pre-SDK NUMS/single-OP_TRUE contract. A dependency +// upgrade or a fresh wallet locator must not change existing asset ownership. +func TestLegacyOPTruePolicy(t *testing.T) { + key, spend, err := LegacyOPTrueDescriptor() + require.NoError(t, err) + require.Equal( + t, + "027bbbb85ff774141ee36c2cc9f38b40be4a02c2a156c8a1def8781cf39177deca", + hex.EncodeToString(key.PubKey[:]), + ) + require.Equal( + t, + "a85b2107f791b26a84e7586c28cec7cb61202ed3d01944d832500f363782d675", + hex.EncodeToString(key.TapTweak), + ) + require.Equal( + t, + "c17c79b9b26e463895eef5679d8558942c86c4ad2233adef01bc3e6d540b3653fe", + hex.EncodeToString(spend.ControlBlock), + ) + require.Zero(t, key.KeyDesc.KeyLocator) + require.NoError(t, spend.Validate(key.PubKey)) + external := sdk.CustomAnchorAssetOutputSummary{ + ScriptMode: sdk.CustomAssetScriptExternal, + ScriptKey: key.PubKey, + } + restored, err := OPTrueSpendInfo(external) + require.NoError(t, err) + require.Equal(t, spend, restored) + // The policy changes require explicit selection; nil ordinary wallet + // descriptors cannot be promoted into public asset witnesses. + external.ScriptKey = testKey(t, 12) + _, err = OPTrueSpendInfo(external) + require.Error(t, err) + external.ScriptKey = key.PubKey + external.ScriptMode = sdk.CustomAssetScriptWallet + _, err = OPTrueSpendInfo(external) + require.Error(t, err) + external.ScriptMode = sdk.CustomAssetScriptExternal + external.OPTrueSpend = spend.Clone() + external.OPTrueSpend.ControlBlock[0] ^= 1 + _, err = OPTrueSpendInfo(external) + require.Error(t, err) + // Returned descriptors never share mutable tweak or witness storage. + key.TapTweak[0] ^= 1 + spend.ControlBlock[0] ^= 1 + fresh, freshSpend, err := LegacyOPTrueDescriptor() + require.NoError(t, err) + require.NotEqual(t, key.TapTweak, fresh.TapTweak) + require.NotEqual(t, spend.ControlBlock, freshSpend.ControlBlock) +} + +func TestNativeLegacyAndExplicitSDKPolicies(t *testing.T) { + for _, explicit := range []bool{false, true} { + name := "legacy default" + if explicit { + name = "explicit SDK tree" + } + t.Run(name, func(t *testing.T) { + fixture := newCustomAnchorBuilderFixture(t) + kit, err := swapkit.NewSwapKit(swapKitTestParams(t)) + require.NoError(t, err) + if explicit { + fixture.request.Outputs[0] = SDKOPTrueOutput( + fixture.request.Outputs[0], + sdk.KeyDescriptor{ + RawKeyBytes: testKey(t, 13), + }, + kit.AnchorPlan(), + ) + } else { + fixture.request.Outputs[0], err = LegacyOPTrueOutput(fixture.request.Outputs[0], kit.AnchorPlan()) + require.NoError(t, err) + } + wallet := sdk.NewWallet( + fixture.client, + sdk.NetworkRegtest, + ) + plan, err := wallet.NewCustomAnchorTxBuilder(). + Build(t.Context(), fixture.request) + require.NoError(t, err) + out := plan.Outputs()[0] + summary := sdk.CustomAnchorAssetOutputSummary{ + ScriptKey: out.ScriptKey, + ScriptMode: out.ScriptMode, + OPTrueSpend: out.OPTrueSpend, + } + spend, err := OPTrueSpendInfo(summary) + require.NoError(t, err) + require.NoError(t, spend.Validate(out.ScriptKey)) + key, _, err := LegacyOPTrueDescriptor() + require.NoError(t, err) + if explicit { + require.Equal( + t, + sdk.CustomAssetScriptOPTrue, + out.ScriptMode, + ) + require.NotEqual(t, key.PubKey, out.ScriptKey) + require.NotNil(t, out.OPTrueSpend) + } else { + require.Equal(t, sdk.CustomAssetScriptExternal, out.ScriptMode) + require.Equal(t, key.PubKey, out.ScriptKey) + require.Nil(t, out.OPTrueSpend) + } + }) + } +} diff --git a/swapkit/tapsdk/binding_test.go b/swapkit/tapsdk/binding_test.go new file mode 100644 index 000000000..2bf489a73 --- /dev/null +++ b/swapkit/tapsdk/binding_test.go @@ -0,0 +1,7 @@ +package tapsdk + +import ( + sdk "github.com/lightninglabs/tap-sdk" +) + +func fixtureNodeInfo() *sdk.Info { return &sdk.Info{Version: "0.8.8", Network: "regtest"} } diff --git a/swapkit/tapsdk/builder_fixture_test.go b/swapkit/tapsdk/builder_fixture_test.go new file mode 100644 index 000000000..90ffd98ea --- /dev/null +++ b/swapkit/tapsdk/builder_fixture_test.go @@ -0,0 +1,128 @@ +package tapsdk + +import ( + "bytes" + "context" + _ "embed" + "encoding/json" + "fmt" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr/musig2" + "github.com/btcsuite/btcd/txscript" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +// builderFixtureJSON is the SDK's deterministic minted-proof and caller-funded +// anchor fixture, exported through public request and verification types. This +// freezes input bytes while the real builder derives each new kit commitment. +// +//go:embed testdata/builder_request.json +var builderFixtureJSON []byte + +type builderFixtureClient struct { + sdk.Client + + raw []byte + verified *sdk.VerifyProofResponse + verifyCalls int + afterVerify func() +} + +func (c *builderFixtureClient) VerifyProof(_ context.Context, raw []byte) ( + *sdk.VerifyProofResponse, error) { + + if !bytes.Equal(c.raw, raw) { + return nil, fmt.Errorf("unexpected proof fixture") + } + c.verifyCalls++ + if c.afterVerify != nil { + c.afterVerify() + } + return c.verified, nil +} + +func (c *builderFixtureClient) QueryScriptKey(_ context.Context, + key []byte) (*sdk.ScriptKey, error) { + + // The frozen SDK proof fixture is minted to the scalar-one BIP86 key. + private, _ := btcec.PrivKeyFromBytes([]byte{1}) + output, err := sdk.ParsePubKey(txscript.ComputeTaprootKeyNoScript( + private.PubKey(), + ).SerializeCompressed()) + if err != nil { + return nil, err + } + if !bytes.Equal(key, output[1:]) { + return nil, fmt.Errorf("unexpected script key fixture") + } + raw, err := sdk.ParsePubKey(private.PubKey().SerializeCompressed()) + if err != nil { + return nil, err + } + return &sdk.ScriptKey{ + PubKey: output, KeyDesc: sdk.KeyDescriptor{RawKeyBytes: raw}, + }, nil +} + +type builderFixture struct { + request *sdk.CustomAnchorRequest + client *builderFixtureClient +} + +func newCustomAnchorBuilderFixture(t *testing.T) *builderFixture { + t.Helper() + //nolint:tagliatelle // Retain the SDK fixture's serialized field names. + var fixture struct { + Request *sdk.CustomAnchorRequest `json:"Request"` + Verified *sdk.VerifyProofResponse `json:"Verified"` + } + // Preserve the existing SDK/contract JSON field names. + //nolint:musttag + require.NoError(t, json.Unmarshal(builderFixtureJSON, &fixture)) + require.NotNil(t, fixture.Request) + require.Len(t, fixture.Request.Inputs, 1) + return &builderFixture{ + request: fixture.Request, + client: &builderFixtureClient{ + raw: fixture.Request.Inputs[0].ProofFile, + verified: fixture.Verified, + }, + } +} + +func testKey(t *testing.T, scalar byte) sdk.PubKey { + t.Helper() + key, _ := btcec.PrivKeyFromBytes([]byte{scalar}) + pub, err := sdk.ParsePubKey(key.PubKey().SerializeCompressed()) + require.NoError(t, err) + return pub +} + +func validateMuSig2Aggregate(expected sdk.XOnlyPubKey, + participants []sdk.PubKey) error { + + keys := make([]*btcec.PublicKey, len(participants)) + for i, key := range participants { + parsed, err := btcec.ParsePubKey(key[:]) + if err != nil { + return err + } + keys[i] = parsed + } + aggregate, _, _, err := musig2.AggregateKeys(keys, false) + if err != nil { + return err + } + actual := aggregate.FinalKey.SerializeCompressed()[1:] + if !bytes.Equal(expected[:], actual) { + return fmt.Errorf("aggregate key mismatch") + } + return nil +} + +func (c *builderFixtureClient) GetInfo(context.Context) (*sdk.Info, error) { + return fixtureNodeInfo(), nil +} diff --git a/swapkit/tapsdk/client.go b/swapkit/tapsdk/client.go new file mode 100644 index 000000000..f30a9b1b4 --- /dev/null +++ b/swapkit/tapsdk/client.go @@ -0,0 +1,108 @@ +package tapsdk + +import ( + "context" + "time" + + sdk "github.com/lightninglabs/tap-sdk" + sdkgrpc "github.com/lightninglabs/tap-sdk/grpc" + "google.golang.org/grpc" + "google.golang.org/grpc/metadata" +) + +const defaultClientTimeout = 30 * time.Second + +// anchorWalletClient preserves the SDK's optional custom-anchor operations. +type anchorWalletClient interface { + sdk.WalletKitClient + sdk.CustomAnchorWalletKitClient + sdk.CustomAnchorCapabilityProvider +} + +// issuanceProofClient preserves registration of a specific grouped issuance. +type issuanceProofClient interface { + sdk.ProofClient + + RegisterTransferWithIssuance(context.Context, sdk.AssetRef, sdk.AssetID, + sdk.PubKey, sdk.Outpoint) (*sdk.RegisteredAsset, error) +} + +// connectionClient composes the released SDK clients without owning their +// shared connection. All RPC encoding and asset operations remain in the SDK. +type connectionClient struct { + sdk.WalletClient + anchorWalletClient + issuanceProofClient + sdk.UniverseClient + sdk.MintClient + sdk.EventClient +} + +// NewClientFromConn adapts an existing authenticated tapd connection to the SDK. +// The caller owns transport security, credentials, message limits and connection +// shutdown. Closing the returned client leaves that connection open. Non-positive +// timeouts use 30 seconds; streaming calls retain the caller's context lifetime. +func NewClientFromConn(conn grpc.ClientConnInterface, + timeout time.Duration) sdk.Client { + + if timeout <= 0 { + timeout = defaultClientTimeout + } + conn = credentialConn{ClientConnInterface: conn} + + return &connectionClient{ + WalletClient: sdkgrpc.NewWalletClient(conn, timeout, ""), + anchorWalletClient: sdkgrpc.NewWalletKitClient( + conn, timeout, "", + ), + issuanceProofClient: sdkgrpc.NewProofClient(conn, timeout, ""), + UniverseClient: sdkgrpc.NewUniverseClient(conn, timeout, ""), + MintClient: sdkgrpc.NewMintClient(conn, timeout, ""), + EventClient: sdkgrpc.NewEventClient( + conn, timeout, "", "", + ), + } +} + +// Close leaves the caller-owned connection open. +func (*connectionClient) Close() error { + return nil +} + +// credentialConn removes the empty macaroon appended by SDK v0.1.1. The +// existing context metadata and connection credentials remain authoritative. +type credentialConn struct { + grpc.ClientConnInterface +} + +func (c credentialConn) Invoke(ctx context.Context, method string, + args, reply any, opts ...grpc.CallOption) error { + + return c.ClientConnInterface.Invoke( + withoutSDKMacaroon(ctx), method, args, reply, opts..., + ) +} + +func (c credentialConn) NewStream(ctx context.Context, desc *grpc.StreamDesc, + method string, opts ...grpc.CallOption) (grpc.ClientStream, error) { + + return c.ClientConnInterface.NewStream( + withoutSDKMacaroon(ctx), desc, method, opts..., + ) +} + +// withoutSDKMacaroon removes only the SDK's trailing empty credential. The +// metadata returned by FromOutgoingContext is a copy, so the caller is unchanged. +func withoutSDKMacaroon(ctx context.Context) context.Context { + md, _ := metadata.FromOutgoingContext(ctx) + values := md.Get("macaroon") + if len(values) == 0 || values[len(values)-1] != "" { + return ctx + } + if len(values) == 1 { + delete(md, "macaroon") + } else { + md.Set("macaroon", values[:len(values)-1]...) + } + return metadata.NewOutgoingContext(ctx, md) +} diff --git a/swapkit/tapsdk/client_test.go b/swapkit/tapsdk/client_test.go new file mode 100644 index 000000000..14eb3830d --- /dev/null +++ b/swapkit/tapsdk/client_test.go @@ -0,0 +1,207 @@ +package tapsdk + +import ( + "context" + "errors" + "testing" + "time" + + tapsdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/taprpc" + "github.com/stretchr/testify/require" + grpcpkg "google.golang.org/grpc" + "google.golang.org/grpc/connectivity" + "google.golang.org/grpc/credentials/insecure" + "google.golang.org/grpc/metadata" +) + +type connectionProbe struct { + invoke func(context.Context, string, any, any) error + stream func(context.Context, string) error +} + +func (c *connectionProbe) Invoke(ctx context.Context, method string, + args, reply any, _ ...grpcpkg.CallOption) error { + + return c.invoke(ctx, method, args, reply) +} + +func (c *connectionProbe) NewStream(ctx context.Context, + _ *grpcpkg.StreamDesc, method string, _ ...grpcpkg.CallOption) ( + grpcpkg.ClientStream, error) { + + return nil, c.stream(ctx, method) +} + +func TestClientFromConnCapabilities(t *testing.T) { + t.Parallel() + + wallet := tapsdk.NewWallet( + NewClientFromConn(nil, time.Second), tapsdk.NetworkRegtest, + ) + _, ok := wallet.Client().(tapsdk.CustomAnchorWalletKitClient) + require.True(t, ok) + + caps, err := wallet.CustomAnchorCapabilities(t.Context()) + require.NoError(t, err) + require.Equal(t, tapsdk.DefaultTapdCustomAnchorCapabilities(), *caps) + + _, ok = wallet.Client().(interface { + RegisterTransferWithIssuance(context.Context, tapsdk.AssetRef, + tapsdk.AssetID, tapsdk.PubKey, tapsdk.Outpoint) ( + *tapsdk.RegisteredAsset, error) + }) + require.True(t, ok, "grouped imports require issuance registration") + require.NoError(t, wallet.Close()) +} + +func TestClientFromConnGroupedRegistration(t *testing.T) { + t.Parallel() + + group := testKey(t, 1) + + ref := tapsdk.AssetRefFromGroupKey(group) + issuance := tapsdk.AssetID{1} + point := tapsdk.Outpoint{Txid: tapsdk.Hash{2}, Index: 3} + called := false + conn := &connectionProbe{ + invoke: func(_ context.Context, method string, + args, reply any) error { + + called = true + require.Equal(t, "/taprpc.TaprootAssets/RegisterTransfer", + method) + req, ok := args.(*taprpc.RegisterTransferRequest) + require.True(t, ok) + require.Equal(t, issuance[:], req.AssetId) + require.Equal(t, group[:], req.GroupKey) + require.Equal(t, group[:], req.ScriptKey) + require.Equal(t, point.Txid[:], req.Outpoint.Txid) + require.Equal(t, point.Index, req.Outpoint.OutputIndex) + + resp, ok := reply.(*taprpc.RegisterTransferResponse) + require.True(t, ok) + resp.RegisteredAsset = &taprpc.Asset{ + Amount: 1_000, + AssetGenesis: &taprpc.GenesisInfo{ + AssetId: issuance[:], + }, + ScriptKey: group[:], + ChainAnchor: &taprpc.AnchorInfo{ + AnchorOutpoint: point.String(), + }, + } + return nil + }, + } + client := NewClientFromConn(conn, time.Second) + proofs := client.(issuanceProofClient) + registered, err := proofs.RegisterTransferWithIssuance( + t.Context(), ref, issuance, group, point, + ) + require.NoError(t, err) + require.True(t, called) + require.Equal(t, issuance, registered.IssuanceID) + require.Equal(t, ref, registered.AssetRef) + require.Equal(t, point, registered.Outpoint) + require.Equal(t, uint64(1_000), registered.Amount) +} + +func TestClientFromConnAuthentication(t *testing.T) { + t.Parallel() + + for _, supplied := range []bool{false, true} { + name := "connection credentials" + if supplied { + name = "context credentials" + } + t.Run(name, func(t *testing.T) { + t.Parallel() + + original := metadata.Pairs("trace", "transfer") + if supplied { + original.Set("macaroon", "credential") + } + ctx := metadata.NewOutgoingContext(t.Context(), original) + check := func(ctx context.Context) { + md, _ := metadata.FromOutgoingContext(ctx) + require.Equal(t, original, md) + } + streamErr := errors.New("stream intercepted") + conn := &connectionProbe{ + invoke: func(ctx context.Context, _ string, + _, reply any) error { + + check(ctx) + require.IsType(t, &taprpc.GetInfoResponse{}, reply) + return nil + }, + stream: func(ctx context.Context, _ string) error { + check(ctx) + return streamErr + }, + } + client := NewClientFromConn(conn, time.Second) + _, err := client.GetInfo(ctx) + require.NoError(t, err) + + _, _, err = client.SubscribeReceiveEvents( + ctx, &tapsdk.SubscribeReceiveEventsRequest{}, + ) + require.ErrorIs(t, err, streamErr) + md, _ := metadata.FromOutgoingContext(ctx) + require.Equal(t, original, md) + }) + } +} + +func TestClientFromConnTimeout(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + timeout time.Duration + want time.Duration + }{ + {name: "default", want: defaultClientTimeout}, + {name: "negative", timeout: -1, want: defaultClientTimeout}, + {name: "explicit", timeout: time.Second, want: time.Second}, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + t.Parallel() + + conn := &connectionProbe{ + invoke: func(ctx context.Context, _ string, + _, _ any) error { + + deadline, ok := ctx.Deadline() + require.True(t, ok) + require.InDelta(t, test.want.Seconds(), + time.Until(deadline).Seconds(), 1) + return nil + }, + } + client := NewClientFromConn(conn, test.timeout) + _, err := client.GetInfo(t.Context()) + require.NoError(t, err) + }) + } +} + +func TestClientConnectionOwnership(t *testing.T) { + t.Parallel() + + conn, err := grpcpkg.NewClient( + "passthrough:///unused", + grpcpkg.WithTransportCredentials(insecure.NewCredentials()), + ) + require.NoError(t, err) + t.Cleanup(func() { require.NoError(t, conn.Close()) }) + + wallet := tapsdk.NewWallet( + NewClientFromConn(conn, time.Second), tapsdk.NetworkRegtest, + ) + require.NoError(t, wallet.Close()) + require.NotEqual(t, connectivity.Shutdown, conn.GetState()) +} diff --git a/swapkit/tapsdk/proof_tlv_test.go b/swapkit/tapsdk/proof_tlv_test.go new file mode 100644 index 000000000..3b52f780d --- /dev/null +++ b/swapkit/tapsdk/proof_tlv_test.go @@ -0,0 +1,53 @@ +package tapsdk + +import ( + "bytes" + "crypto/sha256" + "encoding/binary" + "math" + "strconv" + "testing" + + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightningnetwork/lnd/tlv" + "github.com/stretchr/testify/require" +) + +// TestAssetProofPathMalformedRecordLength rejects truncated TLV records without +// allocating their declared length. The proof file itself fits comfortably +// within the proof-path budget, including its valid checksum. +func TestAssetProofPathMalformedRecordLength(t *testing.T) { + for _, length := range []uint64{math.MaxInt64, math.MaxUint64} { + t.Run(strconv.FormatUint(length, 10), func(t *testing.T) { + var raw bytes.Buffer + raw.Write(proof.PrefixMagicBytes[:]) + var scratch [8]byte + require.NoError(t, tlv.WriteVarInt(&raw, 65535, &scratch)) + require.NoError(t, tlv.WriteVarInt(&raw, length, &scratch)) + + var file bytes.Buffer + file.Write(proof.FilePrefixMagicBytes[:]) + require.NoError(t, binary.Write( + &file, binary.BigEndian, uint32(proof.V0), + )) + require.NoError(t, tlv.WriteVarInt(&file, 1, &scratch)) + require.NoError(t, tlv.WriteVarInt( + &file, uint64(raw.Len()), &scratch, + )) + file.Write(raw.Bytes()) + var previous [sha256.Size]byte + hash := sha256.New() + hash.Write(previous[:]) + hash.Write(raw.Bytes()) + file.Write(hash.Sum(nil)) + + path := &sdk.AssetProofPath{ConfirmedBaseProof: file.Bytes()} + var err error + require.NotPanics(t, func() { + err = path.Validate() + }) + require.ErrorIs(t, err, sdk.ErrAssetProofPathInvalid) + }) + } +} diff --git a/swapkit/tapsdk/swapkit.go b/swapkit/tapsdk/swapkit.go new file mode 100644 index 000000000..a1b38dec4 --- /dev/null +++ b/swapkit/tapsdk/swapkit.go @@ -0,0 +1,74 @@ +// Package tapsdk connects Loop asset contracts and node services to the +// Taproot Assets SDK. Swap policy remains owned by Loop's swapkit package. +package tapsdk + +import ( + "bytes" + + "github.com/btcsuite/btcd/txscript" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" +) + +// AnchorPlan converts a Loop Bitcoin contract into an SDK output plan. +func AnchorPlan(plan swapkit.AnchorPlan) sdk.CustomAnchorOutputPlan { + leaves := make([]sdk.TapLeaf, len(plan.Leaves)) + for i := range plan.Leaves { + leaves[i] = sdk.TapLeaf{Script: bytes.Clone(plan.Leaves[i])} + } + return sdk.CustomAnchorOutputPlan{ + InternalKey: sdk.InternalKey{ + PubKey: sdk.PubKey(plan.InternalKey), + }, + Tapscript: sdk.CustomAnchorTapscriptPlan{TapLeaves: leaves}, + } +} + +// OPTrueOutput explicitly selects the SDK supplied-key/asset-ID asset tree. +// Use LegacyOPTrueOutput for the unchanged fixed NUMS policy. +// The SDK builder validates the complete output and creates its asset witness. +func OPTrueOutput(output sdk.CustomAssetOutput, key sdk.KeyDescriptor, + anchor swapkit.AnchorPlan) sdk.CustomAssetOutput { + + output.Script = sdk.CustomAssetScriptPlan{ + Mode: sdk.CustomAssetScriptOPTrue, + OPTrue: &sdk.CustomAssetOPTrueScriptPlan{InternalKey: key}, + } + output.Anchor = AnchorPlan(anchor) + return output +} + +// CooperativeSigningPlan selects a contract's sorted aggregate key path. +// Nonce exchange remains external; sessionContext must not contain secrets. +func CooperativeSigningPlan(participants [][33]byte, inputIndex uint32, + sessionContext []byte) sdk.CustomAnchorInputSigningPlan { + + keys := make([]sdk.PubKey, len(participants)) + for i := range participants { + keys[i] = sdk.PubKey(participants[i]) + } + return sdk.CustomAnchorInputSigningPlan{ + InputIndex: inputIndex, + MuSig2: &sdk.CustomAnchorMuSig2SigningPlan{ + Participants: keys, + SessionContext: bytes.Clone(sessionContext), + }, + } +} + +// ScriptSigningPlan selects a contract's exact Bitcoin leaf for SDK signing. +// The anchor PSBT must also include its leaf script and control block. +func ScriptSigningPlan(spend *swapkit.SwapAnchorSpendInfo, + inputIndex uint32) sdk.CustomAnchorInputSigningPlan { + + leafHash := txscript.NewBaseTapLeaf(spend.LeafScript).TapHash() + return sdk.CustomAnchorInputSigningPlan{ + InputIndex: inputIndex, + ScriptPath: &sdk.CustomAnchorScriptPathSigningPlan{ + LeafHash: sdk.Hash(leafHash), + RequiredSigners: []sdk.XOnlyPubKey{ + sdk.XOnlyPubKey(spend.RequiredSigner), + }, + }, + } +} diff --git a/swapkit/tapsdk/swapkit_test.go b/swapkit/tapsdk/swapkit_test.go new file mode 100644 index 000000000..9817134b4 --- /dev/null +++ b/swapkit/tapsdk/swapkit_test.go @@ -0,0 +1,147 @@ +package tapsdk + +import ( + "bytes" + "crypto/sha256" + "testing" + + "github.com/btcsuite/btcd/txscript" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/tappsbt" + "github.com/lightninglabs/taproot-assets/tapsend" + "github.com/stretchr/testify/require" +) + +// TestSwapKitSigningPlan checks SDK signing metadata and defensive copies. +// Bitcoin policy vectors and VM execution are covered by the swapkit module. +func TestSwapKitSigningPlan(t *testing.T) { + kit, err := swapkit.NewSwapKit(swapKitTestParams(t)) + require.NoError(t, err) + source := kit.AnchorPlan() + plan := AnchorPlan(source) + expected := bytes.Clone(plan.Tapscript.TapLeaves[0].Script) + plan.Tapscript.TapLeaves[0].Script[0] ^= 1 + require.Equal(t, expected, + source.Leaves[0]) + + context := []byte("unique-signing-round") + signing := CooperativeSigningPlan( + kit.CooperativeParticipants(), 2, context, + ) + require.Equal(t, uint32(2), signing.InputIndex) + require.NoError(t, validateMuSig2Aggregate( + sdk.PubKey(source.InternalKey).XOnly(), + signing.MuSig2.Participants, + )) + context[0] ^= 1 + require.NotEqual(t, context, signing.MuSig2.SessionContext) + signing.MuSig2.Participants[0] = sdk.PubKey{} + require.NotEqual(t, signing.MuSig2.Participants, + CooperativeSigningPlan( + kit.CooperativeParticipants(), 2, nil, + ).MuSig2.Participants) +} + +// TestSwapKitBuilderCommitments binds the kit's Bitcoin control blocks to the +// custom-anchor builder's independently assembled asset and policy roots. +func TestSwapKitBuilderCommitments(t *testing.T) { + params := swapKitTestParams(t) + legacy, err := swapkit.NewSwapKit(params) + require.NoError(t, err) + params.Policy = swapkit.SwapHTLCStaticLoopInV3 + v3, err := swapkit.NewSwapKit(params) + require.NoError(t, err) + deposit, err := swapkit.NewDepositKit(swapkit.DepositKitParams{ + ClientKey: params.SenderKey, ServerKey: params.ReceiverKey, + CSVExpiry: 144, + }) + require.NoError(t, err) + for name, kit := range map[string]swapKitOutput{ + "legacy": legacy, "v3": v3, "deposit": deposit, + } { + t.Run(name, func(t *testing.T) { + first := testSwapKitBuilderCommitment(t, kit, 10) + second := testSwapKitBuilderCommitment(t, kit, 11) + require.NotEqual(t, first, second) + }) + } +} + +type swapKitOutput interface { + AnchorPlan() swapkit.AnchorPlan + TimeoutSpend(swapkit.Hash) (*swapkit.SwapAnchorSpendInfo, error) +} + +func testSwapKitBuilderCommitment(t *testing.T, kit swapKitOutput, + scalar byte) sdk.PubKey { + + t.Helper() + fixture := newCustomAnchorBuilderFixture(t) + original := fixture.request.Outputs[0] + output := OPTrueOutput(original, sdk.KeyDescriptor{ + RawKeyBytes: testKey(t, scalar), + }, kit.AnchorPlan()) + fixture.request.Outputs[0] = output + wallet := sdk.NewWallet(fixture.client, sdk.NetworkRegtest) + plan, err := wallet.NewCustomAnchorTxBuilder(). + Build(t.Context(), fixture.request) + require.NoError(t, err) + planned := plan.Outputs()[0] + require.NotNil(t, planned.OPTrueSpend) + require.NoError(t, planned.OPTrueSpend.Validate(planned.ScriptKey)) + require.Equal(t, []byte{txscript.OP_TRUE}, + planned.OPTrueSpend.LeafScript) + + // Derive the builder's root independently through tapd's public + // commitment implementation. No signing or backend commit is needed. + packets := plan.ActiveVirtualPSBTs() + require.Len(t, packets, 1) + packet, err := tappsbt.NewFromRawBytes( + bytes.NewReader(packets[0]), + false, + ) + require.NoError(t, err) + commitments, err := tapsend.CreateOutputCommitments( + []*tappsbt.VPacket{packet}, tapsend.WithSpenderLeaves(), + ) + require.NoError(t, err) + virtual := packet.Outputs[planned.VirtualOutputIndex] + _, merkle, root, err := tapsend.AnchorOutputScript( + virtual.AnchorOutputInternalKey, + virtual.AnchorOutputTapscriptSibling, + commitments[virtual.AnchorOutputIndex], + ) + require.NoError(t, err) + spend, err := kit.TimeoutSpend(sdk.Hash(root)) + require.NoError(t, err) + require.Equal(t, [32]byte(merkle), spend.TaprootMerkleRoot) + signing := ScriptSigningPlan(spend, 3) + require.Equal(t, uint32(3), signing.InputIndex) + require.Equal(t, sdk.Hash(txscript.NewBaseTapLeaf( + spend.LeafScript, + ).TapHash()), signing.ScriptPath.LeafHash) + require.Equal(t, []sdk.XOnlyPubKey{ + sdk.XOnlyPubKey(spend.RequiredSigner), + }, signing.ScriptPath.RequiredSigners) + control, err := txscript.ParseControlBlock(spend.ControlBlock) + require.NoError(t, err) + require.NoError(t, txscript.VerifyTaprootLeafCommitment( + control, spend.PkScript[2:], spend.LeafScript, + )) + return planned.ScriptKey +} + +func swapKitTestParams(t *testing.T) swapkit.SwapKitParams { + t.Helper() + sender := testKey(t, 1) + receiver := testKey(t, 2) + preimage := [32]byte{42} + return swapkit.SwapKitParams{ + Policy: swapkit.SwapHTLCLegacyCSV, + SenderKey: sender, ReceiverKey: receiver, + SenderInternalKey: sender, ReceiverInternalKey: receiver, + PaymentHash: sdk.Hash(sha256.Sum256(preimage[:])), + Expiry: 144, + } +} diff --git a/swapkit/tapsdk/testdata/builder_request.json b/swapkit/tapsdk/testdata/builder_request.json new file mode 100644 index 000000000..176b1375d --- /dev/null +++ b/swapkit/tapsdk/testdata/builder_request.json @@ -0,0 +1,385 @@ +{ + "Request": { + "Inputs": [ + { + "ID": "asset-input", + "AssetRef": "tapr1qqqvf4wta3rfpxvuauv3xx0glv5lgy78x34y2dyq4r7ksuvxm9zsm5qjdcsj7", + "Amount": 100, + "ProofFile": "VEFQRgAAAAAB/QLhVEFQUAAEAAAAAQIkAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAatWwK2mb6b9cBCjkRUli09D6oBMXGNjptuiXD3kg+ZwAJbogAAAAAAAAAAAZeAwAAAAEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAFKAQAAAAAAACJRIBWAwqm9Ntk9OxJQKldaBpaxLfQZFu/6NkIsFhNVXbN/AAAAAAgBAAr3AAEBAloBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQYXNzZXQtcHJvb2YtcGF0aAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAQAGAWQLaQFnAWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4CAAAQIQLaRxCWT3hSaV3i2gJSkOJK9tjCgd5aC5ArcTX9n9dNIQyfAAQAAAAAAiECxgR/lEHtfW0wRUBulcB82Fx3jkuM7zynq6wJuVxwnuUDdAFJAAEBAiDE1cvsRpCZnO8ZExno+yn0E8c0akU0gKj9aHGG2UUN0AQiAAD//////////////////////////////////////////wInAAECAiIAAP//////////////////////////////////////////FgQAAABkF1oBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQYXNzZXQtcHJvb2YtcGF0aAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABan+WnD6nnUqtFpTlr4jyhk5IS73ZCp551AN4sK+C/XA==", + "ProofPath": null, + "Witness": { + "Mode": 1, + "Stack": null + } + } + ], + "Outputs": [ + { + "ID": "asset-output", + "AssetRef": "tapr1qqqvf4wta3rfpxvuauv3xx0glv5lgy78x34y2dyq4r7ksuvxm9zsm5qjdcsj7", + "Amount": 100, + "AnchorOutputIndex": 1, + "AnchorValueSat": 777, + "Script": { + "Mode": 2, + "Wallet": null, + "External": { + "ScriptKey": { + "PubKey": [ + 3, + 236, + 235, + 1, + 9, + 8, + 90, + 10, + 62, + 52, + 52, + 250, + 234, + 178, + 14, + 157, + 8, + 229, + 180, + 253, + 200, + 83, + 140, + 67, + 139, + 163, + 230, + 116, + 131, + 73, + 213, + 242, + 95 + ], + "KeyDesc": { + "RawKeyBytes": [ + 3, + 172, + 212, + 132, + 226, + 240, + 199, + 246, + 83, + 9, + 173, + 23, + 138, + 159, + 85, + 154, + 189, + 224, + 151, + 150, + 151, + 76, + 87, + 231, + 20, + 195, + 95, + 17, + 13, + 252, + 39, + 204, + 190 + ], + "KeyLocator": { + "Family": 0, + "Index": 0 + } + }, + "TapTweak": null + } + }, + "OPTrue": null, + "Burn": null + }, + "Anchor": { + "InternalKey": { + "PubKey": [ + 2, + 47, + 1, + 229, + 225, + 92, + 202, + 53, + 29, + 175, + 243, + 132, + 63, + 183, + 15, + 60, + 47, + 10, + 27, + 221, + 5, + 229, + 175, + 136, + 138, + 103, + 120, + 78, + 243, + 225, + 10, + 42, + 1 + ], + "KeyLocator": { + "Family": 0, + "Index": 0 + } + }, + "Tapscript": { + "TapLeaves": null, + "SerializedSibling": null + } + }, + "ProofDelivery": { + "recipient_id": "", + "courier_address": "", + "opaque_metadata": null + }, + "Timelocks": { + "Absolute": 0, + "Relative": 0 + } + } + ], + "AnchorPSBT": "cHNidP8BAH0DAAAAAqoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQAAAAARERERGrVsCtpm+m/XAQo5EVJYtPQ+qATFxjY6bbolw95IPmcAAAAAACIiIiIDOTAAAAAAAAABUQkDAAAAAAAAAQAAAAAAAAAAAARRAk5zKgAAAAABASv4MQAAAAAAACJRIBnLpbY73L9GYp7fF82hO85We5BEK7Qh6uijLjWEOWfDARcgXL3wZG5dtOqjmPNl8up6Dj1Bm34DMOOc6Svd7crE+bwAAAAAAA==", + "Funding": { + "Mode": 3, + "WalletFunded": null, + "CallerFundedExact": null, + "ExternalP2AFeeBump": { + "P2AOutputIndex": 2 + } + }, + "PassiveAssets": { + "Policy": 0, + "Packets": null + }, + "LossPolicy": { + "Mode": 0, + "Allowances": null, + "ConfirmIrreversibleLoss": false + }, + "SigningPlans": [ + { + "input_index": 0, + "key_path": { + "signer": [ + 92, + 189, + 240, + 100, + 110, + 93, + 180, + 234, + 163, + 152, + 243, + 101, + 242, + 234, + 122, + 14, + 61, + 65, + 155, + 126, + 3, + 48, + 227, + 156, + 233, + 43, + 221, + 237, + 202, + 196, + 249, + 188 + ] + } + }, + { + "input_index": 1, + "key_path": { + "signer": [ + 198, + 4, + 127, + 148, + 65, + 237, + 125, + 109, + 48, + 69, + 64, + 110, + 149, + 192, + 124, + 216, + 92, + 119, + 142, + 75, + 140, + 239, + 60, + 167, + 171, + 172, + 9, + 185, + 92, + 112, + 158, + 229 + ] + } + } + ] + }, + "Verified": { + "Valid": true, + "DecodedProof": { + "ProofAtDepth": 0, + "NumberOfProofs": 0, + "AssetRef": "tapr1qqqvf4wta3rfpxvuauv3xx0glv5lgy78x34y2dyq4r7ksuvxm9zsm5qjdcsj7", + "IssuanceID": [ + 196, + 213, + 203, + 236, + 70, + 144, + 153, + 156, + 239, + 25, + 19, + 25, + 232, + 251, + 41, + 244, + 19, + 199, + 52, + 106, + 69, + 52, + 128, + 168, + 253, + 104, + 113, + 134, + 217, + 69, + 13, + 208 + ], + "ScriptKey": [ + 2, + 218, + 71, + 16, + 150, + 79, + 120, + 82, + 105, + 93, + 226, + 218, + 2, + 82, + 144, + 226, + 74, + 246, + 216, + 194, + 129, + 222, + 90, + 11, + 144, + 43, + 113, + 53, + 253, + 159, + 215, + 77, + 33 + ], + "Amount": 100, + "Outpoint": { + "Txid": [ + 26, + 181, + 108, + 10, + 218, + 102, + 250, + 111, + 215, + 1, + 10, + 57, + 17, + 82, + 88, + 180, + 244, + 62, + 168, + 4, + 197, + 198, + 54, + 58, + 109, + 186, + 37, + 195, + 222, + 72, + 62, + 103 + ], + "Index": 0 + }, + "AltLeaves": null, + "PrevIDs": null, + "IsIssuance": false + } + } +} \ No newline at end of file From 5916d94e6b44da32a552bbe512705e2312efc181 Mon Sep 17 00:00:00 2001 From: Slyghtning Date: Wed, 11 Nov 2026 14:18:38 +0100 Subject: [PATCH 4/9] tapsdk: Validate asset proofs and current-chain inputs Authenticate proof history, asset commitments, group issuances and Bitcoin inputs before granting on-chain authority. Apply the shared tapd floor at proof boundaries while keeping offline construction available. Distinguish invalid funding candidates from exact outputs waiting on confirmations or a chain backend. Preserve retryable results when no candidate is ready. --- internal/assetpolicy/networks.go | 65 +++ internal/assetpolicy/networks_test.go | 79 ++++ internal/assetpolicy/provenance.go | 257 +++++++++++ internal/assetpolicy/provenance_test.go | 482 ++++++++++++++++++++ internal/assetpolicy/test_constants_test.go | 3 + internal/assetpolicy/tlv_test.go | 56 +++ internal/assetpolicy/versions.go | 75 +++ internal/assetproof/anchor.go | 190 ++++++++ internal/assetproof/anchor_test.go | 95 ++++ swapkit/asset_types.go | 15 + swapkit/tapsdk/asset.go | 32 ++ swapkit/tapsdk/binding_test.go | 199 ++++++++ swapkit/tapsdk/bindings.go | 314 +++++++++++++ swapkit/tapsdk/chain.go | 173 +++++++ swapkit/tapsdk/chain_guard_test.go | 97 ++++ swapkit/tapsdk/chain_test.go | 147 ++++++ swapkit/tapsdk/confirmation_chain_test.go | 79 ++++ swapkit/tapsdk/deposit.go | 83 ++++ swapkit/tapsdk/funding.go | 64 +++ swapkit/tapsdk/funding_test.go | 210 +++++++++ swapkit/tapsdk/group.go | 21 + swapkit/tapsdk/group_proofs.go | 93 ++++ swapkit/tapsdk/group_proofs_test.go | 90 ++++ swapkit/tapsdk/group_test.go | 72 +++ swapkit/tapsdk/inputs.go | 100 ++++ swapkit/tapsdk/issuance.go | 98 ++++ swapkit/tapsdk/issuance_test.go | 116 +++++ swapkit/tapsdk/policy.go | 135 ++++++ swapkit/tapsdk/proofs.go | 184 ++++++++ swapkit/tapsdk/test_constants_test.go | 11 + 30 files changed, 3635 insertions(+) create mode 100644 internal/assetpolicy/networks.go create mode 100644 internal/assetpolicy/networks_test.go create mode 100644 internal/assetpolicy/provenance.go create mode 100644 internal/assetpolicy/provenance_test.go create mode 100644 internal/assetpolicy/test_constants_test.go create mode 100644 internal/assetpolicy/tlv_test.go create mode 100644 internal/assetpolicy/versions.go create mode 100644 internal/assetproof/anchor.go create mode 100644 internal/assetproof/anchor_test.go create mode 100644 swapkit/tapsdk/bindings.go create mode 100644 swapkit/tapsdk/chain.go create mode 100644 swapkit/tapsdk/chain_guard_test.go create mode 100644 swapkit/tapsdk/chain_test.go create mode 100644 swapkit/tapsdk/confirmation_chain_test.go create mode 100644 swapkit/tapsdk/deposit.go create mode 100644 swapkit/tapsdk/funding.go create mode 100644 swapkit/tapsdk/funding_test.go create mode 100644 swapkit/tapsdk/group.go create mode 100644 swapkit/tapsdk/group_proofs.go create mode 100644 swapkit/tapsdk/group_proofs_test.go create mode 100644 swapkit/tapsdk/group_test.go create mode 100644 swapkit/tapsdk/inputs.go create mode 100644 swapkit/tapsdk/issuance.go create mode 100644 swapkit/tapsdk/issuance_test.go create mode 100644 swapkit/tapsdk/policy.go create mode 100644 swapkit/tapsdk/proofs.go create mode 100644 swapkit/tapsdk/test_constants_test.go diff --git a/internal/assetpolicy/networks.go b/internal/assetpolicy/networks.go new file mode 100644 index 000000000..ef99cf028 --- /dev/null +++ b/internal/assetpolicy/networks.go @@ -0,0 +1,65 @@ +package policy + +import ( + "fmt" + + "github.com/lightninglabs/taproot-assets/address" +) + +// RawSimNetHDCoinType is the BIP-0044 coin type used by btcd's native simnet +// parameters. LND deliberately uses the testnet coin type for simnet instead, +// so both forms need explicit, stable definitions. +const RawSimNetHDCoinType uint32 = 115 + +// CloneAddressParams returns an independent copy of address parameters, +// including the nested Bitcoin network parameters when present. +func CloneAddressParams(params address.ChainParams) *address.ChainParams { + paramsCopy := params + if params.Params != nil { + bitcoinParams := *params.Params + paramsCopy.Params = &bitcoinParams + } + + return ¶msCopy +} + +// CanonicalAddressParams returns an independent copy of the supported network +// parameters that match the caller's Taproot Asset address tuple of HRP, +// network and HD coin type. Every other field, including the network name that +// selects the proof activation height, comes from the canonical definition. +func CanonicalAddressParams(params *address.ChainParams) ( + *address.ChainParams, error) { + + if params == nil { + return nil, fmt.Errorf("address parameters are required") + } + if params.Params == nil || params.TapHRP == "" { + return nil, fmt.Errorf("address parameters are incomplete") + } + + rawSimNet := CloneAddressParams(address.SimNetTap) + rawSimNet.HDCoinType = RawSimNetHDCoinType + lndSimNet := CloneAddressParams(address.SimNetTap) + lndSimNet.HDCoinType = address.TestNet3Tap.HDCoinType + + knownNetworks := []*address.ChainParams{ + &address.MainNetTap, + &address.TestNet3Tap, + &address.TestNet4Tap, + &address.RegressionNetTap, + &address.SigNetTap, + rawSimNet, + lndSimNet, + } + for _, known := range knownNetworks { + if params.TapHRP != known.TapHRP || params.Net != known.Net || + params.HDCoinType != known.HDCoinType { + + continue + } + + return CloneAddressParams(*known), nil + } + + return nil, fmt.Errorf("unsupported or mismatched address parameters") +} diff --git a/internal/assetpolicy/networks_test.go b/internal/assetpolicy/networks_test.go new file mode 100644 index 000000000..dfa2a49dc --- /dev/null +++ b/internal/assetpolicy/networks_test.go @@ -0,0 +1,79 @@ +package policy + +import ( + "testing" + + "github.com/btcsuite/btcd/chaincfg" + "github.com/lightninglabs/taproot-assets/address" + "github.com/stretchr/testify/require" +) + +// TestCanonicalAddressParams verifies that supported network tuples resolve to +// independent copies of their canonical parameters, and that incomplete or +// mismatched tuples are rejected. +func TestCanonicalAddressParams(t *testing.T) { + simNetCoinType := address.SimNetTap.HDCoinType + + rawSimNet := CloneAddressParams(address.SimNetTap) + rawSimNet.HDCoinType = RawSimNetHDCoinType + lndSimNet := CloneAddressParams(address.SimNetTap) + lndSimNet.HDCoinType = address.TestNet3Tap.HDCoinType + + for _, network := range []*address.ChainParams{ + &address.MainNetTap, + &address.TestNet3Tap, + &address.TestNet4Tap, + &address.RegressionNetTap, + &address.SigNetTap, + rawSimNet, + lndSimNet, + } { + canonical, err := CanonicalAddressParams(network) + require.NoError(t, err) + require.Equal(t, network.TapHRP, canonical.TapHRP) + require.Equal(t, network.Net, canonical.Net) + require.Equal(t, network.HDCoinType, canonical.HDCoinType) + require.Equal(t, network.Name, canonical.Name) + require.NotSame(t, network.Params, canonical.Params) + } + require.Equal(t, simNetCoinType, address.SimNetTap.HDCoinType) + + // The tuple selects the network, so a caller cannot rename it and + // thereby select another proof activation height. + renamed := CloneAddressParams(address.MainNetTap) + renamed.Name = chaincfg.RegressionNetParams.Name + canonical, err := CanonicalAddressParams(renamed) + require.NoError(t, err) + require.Equal(t, chaincfg.MainNetParams.Name, canonical.Name) + + canonical.Name = "mutated" + require.Equal(t, chaincfg.MainNetParams.Name, address.MainNetTap.Name) + + mismatched := CloneAddressParams(address.RegressionNetTap) + mismatched.TapHRP = address.MainNetTap.TapHRP + _, err = CanonicalAddressParams(mismatched) + require.ErrorContains(t, err, "unsupported or mismatched") + + _, err = CanonicalAddressParams(nil) + require.ErrorContains(t, err, "required") + + _, err = CanonicalAddressParams(&address.ChainParams{ + TapHRP: address.MainNetTap.TapHRP, + }) + require.ErrorContains(t, err, "incomplete") + + missingHRP := CloneAddressParams(address.MainNetTap) + missingHRP.TapHRP = "" + _, err = CanonicalAddressParams(missingHRP) + require.ErrorContains(t, err, "incomplete") +} + +// TestCheckProofFileSize verifies the proof file limit at its boundary. +func TestCheckProofFileSize(t *testing.T) { + require.NoError(t, checkProofFileSize(make([]byte, 10), 10)) + require.ErrorContains( + t, checkProofFileSize(make([]byte, 11), 10), + "exceeds the 10 byte limit", + ) + require.NoError(t, CheckProofFileSize(nil)) +} diff --git a/internal/assetpolicy/provenance.go b/internal/assetpolicy/provenance.go new file mode 100644 index 000000000..6107ab782 --- /dev/null +++ b/internal/assetpolicy/provenance.go @@ -0,0 +1,257 @@ +package policy + +import ( + "bytes" + "context" + "fmt" + + "github.com/lightninglabs/taproot-assets/address" + "github.com/lightninglabs/taproot-assets/proof" +) + +const ( + // MaxProvenanceDepth bounds how deeply additional input files may nest + // in an accepted proof history. + MaxProvenanceDepth = 16 + + // MaxProvenanceBytes bounds the total size of the proofs decoded while + // walking an accepted proof history. Decoding a proof copies every + // input file nested beneath it, so without a budget the work grows with + // the nesting depth times the file size rather than with the file size. + MaxProvenanceBytes = 64 << 20 +) + +// CheckProofFileSize rejects a proof file larger than MaxProvenanceBytes before +// it is copied or decoded. Proof files share the limit of the decoding budget, +// which is below the maximum file size of Taproot Assets. +func CheckProofFileSize(rawFile []byte) error { + return checkProofFileSize(rawFile, MaxProvenanceBytes) +} + +// checkProofFileSize implements CheckProofFileSize with an explicit limit. +func checkProofFileSize(rawFile []byte, maxBytes int) error { + if len(rawFile) > maxBytes { + return fmt.Errorf("proof file of %d bytes exceeds the %d byte "+ + "limit", len(rawFile), maxBytes) + } + + return proof.CheckMaxFileSize(rawFile) +} + +// ActivationHeight returns the block height from which transition proofs on +// the given network must satisfy the Taproot Assets v0.8.5 activation rules. +// A network without a scheduled height, such as regtest, uses tapd's +// process-wide default, which is unset unless configured. The boolean is false +// when no activation rules apply. +func ActivationHeight(params *address.ChainParams) (uint32, bool) { + height := proof.DefaultActivationHeight() + if params != nil && params.Params != nil { + scheduled := proof.NetworkActivationHeight(params.Params.Name) + if scheduled.IsSome() { + height = scheduled + } + } + + return height.UnwrapOr(0), height.IsSome() +} + +// ValidateActivation applies the Taproot Assets v0.8.5 activation rules to a +// proof as tapd applies them to a confirmed proof. Issuance proofs are exempt, +// as is a proof that claims a non-zero block height below the activation +// height. Any other transition proof must be of version one and carry the root +// locator proof of a split, the STXO proofs of a split asset's root, and the +// spender proofs of its transfer root. Only full proof verification +// authenticates the claimed height. +func ValidateActivation(p *proof.Proof, activationHeight uint32) error { + if p == nil { + return fmt.Errorf("proof is required") + } + if p.Asset.IsGenesisAsset() { + return nil + } + if p.BlockHeight != 0 && p.BlockHeight < activationHeight { + return nil + } + + // A split asset proves its transfer root through its split root proof. + splitAsset := p.Asset.HasSplitCommitmentWitness() + rootProof := &p.InclusionProof + if splitAsset { + rootProof = p.SplitRootProof + } + + var missing error + switch { + case p.Version == proof.TransitionV0: + missing = proof.ErrTransitionV1Required + + case (splitAsset || p.Asset.SplitCommitmentRoot != nil) && + p.RootLocatorProof == nil: + + missing = proof.ErrMissingRootLocatorProof + + case splitAsset && (rootProof == nil || + rootProof.CommitmentProof == nil || + len(rootProof.CommitmentProof.STXOProofs) == 0): + + missing = proof.ErrMissingSplitSTXOProofs + + case rootProof == nil || rootProof.CommitmentProof == nil || + len(rootProof.CommitmentProof.SpenderProofs) == 0: + + missing = proof.ErrMissingSpenderProofs + } + if missing != nil { + return fmt.Errorf("%w: proof at height %d", missing, + p.BlockHeight) + } + + return nil +} + +// provenanceFile is a proof file awaiting the provenance walk, together with +// its nesting depth below the supplied file. +type provenanceFile struct { + file *proof.File + depth int +} + +// ValidateProvenance rejects proof histories that establish no provenance, +// before tapd verifies issuance and transitions. Every file, including each +// nested additional input, must start at genesis and contain no ownership +// challenge, and every proof must satisfy the Taproot Assets v0.8.5 +// activation rules of the given network for its claimed height. Nested files +// are walked iteratively so peer input cannot determine the call-stack depth, +// and the nesting depth and total decoded size are bounded so peer input +// cannot amplify the work. These structural checks alone do not establish +// that an asset is valid. +func ValidateProvenance(ctx context.Context, file *proof.File, + params *address.ChainParams) error { + + return validateProvenance( + ctx, file, params, MaxProvenanceDepth, MaxProvenanceBytes, + ) +} + +// validateProvenance implements ValidateProvenance with explicit bounds. +func validateProvenance(ctx context.Context, file *proof.File, + params *address.ChainParams, maxDepth, maxBytes int) error { + + if file == nil { + return fmt.Errorf("proof file is required") + } + walk := &provenanceWalk{maxDepth: maxDepth, maxBytes: maxBytes} + walk.activationHeight, walk.activated = ActivationHeight(params) + + pending := []provenanceFile{{file: file}} + for len(pending) > 0 { + last := len(pending) - 1 + entry := pending[last] + pending[last] = provenanceFile{} + pending = pending[:last] + + inputs, err := walk.visit(ctx, entry) + if err != nil { + return err + } + pending = append(pending, inputs...) + } + + return nil +} + +// provenanceWalk holds the bounds and the decoding budget shared by every +// file of one provenance walk. +type provenanceWalk struct { + maxDepth int + maxBytes int + decodedBytes int + activationHeight uint32 + activated bool +} + +// visit checks every proof of a file and returns its additional inputs. +func (w *provenanceWalk) visit(ctx context.Context, + entry provenanceFile) ([]provenanceFile, error) { + + file := entry.file + if file.Version != ProofFileVersion { + return nil, fmt.Errorf("unsupported proof file version %d", + file.Version) + } + if file.NumProofs() == 0 { + return nil, fmt.Errorf("proof history is empty") + } + + var inputs []provenanceFile + for idx := range file.NumProofs() { + if err := ctx.Err(); err != nil { + return nil, err + } + p, err := w.decode(file, idx) + if err != nil { + return nil, err + } + if err := w.check(p, idx == 0); err != nil { + return nil, err + } + + if len(p.AdditionalInputs) == 0 { + continue + } + if entry.depth >= w.maxDepth { + return nil, fmt.Errorf("proof inputs nest more than %d "+ + "levels deep", w.maxDepth) + } + for inputIdx := range p.AdditionalInputs { + inputs = append(inputs, provenanceFile{ + file: &p.AdditionalInputs[inputIdx], + depth: entry.depth + 1, + }) + } + } + + return inputs, nil +} + +// decode charges a proof's size to the budget before decoding the proof, as +// decoding copies every input file nested in it. +func (w *provenanceWalk) decode(file *proof.File, idx int) (*proof.Proof, + error) { + + rawProof, err := file.RawProofAt(uint32(idx)) + if err != nil { + return nil, fmt.Errorf("unable to read proof: %w", err) + } + w.decodedBytes += len(rawProof) + if w.decodedBytes > w.maxBytes { + return nil, fmt.Errorf("proof history exceeds the %d byte "+ + "decoding budget", w.maxBytes) + } + + p := &proof.Proof{} + if err := p.Decode(bytes.NewReader(rawProof)); err != nil { + return nil, fmt.Errorf("unable to decode proof: %w", err) + } + + return p, nil +} + +// check applies the provenance and activation rules to one proof, the first +// of its file if first is set. +func (w *provenanceWalk) check(p *proof.Proof, first bool) error { + if err := ValidateTransitionVersion(p.Version); err != nil { + return err + } + if p.ChallengeWitness != nil { + return fmt.Errorf("proof history contains an ownership challenge") + } + if first && !p.Asset.IsGenesisAsset() { + return fmt.Errorf("proof history must start at genesis") + } + if !w.activated { + return nil + } + + return ValidateActivation(p, w.activationHeight) +} diff --git a/internal/assetpolicy/provenance_test.go b/internal/assetpolicy/provenance_test.go new file mode 100644 index 000000000..7729888cc --- /dev/null +++ b/internal/assetpolicy/provenance_test.go @@ -0,0 +1,482 @@ +package policy + +import ( + "context" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/chaincfg" + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/taproot-assets/address" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightninglabs/taproot-assets/mssmt" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/stretchr/testify/require" +) + +// testKey derives a deterministic test key from a one-byte scalar. +func testKey(scalar byte) *btcec.PublicKey { + keyBytes := make([]byte, 32) + keyBytes[31] = scalar + _, publicKey := btcec.PrivKeyFromBytes(keyBytes) + + return publicKey +} + +// issuanceProof returns an encodable issuance proof. The provenance walk only +// decodes proofs, so it need not pass verification. +func issuanceProof(t *testing.T) proof.Proof { + t.Helper() + + genesis := asset.Genesis{ + FirstPrevOut: wire.OutPoint{Hash: chainhash.Hash{0x61}, Index: 1}, + Tag: "provenance policy test", + Type: asset.Normal, + } + issued, err := asset.New( + genesis, 1000, 0, 0, asset.NewScriptKey(testKey(1)), nil, + asset.WithAssetVersion(asset.V1), + ) + require.NoError(t, err) + version := commitment.TapCommitmentV2 + tapCommitment, err := commitment.FromAssets(&version, issued) + require.NoError(t, err) + _, inclusion, err := tapCommitment.Proof( + issued.TapCommitmentKey(), issued.AssetCommitmentKey(), + ) + require.NoError(t, err) + + anchorTx := wire.NewMsgTx(2) + anchorTx.AddTxIn(&wire.TxIn{PreviousOutPoint: genesis.FirstPrevOut}) + anchorTx.AddTxOut(&wire.TxOut{ + Value: 1000, PkScript: []byte{txscript.OP_TRUE}, + }) + + return proof.Proof{ + PrevOut: genesis.FirstPrevOut, + AnchorTx: *anchorTx, + Asset: *issued, + GenesisReveal: &genesis, + InclusionProof: proof.TaprootProof{ + InternalKey: testKey(2), + CommitmentProof: &proof.CommitmentProof{ + Proof: *inclusion, + }, + }, + } +} + +// transferProof returns an encodable proof that spends the issued asset and +// carries none of the evidence the activation rules require. +func transferProof(t *testing.T, issuance proof.Proof) proof.Proof { + t.Helper() + + transfer := issuance + transfer.Asset = *issuance.Asset.Copy() + transfer.Asset.PrevWitnesses = []asset.Witness{{ + PrevID: &asset.PrevID{ + OutPoint: issuance.OutPoint(), + ID: issuance.Asset.ID(), + ScriptKey: asset.ToSerialized( + issuance.Asset.ScriptKey.PubKey, + ), + }, + TxWitness: wire.TxWitness{{0x01}}, + }} + transfer.GenesisReveal = nil + transfer.PrevOut = issuance.OutPoint() + + return transfer +} + +// newFile encodes the proofs into a proof file. +func newFile(t *testing.T, proofs ...proof.Proof) *proof.File { + t.Helper() + + file, err := proof.NewFile(proof.V0, proofs...) + require.NoError(t, err) + + return file +} + +// nest returns a file whose single proof carries file as an additional input. +func nest(t *testing.T, issuance proof.Proof, file *proof.File) *proof.File { + t.Helper() + + parent := issuance + parent.AdditionalInputs = []proof.File{*file} + + return newFile(t, parent) +} + +// nested returns an issuance file wrapped depth times in additional inputs. +func nested(t *testing.T, issuance proof.Proof, depth int) *proof.File { + t.Helper() + + file := newFile(t, issuance) + for range depth { + file = nest(t, issuance, file) + } + + return file +} + +// TestActivationHeight uses the scheduled height of each network, and tapd's +// process-wide default for networks without one. +func TestActivationHeight(t *testing.T) { + scheduled := []struct { + params *address.ChainParams + height uint32 + }{ + {&address.MainNetTap, proof.MainNetActivationHeight}, + {&address.TestNet3Tap, proof.TestNet3ActivationHeight}, + {&address.TestNet4Tap, proof.TestNet4ActivationHeight}, + {&address.SigNetTap, proof.SigNetActivationHeight}, + } + for _, network := range scheduled { + height, activated := ActivationHeight(network.params) + require.True(t, activated) + require.Equal(t, network.height, height) + } + for _, params := range []*address.ChainParams{ + &address.RegressionNetTap, &address.SimNetTap, nil, + } { + _, activated := ActivationHeight(params) + require.False(t, activated) + } + + // Regtest follows the default, while scheduled heights take precedence. + proof.SetDefaultActivationHeight( + proof.NetworkActivationHeight(chaincfg.TestNet4Params.Name), + ) + t.Cleanup(func() { + proof.SetDefaultActivationHeight(proof.NetworkActivationHeight( + chaincfg.RegressionNetParams.Name, + )) + }) + height, activated := ActivationHeight(&address.RegressionNetTap) + require.True(t, activated) + require.Equal(t, proof.TestNet4ActivationHeight, height) + height, activated = ActivationHeight(&address.MainNetTap) + require.True(t, activated) + require.Equal(t, proof.MainNetActivationHeight, height) +} + +// TestValidateActivation mirrors each Taproot Assets v0.8.5 activation rule +// for root transfers, split roots and split assets. +func TestValidateActivation(t *testing.T) { + const activationHeight = proof.MainNetActivationHeight + + issuance := issuanceProof(t) + spenders := map[asset.SerializedKey]commitment.Proof{{0x02}: {}} + stxos := map[asset.SerializedKey]commitment.Proof{{0x03}: {}} + + // rootTransfer returns a version one root transfer proof with spender + // proofs, which mutate may strip. + rootTransfer := func(mutate func(*proof.Proof)) *proof.Proof { + p := transferProof(t, issuance) + p.Version = proof.TransitionV1 + p.InclusionProof.CommitmentProof = &proof.CommitmentProof{ + SpenderProofs: spenders, + } + if mutate != nil { + mutate(&p) + } + + return &p + } + + // splitRoot returns a split root asset proof with its root locator. + splitRoot := func(mutate func(*proof.Proof)) *proof.Proof { + return rootTransfer(func(p *proof.Proof) { + p.Asset.SplitCommitmentRoot = mssmt.NewComputedNode( + mssmt.NodeHash{0x04}, 1000, + ) + p.RootLocatorProof = &mssmt.Proof{} + if mutate != nil { + mutate(p) + } + }) + } + + // splitAsset returns a split asset proof whose split root proof + // carries its root's STXO and spender proofs. + splitAsset := func(mutate func(*proof.Proof)) *proof.Proof { + p := transferProof(t, issuance) + p.Version = proof.TransitionV1 + p.Asset.PrevWitnesses = []asset.Witness{{ + PrevID: &asset.ZeroPrevID, + SplitCommitment: &asset.SplitCommitment{ + RootAsset: *issuance.Asset.Copy(), + }, + }} + p.RootLocatorProof = &mssmt.Proof{} + p.SplitRootProof = &proof.TaprootProof{ + CommitmentProof: &proof.CommitmentProof{ + STXOProofs: stxos, + SpenderProofs: spenders, + }, + } + if mutate != nil { + mutate(&p) + } + + return &p + } + + tests := []struct { + name string + proof *proof.Proof + err error + }{ + { + name: "issuance", + proof: &issuance, + }, + { + name: "complete root transfer", + proof: rootTransfer(nil), + }, + { + name: "version zero transfer", + proof: rootTransfer(func(p *proof.Proof) { + p.Version = proof.TransitionV0 + }), + err: proof.ErrTransitionV1Required, + }, + { + name: "transfer without spender proofs", + proof: rootTransfer(func(p *proof.Proof) { + p.InclusionProof.CommitmentProof = nil + }), + err: proof.ErrMissingSpenderProofs, + }, + { + name: "complete split root", + proof: splitRoot(nil), + }, + { + name: "split root without root locator", + proof: splitRoot(func(p *proof.Proof) { + p.RootLocatorProof = nil + }), + err: proof.ErrMissingRootLocatorProof, + }, + { + name: "complete split asset", + proof: splitAsset(nil), + }, + { + name: "split asset without root locator", + proof: splitAsset(func(p *proof.Proof) { + p.RootLocatorProof = nil + }), + err: proof.ErrMissingRootLocatorProof, + }, + { + name: "split asset without split root STXO proofs", + proof: splitAsset(func(p *proof.Proof) { + p.SplitRootProof.CommitmentProof.STXOProofs = nil + }), + err: proof.ErrMissingSplitSTXOProofs, + }, + { + name: "split asset without split root spender proofs", + proof: splitAsset(func(p *proof.Proof) { + p.SplitRootProof.CommitmentProof.SpenderProofs = nil + }), + err: proof.ErrMissingSpenderProofs, + }, + { + name: "split asset without split root proof", + proof: splitAsset(func(p *proof.Proof) { + p.SplitRootProof = nil + }), + err: proof.ErrMissingSplitSTXOProofs, + }, + { + name: "claimed height before activation", + proof: rootTransfer(func(p *proof.Proof) { + p.Version = proof.TransitionV0 + p.BlockHeight = activationHeight - 1 + }), + }, + { + name: "claimed activation height", + proof: rootTransfer(func(p *proof.Proof) { + p.Version = proof.TransitionV0 + p.BlockHeight = activationHeight + }), + err: proof.ErrTransitionV1Required, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + err := ValidateActivation(test.proof, activationHeight) + if test.err == nil { + require.NoError(t, err) + + return + } + require.ErrorIs(t, err, test.err) + }) + } + + require.ErrorContains( + t, ValidateActivation(nil, activationHeight), "proof is required", + ) +} + +// TestValidateProvenance rejects histories without provenance anywhere in the +// input tree, and applies the activation rules of the given network. +func TestValidateProvenance(t *testing.T) { + issuance := issuanceProof(t) + transfer := transferProof(t, issuance) + ownership := transfer + ownership.ChallengeWitness = wire.TxWitness{{0x01}} + preActivation := transfer + preActivation.BlockHeight = proof.MainNetActivationHeight - 1 + + tests := []struct { + name string + file *proof.File + params *address.ChainParams + err string + errIs error + }{ + { + name: "issuance", + file: newFile(t, issuance), + }, + { + name: "transfer history", + file: newFile(t, issuance, transfer), + }, + { + name: "nested history", + file: nest(t, issuance, newFile(t, issuance, transfer)), + }, + { + name: "empty history", + file: newFile(t), + err: "history is empty", + }, + { + name: "ownership proof", + file: newFile(t, ownership), + err: testOwnershipChallenge, + }, + { + name: "later ownership proof", + file: newFile(t, issuance, ownership), + err: testOwnershipChallenge, + }, + { + name: "missing genesis", + file: newFile(t, transfer), + err: "must start at genesis", + }, + { + name: "nested ownership proof", + file: nest(t, issuance, nest(t, issuance, + newFile(t, ownership))), + err: testOwnershipChallenge, + }, + { + name: "nested input missing genesis", + file: nest(t, issuance, newFile(t, transfer)), + err: "must start at genesis", + }, + { + name: "nested empty input", + file: nest(t, issuance, newFile(t)), + err: "history is empty", + }, + { + name: "activated issuance", + file: newFile(t, issuance), + params: &address.MainNetTap, + }, + { + name: "activated transfer without evidence", + file: newFile(t, issuance, transfer), + params: &address.MainNetTap, + errIs: proof.ErrTransitionV1Required, + }, + { + name: "activated nested transfer without evidence", + file: nest(t, issuance, + newFile(t, issuance, transfer)), + params: &address.MainNetTap, + errIs: proof.ErrTransitionV1Required, + }, + { + name: "transfer claimed before activation", + file: newFile(t, issuance, preActivation), + params: &address.MainNetTap, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + params := test.params + if params == nil { + params = &address.RegressionNetTap + } + err := ValidateProvenance(t.Context(), test.file, params) + switch { + case test.err != "": + require.ErrorContains(t, err, test.err) + + case test.errIs != nil: + require.ErrorIs(t, err, test.errIs) + + default: + require.NoError(t, err) + } + }) + } + + file := newFile(t, issuance) + file.Version = ProofFileVersion + 1 + require.ErrorContains(t, ValidateProvenance( + t.Context(), file, &address.RegressionNetTap, + ), "unsupported proof file version") + require.ErrorContains(t, ValidateProvenance( + t.Context(), nil, &address.RegressionNetTap, + ), "proof file is required") +} + +// TestValidateProvenanceBounds stops nested input histories at the depth and +// decoding budget limits, which charge every nested copy that decoding makes. +func TestValidateProvenanceBounds(t *testing.T) { + issuance := issuanceProof(t) + params := &address.RegressionNetTap + + require.NoError(t, ValidateProvenance( + t.Context(), nested(t, issuance, MaxProvenanceDepth), params, + )) + require.ErrorContains(t, ValidateProvenance( + t.Context(), nested(t, issuance, MaxProvenanceDepth+1), params, + ), "levels deep") + + // The terminal proof alone fits the budget, but the copy of its nested + // input that decoding makes does not. + file := nested(t, issuance, 1) + terminal, err := file.RawProofAt(0) + require.NoError(t, err) + require.ErrorContains(t, validateProvenance( + t.Context(), file, params, MaxProvenanceDepth, len(terminal)+1, + ), "decoding budget") + require.NoError(t, validateProvenance( + t.Context(), file, params, MaxProvenanceDepth, 2*len(terminal), + )) + + ctx, cancel := context.WithCancel(t.Context()) + cancel() + require.ErrorIs( + t, ValidateProvenance(ctx, file, params), context.Canceled, + ) +} diff --git a/internal/assetpolicy/test_constants_test.go b/internal/assetpolicy/test_constants_test.go new file mode 100644 index 000000000..9fce3febc --- /dev/null +++ b/internal/assetpolicy/test_constants_test.go @@ -0,0 +1,3 @@ +package policy + +const testOwnershipChallenge = "ownership challenge" diff --git a/internal/assetpolicy/tlv_test.go b/internal/assetpolicy/tlv_test.go new file mode 100644 index 000000000..32a6a32d9 --- /dev/null +++ b/internal/assetpolicy/tlv_test.go @@ -0,0 +1,56 @@ +package policy + +import ( + "bytes" + "crypto/sha256" + "encoding/binary" + "math" + "strconv" + "testing" + + "github.com/lightninglabs/taproot-assets/address" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightningnetwork/lnd/tlv" + "github.com/stretchr/testify/require" +) + +// TestMalformedProofRecordLength rejects truncated TLV records without +// allocating their declared length. The proof file itself fits comfortably +// within the provenance budget, including its valid checksum. +func TestMalformedProofRecordLength(t *testing.T) { + for _, length := range []uint64{math.MaxInt64, math.MaxUint64} { + t.Run(strconv.FormatUint(length, 10), func(t *testing.T) { + var raw bytes.Buffer + raw.Write(proof.PrefixMagicBytes[:]) + var scratch [8]byte + require.NoError(t, tlv.WriteVarInt(&raw, 65535, &scratch)) + require.NoError(t, tlv.WriteVarInt(&raw, length, &scratch)) + + var file bytes.Buffer + file.Write(proof.FilePrefixMagicBytes[:]) + require.NoError(t, binary.Write( + &file, binary.BigEndian, uint32(proof.V0), + )) + require.NoError(t, tlv.WriteVarInt(&file, 1, &scratch)) + require.NoError(t, tlv.WriteVarInt( + &file, uint64(raw.Len()), &scratch, + )) + file.Write(raw.Bytes()) + var previous [sha256.Size]byte + hash := sha256.New() + hash.Write(previous[:]) + hash.Write(raw.Bytes()) + file.Write(hash.Sum(nil)) + + require.NoError(t, CheckProofFileSize(file.Bytes())) + decoded, err := proof.DecodeFile(file.Bytes()) + require.NoError(t, err) + require.NotPanics(t, func() { + err = ValidateProvenance( + t.Context(), decoded, &address.RegressionNetTap, + ) + }) + require.Error(t, err) + }) + } +} diff --git a/internal/assetpolicy/versions.go b/internal/assetpolicy/versions.go new file mode 100644 index 000000000..616abbe6b --- /dev/null +++ b/internal/assetpolicy/versions.go @@ -0,0 +1,75 @@ +// Package policy freezes the wire versions of the legacy asset contracts and +// the structural rules for accepting their proof histories. New contracts use +// V1 assets and addresses with V2 commitments. Legacy input assets and +// transition proofs remain accepted under the explicit rules below. The +// Taproot Assets v0.8.5 activation rules are applied to each proof's claimed +// block height, which only the full verifier authenticates. +package policy + +import ( + "fmt" + + "github.com/lightninglabs/taproot-assets/address" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/tappsbt" + "github.com/lightninglabs/taproot-assets/taprpc" +) + +const ( + // AddressVersion is the predictable non-interactive address format. + AddressVersion = address.V1 + + // AssetVersion is used for newly created contract asset leaves. + AssetVersion = asset.V1 + + // PacketVersion selects the commitment format of newly funded contracts. + PacketVersion = tappsbt.V1 + + // CommitmentVersion is required by PacketVersion. + CommitmentVersion = commitment.TapCommitmentV2 + + // ProofFileVersion is the only supported proof history container. + ProofFileVersion = proof.V0 + + // TransitionVersion includes the activation-required STXO proofs. + TransitionVersion = proof.TransitionV1 + + // RPCAssetVersion explicitly selects AssetVersion in address requests. + RPCAssetVersion = taprpc.AssetVersion_ASSET_VERSION_V1 + + // RPCAddressVersion explicitly selects AddressVersion in address requests. + RPCAddressVersion = taprpc.AddrVersion_ADDR_VERSION_V1 +) + +// ValidateTransitionVersion rejects unrecognized transition proof semantics +// even when only the commitment proofs, rather than the history, are checked. +func ValidateTransitionVersion(version proof.TransitionVersion) error { + if version != proof.TransitionV0 && version != TransitionVersion { + return fmt.Errorf("unsupported transition proof version %d", version) + } + return nil +} + +// SupportsAssetVersion permits the two historical asset leaf encodings. +func SupportsAssetVersion(version asset.Version) bool { + return version == asset.V0 || version == AssetVersion +} + +// SupportsPacketVersion permits both historical virtual packet encodings. +func SupportsPacketVersion(version tappsbt.VPacketVersion) bool { + return version == tappsbt.V0 || version == PacketVersion +} + +// ValidateCommitmentVersion permits the three historical commitment formats. +func ValidateCommitmentVersion(version commitment.TapCommitmentVersion) error { + switch version { + case commitment.TapCommitmentV0, commitment.TapCommitmentV1, + CommitmentVersion: + + return nil + default: + return fmt.Errorf("unsupported asset commitment version %d", version) + } +} diff --git a/internal/assetproof/anchor.go b/internal/assetproof/anchor.go new file mode 100644 index 000000000..e413b65e3 --- /dev/null +++ b/internal/assetproof/anchor.go @@ -0,0 +1,190 @@ +// Package assetproof checks the input inventory required by Loop contracts. +// Generic lineage and transition verification belongs to the SDK and tapd. +package assetproof + +import ( + "bytes" + "fmt" + + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/wire" + policy "github.com/lightninglabs/loop/internal/assetpolicy" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightninglabs/taproot-assets/proof" +) + +// VerifyCompleteAnchor requires a proof to disclose its entire anchor +// commitment, including alt leaves. This prevents a negotiated contract from +// hiding co-anchored assets whose owner could bypass its Bitcoin policy. +// It does not verify history, confirmation or current unspent status. +func VerifyCompleteAnchor(assetProof *proof.Proof) (*commitment.TapCommitment, + error) { + + if err := validateInventoryProof(assetProof); err != nil { + return nil, err + } + provenCommitment, err := assetProof.VerifyProofs() + if err != nil { + return nil, fmt.Errorf("invalid asset proof: %w", err) + } + if err := policy.ValidateCommitmentVersion(provenCommitment.Version); err != nil { + return nil, err + } + + // Rebuild the disclosed on-chain leaf and alt leaves at version two + // and then at the legacy versions. + anchorAsset := assetProof.Asset.Copy() + if anchorAsset.HasSplitCommitmentWitness() && + *anchorAsset.PrevWitnesses[0].PrevID == asset.ZeroPrevID { + + anchorAsset.PrevWitnesses[0].SplitCommitment = nil + } + version := policy.CommitmentVersion + rebuiltCommitment, err := commitment.FromAssets(&version, anchorAsset) + if err != nil { + return nil, fmt.Errorf("unable to rebuild asset anchor: %w", err) + } + err = rebuiltCommitment.MergeAltLeaves( + asset.CopyAltLeaves(assetProof.AltLeaves), + ) + if err != nil { + return nil, fmt.Errorf("invalid asset proof alt leaves: %w", err) + } + + provenRoot := provenCommitment.TapscriptRoot(nil) + if rebuiltCommitment.TapscriptRoot(nil) == provenRoot { + return provenCommitment, nil + } + legacyCommitment, err := rebuiltCommitment.Downgrade() + if err != nil { + return nil, fmt.Errorf("unable to rebuild legacy asset anchor: %w", + err) + } + if legacyCommitment.TapscriptRoot(nil) != provenRoot { + return nil, fmt.Errorf("asset anchor does not match the proven " + + "asset and alt leaves") + } + + return provenCommitment, nil +} + +// VerifyCompleteAnchors checks the union of disclosed active and passive assets +// at each input anchor. A native SDK request can preserve known co-anchored +// assets by supplying all their proofs; an undisclosed asset is rejected. +// This does not establish lineage, chain inclusion or current spendability. +func VerifyCompleteAnchors(proofs []*proof.Proof) error { + if len(proofs) == 0 { + return fmt.Errorf("asset input inventory is required") + } + groups := make(map[wire.OutPoint][]*proof.Proof) + for _, p := range proofs { + if err := validateInventoryProof(p); err != nil { + return err + } + groups[p.OutPoint()] = append(groups[p.OutPoint()], p) + } + for point, group := range groups { + if len(group) == 1 { + if _, err := VerifyCompleteAnchor(group[0]); err != nil { + return fmt.Errorf("input anchor %v: %w", point, err) + } + continue + } + if err := verifyDisclosedAnchor(group); err != nil { + return fmt.Errorf("input anchor %v: %w", point, err) + } + } + return nil +} + +func validateInventoryProof(p *proof.Proof) error { + if p == nil || p.InclusionProof.CommitmentProof == nil || + p.InclusionProof.InternalKey == nil || p.Asset.ScriptKey.PubKey == nil { + + return fmt.Errorf("complete asset inclusion proof is required") + } + if err := policy.ValidateTransitionVersion(p.Version); err != nil { + return err + } + if !policy.SupportsAssetVersion(p.Asset.Version) { + return fmt.Errorf("unsupported input asset version %d", p.Asset.Version) + } + for _, witness := range p.Asset.PrevWitnesses { + if witness.SplitCommitment != nil && + (witness.PrevID == nil || + witness.SplitCommitment.RootAsset.ScriptKey.PubKey == nil) { + + return fmt.Errorf("split asset witness is incomplete") + } + } + return nil +} + +func verifyDisclosedAnchor(proofs []*proof.Proof) error { + var disclosed []*asset.Asset + altLeaves := make(map[[32]byte]asset.AltLeaf[asset.Asset]) + var expectedRoot chainhash.Hash + for idx, p := range proofs { + proven, err := p.VerifyProofs() + if err != nil { + return err + } + if err := policy.ValidateCommitmentVersion(proven.Version); err != nil { + return err + } + root := proven.TapscriptRoot(nil) + if idx == 0 { + expectedRoot = root + } else if root != expectedRoot { + return fmt.Errorf("disclosed assets disagree on their anchor root") + } + a := p.Asset.Copy() + if a.HasSplitCommitmentWitness() && + *a.PrevWitnesses[0].PrevID == asset.ZeroPrevID { + + a.PrevWitnesses[0].SplitCommitment = nil + } + disclosed = append(disclosed, a) + for _, alt := range p.AltLeaves { + key := alt.AssetCommitmentKey() + if previous, ok := altLeaves[key]; ok { + var old, next bytes.Buffer + if err := previous.EncodeAltLeaf(&old); err != nil { + return err + } + if err := alt.EncodeAltLeaf(&next); err != nil { + return err + } + if !bytes.Equal(old.Bytes(), next.Bytes()) { + return fmt.Errorf("conflicting disclosed alt leaves") + } + } else { + altLeaves[key] = alt.Copy() + } + } + } + version := policy.CommitmentVersion + rebuilt, err := commitment.FromAssets(&version, disclosed...) + if err != nil { + return err + } + leaves := make([]asset.AltLeaf[asset.Asset], 0, len(altLeaves)) + for _, leaf := range altLeaves { + leaves = append(leaves, leaf) + } + if err := rebuilt.MergeAltLeaves(leaves); err != nil { + return err + } + if rebuilt.TapscriptRoot(nil) == expectedRoot { + return nil + } + legacy, err := rebuilt.Downgrade() + if err != nil { + return err + } + if legacy.TapscriptRoot(nil) != expectedRoot { + return fmt.Errorf("input anchor contains undisclosed asset leaves") + } + return nil +} diff --git a/internal/assetproof/anchor_test.go b/internal/assetproof/anchor_test.go new file mode 100644 index 000000000..c98913ff3 --- /dev/null +++ b/internal/assetproof/anchor_test.go @@ -0,0 +1,95 @@ +package assetproof + +import ( + "slices" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/stretchr/testify/require" +) + +func inventoryProofs(t *testing.T, seed byte, count int) []*proof.Proof { + t.Helper() + genesis := asset.Genesis{ + FirstPrevOut: wire.OutPoint{Hash: chainhash.Hash{seed}, Index: 1}, + Tag: "inventory", Type: asset.Normal, + } + assets := make([]*asset.Asset, count) + for idx := range assets { + _, key := btcec.PrivKeyFromBytes([]byte{byte(idx + 1)}) + a, err := asset.New(genesis, 500, 0, 0, asset.NewScriptKey(key), + nil, asset.WithAssetVersion(asset.V1)) + require.NoError(t, err) + assets[idx] = a + } + version := commitment.TapCommitmentV2 + tree, err := commitment.FromAssets(&version, assets...) + require.NoError(t, err) + _, internal := btcec.PrivKeyFromBytes([]byte{20}) + root := tree.TapscriptRoot(nil) + key := txscript.ComputeTaprootOutputKey(internal, root[:]) + script, err := txscript.PayToTaprootScript(key) + require.NoError(t, err) + anchor := wire.NewMsgTx(2) + anchor.AddTxIn(wire.NewTxIn(&genesis.FirstPrevOut, nil, nil)) + anchor.AddTxOut(wire.NewTxOut(1_000, script)) + block := &wire.MsgBlock{Header: wire.BlockHeader{ + MerkleRoot: anchor.TxHash(), Nonce: uint32(seed), + }, Transactions: []*wire.MsgTx{anchor}} + blobs, err := proof.NewMintingBlobs(&proof.MintParams{ + Block: block, BlockHeight: 101, Tx: anchor, + TxIndex: 0, OutputIndex: 0, InternalKey: internal, + TaprootAssetRoot: tree, GenesisPoint: genesis.FirstPrevOut, + }, proof.MockVerifierCtx, + proof.WithGenOption(proof.WithVersion(proof.TransitionV1))) + require.NoError(t, err) + proofs := make([]*proof.Proof, count) + for idx, a := range assets { + proofs[idx] = blobs[asset.ToSerialized(a.ScriptKey.PubKey)] + require.NotNil(t, proofs[idx]) + } + return proofs +} + +// TestDisclosedInventory proves that a known passive asset can be preserved, +// while a hidden co-anchor cannot authorize a supposedly complete transfer. +func TestDisclosedInventory(t *testing.T) { + single := inventoryProofs(t, 1, 1) + require.NoError(t, VerifyCompleteAnchors(single)) + _, err := VerifyCompleteAnchor(single[0]) + require.NoError(t, err) + coanchored := inventoryProofs(t, 2, 2) + require.Error(t, VerifyCompleteAnchors(coanchored[:1])) + _, err = VerifyCompleteAnchor(coanchored[0]) + require.Error(t, err) + require.NoError(t, VerifyCompleteAnchors(coanchored)) + combined := slices.Concat(single, coanchored) + require.NoError(t, VerifyCompleteAnchors(combined)) + wrong := inventoryProofs(t, 3, 1) + require.Error(t, VerifyCompleteAnchors([]*proof.Proof{ + coanchored[0], wrong[0], + })) +} + +// TestMalformedInventory verifies rejection before commitment code can +// dereference omitted untrusted proof fields. +func TestMalformedInventory(t *testing.T) { + require.Error(t, VerifyCompleteAnchors(nil)) + malformedSplit := inventoryProofs(t, 1, 1)[0] + malformedSplit.Asset.PrevWitnesses = []asset.Witness{{ + SplitCommitment: &asset.SplitCommitment{}, + }} + for _, p := range []*proof.Proof{nil, {}, malformedSplit} { + require.NotPanics(t, func() { + _, err := VerifyCompleteAnchor(p) + require.Error(t, err) + require.Error(t, VerifyCompleteAnchors([]*proof.Proof{p})) + }) + } +} diff --git a/swapkit/asset_types.go b/swapkit/asset_types.go index aad7dee9c..a14fd54b6 100644 --- a/swapkit/asset_types.go +++ b/swapkit/asset_types.go @@ -8,3 +8,18 @@ var ( ErrInvalid = errors.New("invalid asset transaction") ErrPending = errors.New("asset transaction pending") ) + +// CreateDepositRequest binds idempotent deposit funding to wallet key locators. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type CreateDepositRequest struct { + RequestID [32]byte `json:"RequestID"` + GroupKey [33]byte `json:"GroupKey"` + Amount uint64 `json:"Amount"` + // #nosec G117 -- ClientKey is a public Bitcoin key. + ClientKey [33]byte `json:"ClientKey"` + ServerKey [33]byte `json:"ServerKey"` + CSV uint32 `json:"CSV"` + KeyFamily int32 `json:"KeyFamily"` + KeyIndex uint32 `json:"KeyIndex"` +} diff --git a/swapkit/tapsdk/asset.go b/swapkit/tapsdk/asset.go index 7cedffd98..4690da8c5 100644 --- a/swapkit/tapsdk/asset.go +++ b/swapkit/tapsdk/asset.go @@ -104,3 +104,35 @@ func OPTrueSpendInfo(output sdk.CustomAnchorAssetOutputSummary) ( } return spend, nil } + +// AssetInput supplies a proof-selected OP_TRUE asset to the native SDK. This +// binds the exact issuance, quantity, outpoint and script key before generic +// SDK proof verification; the FSM still checks the current chain and contract. +func AssetInput(output sdk.CustomAnchorAssetOutputSummary, + raw []byte) (sdk.CustomAssetInput, error) { + + spend, err := OPTrueSpendInfo(output) + if err != nil { + return sdk.CustomAssetInput{}, err + } + p, err := LastProof(raw) + if err != nil { + return sdk.CustomAssetInput{}, err + } + if sdk.AssetID(p.Asset.ID()) != output.IssuanceID || + p.Asset.Amount != output.Amount || + p.OutPoint() != SDKPoint(output.AnchorOutpoint) || + !bytes.Equal(p.Asset.ScriptKey.PubKey.SerializeCompressed()[1:], + output.ScriptKey[1:]) { + + return sdk.CustomAssetInput{}, swapkit.ErrInvalid + } + return sdk.CustomAssetInput{ + ID: output.LogicalOutputID, AssetRef: output.AssetRef, + Amount: output.Amount, ProofFile: bytes.Clone(raw), + Witness: sdk.CustomAssetWitnessPlan{ + Mode: sdk.CustomAssetWitnessCallerProvided, + Stack: spend.WitnessStack(), + }, + }, nil +} diff --git a/swapkit/tapsdk/binding_test.go b/swapkit/tapsdk/binding_test.go index 2bf489a73..aa01f0dd7 100644 --- a/swapkit/tapsdk/binding_test.go +++ b/swapkit/tapsdk/binding_test.go @@ -1,7 +1,206 @@ package tapsdk import ( + "context" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/tapsend" + "github.com/stretchr/testify/require" ) +// bindingSDK models successful authenticated tapd proof verification. These +// tests exercise the Loop contract's additional policy and current-chain checks, +// which must reject even a cryptographically valid proof for another contract. +type bindingSDK struct { + sdk.Client + + valid bool +} + +func (s *bindingSDK) VerifyProof(_ context.Context, + raw []byte) (*sdk.VerifyProofResponse, error) { + + return fixtureVerified(raw, s.valid) +} + +type bindingChain struct { + Chain + + tip uint32 + blocks map[uint32]*wire.MsgBlock + unspent bool +} + +func (c *bindingChain) Height(context.Context) (uint32, error) { + return c.tip, nil +} + +func (c *bindingChain) Block(_ context.Context, + height uint32) (*wire.MsgBlock, error) { + + block := c.blocks[height] + if block == nil { + return nil, swapkit.ErrPending + } + return block, nil +} + +func (c *bindingChain) BlockHash(ctx context.Context, + height uint32) (chainhash.Hash, error) { + + block, err := c.Block(ctx, height) + if err != nil { + return chainhash.Hash{}, err + } + return block.BlockHash(), nil +} + +func (c *bindingChain) Unspent(context.Context, + wire.OutPoint) (bool, error) { + + return c.unspent, nil +} + +func bindingKey(scalar byte) *btcec.PrivateKey { + key, _ := btcec.PrivKeyFromBytes([]byte{scalar}) + return key +} + +func bindingPub(scalar byte) [33]byte { + var key [33]byte + copy(key[:], bindingKey(scalar).PubKey().SerializeCompressed()) + return key +} + +// bindingProof constructs a real isolated Taproot commitment; an optional +// second asset deliberately makes reconstruction from the disclosed one fail. +func bindingProof(t *testing.T, genesis asset.Genesis, script, + internal *btcec.PublicKey, sibling *commitment.TapscriptPreimage, + previous wire.OutPoint, height uint32, hidden bool) *proof.Proof { + + t.Helper() + group := &asset.GroupKey{GroupPubKey: *bindingKey(11).PubKey()} + a, err := asset.New(genesis, 1000, 0, 0, + asset.NewScriptKey(script), group, + asset.WithAssetVersion(asset.V1)) + require.NoError(t, err) + assets := []*asset.Asset{a} + if hidden { + otherGenesis := genesis + otherGenesis.Tag += "-hidden" + other, err := asset.New(otherGenesis, 1, 0, 0, + asset.NewScriptKey(bindingKey(9).PubKey()), nil, + asset.WithAssetVersion(asset.V1)) + require.NoError(t, err) + assets = append(assets, other) + } + version := commitment.TapCommitmentV2 + tree, err := commitment.FromAssets(&version, assets...) + require.NoError(t, err) + _, inclusion, err := tree.Proof(a.TapCommitmentKey(), + a.AssetCommitmentKey()) + require.NoError(t, err) + pkScript, _, _, err := tapsend.AnchorOutputScript( + internal, sibling, tree, + ) + require.NoError(t, err) + tx := wire.NewMsgTx(2) + tx.AddTxIn(wire.NewTxIn(&previous, nil, nil)) + tx.AddTxOut(wire.NewTxOut(10_000, pkScript)) + return &proof.Proof{ + PrevOut: previous, AnchorTx: *tx, Asset: *a, + BlockHeight: height, + BlockHeader: wire.BlockHeader{MerkleRoot: tx.TxHash()}, + InclusionProof: proof.TaprootProof{ + InternalKey: internal, OutputIndex: 0, + CommitmentProof: &proof.CommitmentProof{ + Proof: *inclusion, TapSiblingPreimage: sibling, + }, + }, + GenesisReveal: &genesis, + } +} + +func bindingGenesis() asset.Genesis { + return asset.Genesis{ + FirstPrevOut: wire.OutPoint{Hash: chainhash.Hash{7}}, + Tag: "binding-test", Type: asset.Normal, + } +} + +func bindingRaw(t *testing.T, p *proof.Proof) []byte { + t.Helper() + raw, err := proof.EncodeAsProofFile(p) + require.NoError(t, err) + return raw +} + +func bindingBlock(p *proof.Proof) *wire.MsgBlock { + return &wire.MsgBlock{ + Header: p.BlockHeader, Transactions: []*wire.MsgTx{&p.AnchorTx}, + } +} + +// proofNode holds only test services. Tests call production primitives directly. +type proofNode struct { + client sdk.Client + chain Chain + minConfs uint32 +} + +func (n *proofNode) wallet() *sdk.Wallet { + return sdk.NewWallet(n.client, sdk.NetworkRegtest) +} + +func (s *bindingSDK) GetInfo( + context.Context, +) (*sdk.Info, error) { + + return fixtureNodeInfo(), nil +} + func fixtureNodeInfo() *sdk.Info { return &sdk.Info{Version: "0.8.8", Network: "regtest"} } + +func fixtureVerified(raw []byte, valid bool) (*sdk.VerifyProofResponse, error) { + p, err := LastProof(raw) + if err != nil { + return nil, err + } + key, err := sdk.ParsePubKey( + p.Asset.ScriptKey.PubKey.SerializeCompressed(), + ) + if err != nil { + return nil, err + } + var group *sdk.PubKey + if p.Asset.GroupKey != nil { + k, err := sdk.ParsePubKey( + p.Asset.GroupKey.GroupPubKey.SerializeCompressed(), + ) + if err != nil { + return nil, err + } + group = &k + } + return &sdk.VerifyProofResponse{ + Valid: valid, + DecodedProof: &sdk.DecodedProof{ + AssetRef: sdk.AssetRefFromTypedAsset( + sdk.AssetID(p.Asset.ID()), + group, + sdk.AssetType(p.Asset.Type), + ), + IssuanceID: sdk.AssetID(p.Asset.ID()), + Amount: p.Asset.Amount, ScriptKey: key, + Outpoint: sdk.Outpoint{Txid: sdk.Hash(p.OutPoint().Hash), Index: p.OutPoint().Index}, + }, + }, nil +} diff --git a/swapkit/tapsdk/bindings.go b/swapkit/tapsdk/bindings.go new file mode 100644 index 000000000..b2577b7be --- /dev/null +++ b/swapkit/tapsdk/bindings.go @@ -0,0 +1,314 @@ +package tapsdk + +import ( + "bytes" + "context" + "fmt" + "math" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/txscript" + assetpolicy "github.com/lightninglabs/loop/internal/assetpolicy" + "github.com/lightninglabs/loop/internal/assetproof" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/proof" +) + +// InputBinding contains independently agreed terms for one exact issuance and +// anchor. A nil GroupKey requires an ungrouped asset. Anchor and OPTrue describe +// contract inputs; Spend optionally fixes a unilateral Bitcoin path. These are +// operation-local policy inputs, not another transfer or persistence format. +type InputBinding struct { + ID string + IssuanceID sdk.AssetID + GroupKey *sdk.PubKey + Amount uint64 + ScriptKey sdk.PubKey + AnchorOutpoint sdk.Outpoint + Anchor *swapkit.AnchorPlan + OPTrue *sdk.CustomAssetOPTrueSpendInfo + Spend *swapkit.SwapAnchorSpendInfo +} + +func (b InputBinding) clone() InputBinding { + if b.GroupKey != nil { + b.GroupKey = new(*b.GroupKey) + } + if b.Anchor != nil { + b.Anchor = cloneAnchor(*b.Anchor) + } + b.OPTrue = b.OPTrue.Clone() + if b.Spend != nil { + spend := *b.Spend + spend.PkScript = bytes.Clone(spend.PkScript) + spend.LeafScript = bytes.Clone(spend.LeafScript) + spend.ControlBlock = bytes.Clone(spend.ControlBlock) + b.Spend = &spend + } + return b +} + +func cloneAnchor(a swapkit.AnchorPlan) *swapkit.AnchorPlan { + leaves := make([][]byte, len(a.Leaves)) + for i := range a.Leaves { + leaves[i] = bytes.Clone(a.Leaves[i]) + } + a.Leaves = leaves + return &a +} + +func (b InputBinding) validate(p *proof.Proof) error { + if p == nil || b.Amount > math.MaxInt64 { + return swapkit.ErrInvalid + } + if err := p.Asset.Validate(); err != nil { + return err + } + if b.ID == "" || b.IssuanceID == (sdk.AssetID{}) || b.Amount == 0 || + sdk.AssetID(p.Asset.ID()) != b.IssuanceID || + p.Asset.Amount != b.Amount || + p.OutPoint() != SDKPoint(b.AnchorOutpoint) || + !bytes.Equal(p.Asset.ScriptKey.PubKey.SerializeCompressed()[1:], b.ScriptKey[1:]) { + + return fmt.Errorf( + "%w: asset differs from agreed input", + swapkit.ErrInvalid, + ) + } + if _, err := btcec.ParsePubKey(b.ScriptKey[:]); err != nil { + return err + } + group := p.Asset.GroupKey + if (group == nil) != (b.GroupKey == nil) || (group != nil && + !sameGroupKeys(group.GroupPubKey.SerializeCompressed(), b.GroupKey[:])) { + + return fmt.Errorf( + "%w: asset differs from agreed group", + swapkit.ErrInvalid, + ) + } + if p.Asset.ScriptVersion != asset.ScriptV0 || p.Asset.LockTime != 0 || + p.Asset.RelativeLockTime != 0 { + + return fmt.Errorf( + "%w: contract asset has unsupported timelocks", + swapkit.ErrInvalid, + ) + } + if b.Anchor == nil { + if b.Spend != nil || b.OPTrue != nil { + return fmt.Errorf( + "wallet input cannot select a contract spend", + ) + } + return nil + } + if _, err := OPTrueSpendInfo(sdk.CustomAnchorAssetOutputSummary{ + ScriptKey: b.ScriptKey, ScriptMode: sdk.CustomAssetScriptExternal, OPTrueSpend: b.OPTrue, + }); err != nil { + return err + } + assets, root, err := proofRoots(p) + if err != nil { + return err + } + script, err := anchorScript(*b.Anchor, assets) + if err != nil { + return err + } + point := p.OutPoint() + if point.Index >= uint32(len(p.AnchorTx.TxOut)) || + p.AnchorTx.TxOut[point.Index] == nil || !bytes.Equal(script, p.AnchorTx.TxOut[point.Index].PkScript) { + + return fmt.Errorf( + "%w: input anchor differs from contract", + swapkit.ErrInvalid, + ) + } + if b.Spend != nil && + (!bytes.Equal(b.Spend.PkScript, script) || sdk.Hash(b.Spend.TaprootMerkleRoot) != root) { + + return fmt.Errorf( + "%w: spend differs from contract root", + swapkit.ErrInvalid, + ) + } + return nil +} + +func anchorScript(a swapkit.AnchorPlan, assets sdk.Hash) ([]byte, error) { + internal, err := btcec.ParsePubKey(a.InternalKey[:]) + if err != nil { + return nil, err + } + root := chainhash.Hash(assets) + if len(a.Leaves) > 0 { + leaves := make([]txscript.TapLeaf, len(a.Leaves)) + for i, script := range a.Leaves { + if len(script) == 0 { + return nil, fmt.Errorf("empty contract leaf") + } + leaves[i] = txscript.NewBaseTapLeaf(script) + } + sibling := txscript.AssembleTaprootScriptTree( + leaves...).RootNode.TapHash() + root = asset.TapBranchHash(chainhash.Hash(assets), sibling) + } + return txscript.PayToTaprootScript( + txscript.ComputeTaprootOutputKey(internal, root[:]), + ) +} + +// IsolatedAssetRoot checks the exact input binding and requires the disclosed +// asset to open the entire anchor. It returns the asset commitment root for +// constructing a contract witness. The caller verifies history and chain state. +func (b InputBinding) IsolatedAssetRoot(p *proof.Proof) (sdk.Hash, error) { + if err := b.validate(p); err != nil { + return sdk.Hash{}, err + } + assets, _, err := isolatedRoots(p) + return assets, err +} + +// InspectInputProof checks exact contract terms and current-chain policy before +// native SDK Build verifies the full lineage. It does not authorize a spend. +func InspectInputProof( + ctx context.Context, + wallet *sdk.Wallet, + chain Chain, + minConfs uint32, + raw []byte, + binding InputBinding, + unspent bool, +) (*proof.Proof, error) { + + if err := assetpolicy.CheckProofFileSize(raw); err != nil { + return nil, err + } + raw = bytes.Clone(raw) + binding = binding.clone() + if err := checkProvenance(ctx, wallet, raw); err != nil { + return nil, err + } + p, err := LastProof(raw) + if err != nil { + return nil, err + } + if _, err := binding.IsolatedAssetRoot(p); err != nil { + return nil, err + } + if err := checkConfirmation(ctx, chain, minConfs, p, unspent); err != nil { + return nil, err + } + return p, nil +} + +// VerifyInputProof validates negotiated input policy and asks authenticated +// tapd to verify lineage exactly once, bracketed by current-chain checks. +func VerifyInputProof( + ctx context.Context, + wallet *sdk.Wallet, + chain Chain, + minConfs uint32, + raw []byte, + binding InputBinding, + unspent bool, +) (*proof.Proof, error) { + + if err := assetpolicy.CheckProofFileSize(raw); err != nil { + return nil, err + } + raw = bytes.Clone(raw) + p, err := InspectInputProof( + ctx, + wallet, + chain, + minConfs, + raw, + binding, + unspent, + ) + if err != nil { + return nil, err + } + result, err := wallet.Client().VerifyProof(ctx, bytes.Clone(raw)) + if err != nil { + return nil, err + } + if err := checkVerifiedSummary(result, p); err != nil { + return nil, err + } + if err := checkConfirmation(ctx, chain, minConfs, p, unspent); err != nil { + return nil, err + } + return p, nil +} + +// InspectInputProofs checks all active and passive bindings as a single anchor +// inventory. Unlike the single-input helper, it accepts disclosed co-anchored +// assets when their union opens the complete commitment. Include every active +// and passive proof and binding; omitted assets fail closed before SDK Build. +func InspectInputProofs( + ctx context.Context, + wallet *sdk.Wallet, + chain Chain, + minConfs uint32, + raws [][]byte, + bindings []InputBinding, + unspent bool, +) ([]*proof.Proof, error) { + + if len(raws) == 0 || len(raws) != len(bindings) { + return nil, swapkit.ErrInvalid + } + var total int + for _, raw := range raws { + if len(raw) > assetpolicy.MaxProvenanceBytes-total { + return nil, fmt.Errorf( + "proof inventory exceeds size budget", + ) + } + total += len(raw) + } + snapshots := make([]InputBinding, len(bindings)) + copied := make([][]byte, len(raws)) + for i, binding := range bindings { + snapshots[i] = binding.clone() + copied[i] = bytes.Clone(raws[i]) + } + bindings, raws = snapshots, copied + params, err := nodeParams(ctx, wallet) + if err != nil { + return nil, err + } + proofs := make([]*proof.Proof, len(raws)) + ids := make(map[string]bool) + for i, raw := range raws { + binding := bindings[i].clone() + if ids[binding.ID] { + return nil, fmt.Errorf("duplicate input binding") + } + ids[binding.ID] = true + if err := checkProvenanceWithParams(ctx, raw, params); err != nil { + return nil, err + } + p, err := LastProof(raw) + if err != nil { + return nil, err + } + if err := binding.validate(p); err != nil { + return nil, err + } + if err := checkConfirmation(ctx, chain, minConfs, p, unspent); err != nil { + return nil, err + } + proofs[i] = p + } + if err := assetproof.VerifyCompleteAnchors(proofs); err != nil { + return nil, err + } + return proofs, nil +} diff --git a/swapkit/tapsdk/chain.go b/swapkit/tapsdk/chain.go new file mode 100644 index 000000000..80dd5ddad --- /dev/null +++ b/swapkit/tapsdk/chain.go @@ -0,0 +1,173 @@ +package tapsdk + +import ( + "context" + "math" + "time" + + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/lndclient" + "github.com/lightninglabs/loop/swapkit" +) + +// Chain uses the daemon's chain services. Unspent includes mempool spends; +// notifications may be restored from their original height hints after restart. +type Chain interface { + Height(context.Context) (uint32, error) + BlockHash(context.Context, uint32) (chainhash.Hash, error) + Unspent(context.Context, wire.OutPoint) (bool, error) + Block(context.Context, uint32) (*wire.MsgBlock, error) + Spend(context.Context, wire.OutPoint, []byte, uint32) ( + *wire.MsgBlock, uint32, error) +} + +// LNDChain reuses the normal daemon's authenticated LND services. The UTXO +// callback must query its Bitcoin backend with mempool lookup enabled: wallet +// ListUnspent does not cover every externally controlled asset anchor. Chain +// observations are read afresh on each call; the adapter keeps no cached state. +type LNDChain struct { + Kit lndclient.ChainKitClient + Notifier lndclient.ChainNotifierClient + UnspentOutput func(context.Context, wire.OutPoint) (bool, error) + // PrevOutput supplies authenticated full prevouts for fee review and can + // also back Unspent when no separate existence callback is configured. + PrevOutput func(context.Context, wire.OutPoint) (*wire.TxOut, error) +} + +// Height returns LND's current best-chain height. +func (c *LNDChain) Height(ctx context.Context) (uint32, error) { + if c == nil || c.Kit == nil { + return 0, swapkit.ErrInvalid + } + _, height, err := c.Kit.GetBestBlock(ctx) + if err != nil { + return 0, err + } + if height < 0 { + return 0, swapkit.ErrInvalid + } + return uint32(height), nil +} + +// BlockHash reads the block at a height from the current best chain without +// downloading its transactions. Proofs carry their own transaction merkle path. +func (c *LNDChain) BlockHash(ctx context.Context, + height uint32) (chainhash.Hash, error) { + + if c == nil || c.Kit == nil { + return chainhash.Hash{}, swapkit.ErrInvalid + } + return c.Kit.GetBlockHash(ctx, int64(height)) +} + +// Unspent checks the current chain and mempool through the configured backend. +func (c *LNDChain) Unspent(ctx context.Context, + point wire.OutPoint) (bool, error) { + + if c == nil { + return false, swapkit.ErrInvalid + } + if c.UnspentOutput != nil { + return c.UnspentOutput(ctx, point) + } + output, err := c.Prevout(ctx, point) + return output != nil, err +} + +// Prevout supplies the full current Bitcoin output for native funding review. +func (c *LNDChain) Prevout( + ctx context.Context, + point wire.OutPoint, +) (*wire.TxOut, error) { + + if c == nil || c.PrevOutput == nil { + return nil, swapkit.ErrInvalid + } + return c.PrevOutput(ctx, point) +} + +// Block obtains a block from the current best chain, checking its identity. +func (c *LNDChain) Block(ctx context.Context, + height uint32) (*wire.MsgBlock, error) { + + if c == nil || c.Kit == nil { + return nil, swapkit.ErrInvalid + } + hash, err := c.BlockHash(ctx, height) + if err != nil { + return nil, err + } + block, err := c.Kit.GetBlock(ctx, hash) + if err != nil { + return nil, err + } + if block == nil || block.BlockHash() != hash { + return nil, swapkit.ErrInvalid + } + return block, nil +} + +// Spend restores a spend watch from the persisted outpoint and height hint. +// The returned transaction is checked against the current best-chain block; +// a stale notifier response never becomes confirmation evidence. +func (c *LNDChain) Spend(ctx context.Context, point wire.OutPoint, + pkScript []byte, hint uint32) (*wire.MsgBlock, uint32, error) { + + if c == nil || c.Kit == nil || c.Notifier == nil || + hint > math.MaxInt32 || len(pkScript) == 0 { + + return nil, 0, swapkit.ErrInvalid + } + probe, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + spent, failed, err := c.Notifier.RegisterSpendNtfn( + probe, &point, pkScript, int32(hint), + ) + if err != nil { + return nil, 0, err + } + select { + case detail, ok := <-spent: + if !ok || detail == nil || detail.SpendingTx == nil || + detail.SpendingHeight < 0 { + + return nil, 0, swapkit.ErrInvalid + } + height := uint32(detail.SpendingHeight) + block, err := c.Block(ctx, height) + if err != nil { + return nil, 0, err + } + transaction := spendingTransaction(block, point) + if transaction == nil || + transaction.TxHash() != detail.SpendingTx.TxHash() { + + return nil, 0, swapkit.ErrPending + } + return block, height, nil + case err := <-failed: + if err == nil { + err = swapkit.ErrPending + } + return nil, 0, err + case <-probe.Done(): + if ctx.Err() != nil { + return nil, 0, ctx.Err() + } + return nil, 0, swapkit.ErrPending + } +} + +func spendingTransaction(block *wire.MsgBlock, + point wire.OutPoint) *wire.MsgTx { + + for _, tx := range block.Transactions { + for _, input := range tx.TxIn { + if input.PreviousOutPoint == point { + return tx + } + } + } + return nil +} diff --git a/swapkit/tapsdk/chain_guard_test.go b/swapkit/tapsdk/chain_guard_test.go new file mode 100644 index 000000000..75652f62e --- /dev/null +++ b/swapkit/tapsdk/chain_guard_test.go @@ -0,0 +1,97 @@ +package tapsdk + +import ( + "context" + "testing" + + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + "github.com/stretchr/testify/require" +) + +type currentChainKit struct { + *testChainKit + + height int32 +} + +func (k *currentChainKit) GetBestBlock(context.Context) ( + chainhash.Hash, int32, error) { + + return k.hash, k.height, nil +} + +func TestLNDChainReadsCurrentBackend(t *testing.T) { + chain, _, point := chainFixture() + kit := ¤tChainKit{ + testChainKit: chain.Kit.(*testChainKit), height: 200, + } + chain.Kit = kit + for _, height := range []int32{200, 201} { + kit.height = height + actual, err := chain.Height(t.Context()) + require.NoError(t, err) + require.EqualValues(t, height, actual) + } + block, err := chain.Block(t.Context(), 200) + require.NoError(t, err) + previousHash := block.BlockHash() + kit.block.Header.Nonce++ + kit.hash = kit.block.BlockHash() + block, err = chain.Block(t.Context(), 200) + require.NoError(t, err) + require.NotEqual(t, previousHash, block.BlockHash()) + + for _, available := range []bool{true, false} { + chain.UnspentOutput = func(_ context.Context, + actual wire.OutPoint) (bool, error) { + + require.Equal(t, point, actual) + return available, nil + } + chain.PrevOutput = func(_ context.Context, + actual wire.OutPoint) (*wire.TxOut, error) { + + require.Equal(t, point, actual) + if !available { + return nil, nil + } + return wire.NewTxOut(500, []byte{0x51}), nil + } + unspent, err := chain.Unspent(t.Context(), point) + require.NoError(t, err) + require.Equal(t, available, unspent) + // A full mempool-aware prevout lookup is enough to configure both + // current funding authentication and current spendability. + chain.UnspentOutput = nil + unspent, err = chain.Unspent(t.Context(), point) + require.NoError(t, err) + require.Equal(t, available, unspent) + previous, err := chain.Prevout(t.Context(), point) + require.NoError(t, err) + if available { + require.Equal(t, int64(500), previous.Value) + } else { + require.Nil(t, previous) + } + } +} + +func TestLNDChainRejectsMissingServices(t *testing.T) { + var missing *LNDChain + for _, chain := range []*LNDChain{missing, {}} { + _, err := chain.Height(t.Context()) + require.ErrorIs(t, err, swapkit.ErrInvalid) + _, err = chain.Block(t.Context(), 1) + require.ErrorIs(t, err, swapkit.ErrInvalid) + _, err = chain.BlockHash(t.Context(), 1) + require.ErrorIs(t, err, swapkit.ErrInvalid) + _, err = chain.Unspent(t.Context(), wire.OutPoint{}) + require.ErrorIs(t, err, swapkit.ErrInvalid) + _, err = chain.Prevout(t.Context(), wire.OutPoint{}) + require.ErrorIs(t, err, swapkit.ErrInvalid) + _, _, err = chain.Spend(t.Context(), wire.OutPoint{}, []byte{0x51}, 1) + require.ErrorIs(t, err, swapkit.ErrInvalid) + } +} diff --git a/swapkit/tapsdk/chain_test.go b/swapkit/tapsdk/chain_test.go new file mode 100644 index 000000000..ecaaf3ab2 --- /dev/null +++ b/swapkit/tapsdk/chain_test.go @@ -0,0 +1,147 @@ +package tapsdk + +import ( + "context" + "testing" + "time" + + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/lndclient" + "github.com/lightninglabs/loop/swapkit" + "github.com/lightningnetwork/lnd/chainntnfs" + "github.com/stretchr/testify/require" +) + +type testChainKit struct { + lndclient.ChainKitClient + + block *wire.MsgBlock + hash chainhash.Hash +} + +func (k *testChainKit) GetBlockHash(context.Context, int64) ( + chainhash.Hash, error) { + + return k.hash, nil +} + +func (k *testChainKit) GetBlock(context.Context, chainhash.Hash) ( + *wire.MsgBlock, error) { + + return k.block, nil +} + +type testChainNotifier struct { + lndclient.ChainNotifierClient + + spend *chainntnfs.SpendDetail + point wire.OutPoint + script []byte + hint int32 + entered chan struct{} +} + +func (n *testChainNotifier) RegisterSpendNtfn(_ context.Context, + point *wire.OutPoint, script []byte, hint int32, + _ ...lndclient.NotifierOption) (chan *chainntnfs.SpendDetail, + chan error, error) { + + n.point, n.script, n.hint = *point, script, hint + spends := make(chan *chainntnfs.SpendDetail, 1) + if n.spend != nil { + spends <- n.spend + } + if n.entered != nil { + close(n.entered) + } + return spends, make(chan error), nil +} + +func chainFixture() (*LNDChain, *testChainNotifier, wire.OutPoint) { + point := wire.OutPoint{Hash: chainhash.Hash{7}, Index: 1} + tx := wire.NewMsgTx(2) + tx.AddTxIn(wire.NewTxIn(&point, nil, nil)) + tx.AddTxOut(wire.NewTxOut(500, []byte{0x51})) + block := &wire.MsgBlock{ + Header: wire.BlockHeader{MerkleRoot: tx.TxHash()}, + Transactions: []*wire.MsgTx{tx}, + } + n := &testChainNotifier{spend: &chainntnfs.SpendDetail{ + SpendingTx: tx, SpendingHeight: 200, + }} + return &LNDChain{ + Kit: &testChainKit{block: block, hash: block.BlockHash()}, + Notifier: n, + }, n, point +} + +// TestSpendRecoveryUsesNativeNotifier restores the watch from its durable +// outpoint/script/height, without a second journal or scanning block history. +func TestSpendRecoveryUsesNativeNotifier(t *testing.T) { + chain, notifier, point := chainFixture() + for range 2 { + block, height, err := chain.Spend( + t.Context(), point, []byte{0x51}, 150, + ) + require.NoError(t, err) + require.EqualValues(t, 200, height) + require.Equal(t, notifier.spend.SpendingTx, + spendingTransaction(block, point)) + require.Equal(t, point, notifier.point) + require.Equal(t, []byte{0x51}, notifier.script) + require.EqualValues(t, 150, notifier.hint) + // Recreate the adapter to model the normal daemon's restart. + chain = &LNDChain{Kit: chain.Kit, Notifier: notifier} + } +} + +func TestSpendRecoveryRejectsStaleChainEvidence(t *testing.T) { + chain, _, point := chainFixture() + kit := chain.Kit.(*testChainKit) + kit.block.Transactions = nil + _, _, err := chain.Spend(t.Context(), point, []byte{0x51}, 150) + require.ErrorIs(t, err, swapkit.ErrPending) + + kit.hash[0] ^= 1 + _, _, err = chain.Spend(t.Context(), point, []byte{0x51}, 150) + require.ErrorIs(t, err, swapkit.ErrInvalid) +} + +func TestSpendRecoveryHonorsShutdown(t *testing.T) { + chain, notifier, point := chainFixture() + notifier.spend, notifier.entered = nil, make(chan struct{}) + ctx, cancel := context.WithCancel(t.Context()) + done := make(chan error, 1) + go func() { + _, _, err := chain.Spend(ctx, point, []byte{0x51}, 150) + done <- err + }() + <-notifier.entered + cancel() + select { + case err := <-done: + require.ErrorIs(t, err, context.Canceled) + case <-time.After(time.Second): + t.Fatal("spend recovery did not stop with its manager") + } +} + +// TestUnspentRequiresMempoolGate prevents wallet inventory or a confirmation +// notification being substituted for the current Bitcoin UTXO observation. +func TestUnspentRequiresMempoolGate(t *testing.T) { + chain, _, point := chainFixture() + _, err := chain.Unspent(t.Context(), point) + require.ErrorIs(t, err, swapkit.ErrInvalid) + for _, available := range []bool{true, false} { + chain.UnspentOutput = func(_ context.Context, + actual wire.OutPoint) (bool, error) { + + require.Equal(t, point, actual) + return available, nil + } + found, err := chain.Unspent(t.Context(), point) + require.NoError(t, err) + require.Equal(t, available, found) + } +} diff --git a/swapkit/tapsdk/confirmation_chain_test.go b/swapkit/tapsdk/confirmation_chain_test.go new file mode 100644 index 000000000..3e47dc5b2 --- /dev/null +++ b/swapkit/tapsdk/confirmation_chain_test.go @@ -0,0 +1,79 @@ +package tapsdk + +import ( + "context" + "testing" + + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/stretchr/testify/require" +) + +type headerOnlyChain struct { + *bindingChain + + blockReads int + hashReads int +} + +func (c *headerOnlyChain) Block(context.Context, + uint32) (*wire.MsgBlock, error) { + + c.blockReads++ + return nil, swapkit.ErrInvalid +} + +func (c *headerOnlyChain) BlockHash(ctx context.Context, + height uint32) (chainhash.Hash, error) { + + c.hashReads++ + return c.bindingChain.BlockHash(ctx, height) +} + +func TestConfirmationUsesCurrentHashAndMerkleProof(t *testing.T) { + for _, test := range []struct { + name string + change func(*proof.Proof, *bindingChain) + want error + }{ + {name: testValid}, + {name: "reorganized", want: swapkit.ErrPending, + change: func(_ *proof.Proof, c *bindingChain) { + c.blocks[100].Header.Nonce++ + }}, + {name: "wrong merkle path", want: swapkit.ErrInvalid, + change: func(p *proof.Proof, _ *bindingChain) { + p.TxMerkleProof.Nodes = []chainhash.Hash{{1}} + p.TxMerkleProof.Bits = []bool{true} + }}, + {name: "incomplete merkle path", want: swapkit.ErrInvalid, + change: func(p *proof.Proof, _ *bindingChain) { + p.TxMerkleProof.Nodes = []chainhash.Hash{{1}} + }}, + } { + t.Run(test.name, func(t *testing.T) { + p := bindingProof(t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, bindingGenesis().FirstPrevOut, + 100, false) + chain := &headerOnlyChain{bindingChain: &bindingChain{ + tip: 101, unspent: true, + blocks: map[uint32]*wire.MsgBlock{100: bindingBlock(p)}, + }} + if test.change != nil { + test.change(p, chain.bindingChain) + } + for range 2 { + err := checkConfirmation(t.Context(), chain, 2, p, true) + if test.want == nil { + require.NoError(t, err) + } else { + require.ErrorIs(t, err, test.want) + } + } + require.Equal(t, 2, chain.hashReads) + require.Zero(t, chain.blockReads) + }) + } +} diff --git a/swapkit/tapsdk/deposit.go b/swapkit/tapsdk/deposit.go new file mode 100644 index 000000000..bdc4c0c7d --- /dev/null +++ b/swapkit/tapsdk/deposit.go @@ -0,0 +1,83 @@ +package tapsdk + +import ( + "bytes" + "context" + "errors" + + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" +) + +// FundingProof selects the exact confirmed wallet output for a deposit. +// It inspects Loop policy; the subsequent SDK Build verifies lineage once. +// ErrInvalid means the wallet holds no matching unspent output. A matching +// output that only waits on the chain returns ErrPending for outstanding +// confirmations, or the chain backend's own error, so the caller can retry. +func FundingProof(ctx context.Context, wallet *sdk.Wallet, + chain Chain, minConfs uint32, + request swapkit.CreateDepositRequest) ([]byte, error) { + + if err := CheckNodeVersion(ctx, wallet); err != nil { + return nil, err + } + ref := sdk.AssetRefFromGroupKey(request.GroupKey) + assets, err := wallet.Client().ListAssetRecords(ctx, + &sdk.ListAssetsRequest{AssetRef: &ref}) + if err != nil { + return nil, err + } + // waiting is the first chain-state failure of an exact candidate. It is + // reported only when no candidate is ready. + var waiting error + for _, row := range assets { + if row == nil || row.Amount != request.Amount || + row.AnchorOutpoint == nil { + + continue + } + file, err := wallet.ExportProofFile(ctx, + sdk.AssetRefFromAssetID(row.Genesis.IssuanceID), + row.ScriptKey.PubKey, row.AnchorOutpoint) + if err != nil || file == nil { + continue + } + if err := checkProvenance(ctx, wallet, file.RawProofFile); err != nil { + continue + } + p, err := inspectAsset(file.RawProofFile, request.GroupKey, + request.Amount) + if err != nil { + continue + } + scriptKey := p.Asset.ScriptKey.PubKey.SerializeCompressed() + if p.OutPoint() != SDKPoint(*row.AnchorOutpoint) || + sdk.AssetID(p.Asset.ID()) != row.Genesis.IssuanceID || + !bytes.Equal(scriptKey, row.ScriptKey.PubKey[:]) { + + continue + } + // This is the exact wallet output. An outstanding confirmation or + // a chain backend failure does not make the request invalid, + // while a spent output can never fund the deposit. + err = checkConfirmation(ctx, chain, minConfs, p, false) + if err == nil { + var unspent bool + unspent, err = chain.Unspent(ctx, p.OutPoint()) + if err == nil && !unspent { + continue + } + } + if err != nil { + if waiting == nil && !errors.Is(err, swapkit.ErrInvalid) { + waiting = err + } + continue + } + return file.RawProofFile, nil + } + if waiting != nil { + return nil, waiting + } + return nil, swapkit.ErrInvalid +} diff --git a/swapkit/tapsdk/funding.go b/swapkit/tapsdk/funding.go new file mode 100644 index 000000000..8f79a4fea --- /dev/null +++ b/swapkit/tapsdk/funding.go @@ -0,0 +1,64 @@ +package tapsdk + +import ( + "bytes" + "context" + "fmt" + + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" +) + +// PrevoutSource supplies current, authenticated Bitcoin funding outputs. Its +// lookup includes mempool spends and returns nil for a spent/unknown output. +// Wallet-only ListUnspent cannot authenticate external contract anchors. +type PrevoutSource interface { + Prevout(context.Context, wire.OutPoint) (*wire.TxOut, error) +} + +// CheckFundingInputs binds every native PSBT WitnessUtxo to its current Bitcoin +// backend output. Use plan.AnchorPSBT after Build and repeat before Commit, or +// check an already populated request.AnchorPSBT. This authenticates values and +// scripts in addition to Chain.Unspent's existence check. Compact children use +// ApprovedParents for their not-yet-broadcast parent outputs instead. +func CheckFundingInputs(ctx context.Context, source PrevoutSource, + anchorPSBT []byte) error { + + if source == nil { + return fmt.Errorf("authenticated Bitcoin prevouts are required") + } + packet, err := DecodePSBT(anchorPSBT) + if err != nil { + return err + } + seen := make(map[wire.OutPoint]bool) + for i, input := range packet.UnsignedTx.TxIn { + if input == nil || i >= len(packet.Inputs) || + packet.Inputs[i].WitnessUtxo == nil { + + return swapkit.ErrInvalid + } + point := input.PreviousOutPoint + if seen[point] { + return fmt.Errorf("duplicate Bitcoin funding input") + } + seen[point] = true + actual, err := source.Prevout(ctx, point) + if err != nil { + return err + } + if actual == nil { + return swapkit.ErrPending + } + expected := packet.Inputs[i].WitnessUtxo + if actual.Value < 0 || actual.Value != expected.Value || + !bytes.Equal(actual.PkScript, expected.PkScript) { + + return fmt.Errorf( + "%w: Bitcoin prevout differs from authenticated backend", + swapkit.ErrInvalid, + ) + } + } + return nil +} diff --git a/swapkit/tapsdk/funding_test.go b/swapkit/tapsdk/funding_test.go new file mode 100644 index 000000000..96fe92429 --- /dev/null +++ b/swapkit/tapsdk/funding_test.go @@ -0,0 +1,210 @@ +package tapsdk + +import ( + "context" + "errors" + "testing" + + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/stretchr/testify/require" +) + +type fundingSDK struct { + *bindingSDK + + rows []*sdk.AssetRecord + proofs map[sdk.Outpoint][]byte + exports []sdk.Outpoint +} + +func (s *fundingSDK) ListAssetRecords(context.Context, + *sdk.ListAssetsRequest) ([]*sdk.AssetRecord, error) { + + return s.rows, nil +} + +func (s *fundingSDK) ExportProof(_ context.Context, _ sdk.AssetRef, + _ sdk.PubKey, point *sdk.Outpoint) (*sdk.ProofFile, error) { + + if point == nil { + return nil, proof.ErrMultipleProofs + } + s.exports = append(s.exports, *point) + return &sdk.ProofFile{RawProofFile: s.proofs[*point]}, nil +} + +type fundingChain struct { + *bindingChain + + spent wire.OutPoint + heightErr error + unspentErr error +} + +func (c *fundingChain) Height(ctx context.Context) (uint32, error) { + if c.heightErr != nil { + return 0, c.heightErr + } + return c.bindingChain.Height(ctx) +} + +func (c *fundingChain) Unspent(_ context.Context, + point wire.OutPoint) (bool, error) { + + if c.unspentErr != nil { + return false, c.unspentErr + } + return point != c.spent, nil +} + +func TestFundingUsesExactOutpointWithReusedScriptKey(t *testing.T) { + first := bindingProof(t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, bindingGenesis().FirstPrevOut, + 100, false) + second := bindingProof(t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, + wire.OutPoint{Hash: chainhash.Hash{12}}, 101, false) + client := &fundingSDK{bindingSDK: &bindingSDK{valid: true}, + proofs: make(map[sdk.Outpoint][]byte)} + for _, p := range []*proof.Proof{first, second} { + point := sdk.Outpoint{Txid: sdk.Hash(p.OutPoint().Hash), + Index: p.OutPoint().Index} + client.rows = append(client.rows, &sdk.AssetRecord{ + Amount: 1000, AnchorOutpoint: &point, + Genesis: sdk.IssuanceGenesis{ + IssuanceID: sdk.AssetID(p.Asset.ID()), + }, + ScriptKey: sdk.ScriptKey{PubKey: bindingPub(2)}, + }) + client.proofs[point] = bindingRaw(t, p) + } + chain := &fundingChain{spent: first.OutPoint(), + bindingChain: &bindingChain{tip: 102, + blocks: map[uint32]*wire.MsgBlock{ + 100: bindingBlock(first), + 101: bindingBlock(second), + }}} + r := &proofNode{client: client, chain: chain, minConfs: 1} + request := swapkit.CreateDepositRequest{ + GroupKey: bindingPub(11), Amount: 1000, + } + raw, err := FundingProof( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + request, + ) + require.NoError(t, err) + require.Equal(t, bindingRaw(t, second), raw) + require.Len(t, client.exports, 2) + require.Equal(t, *client.rows[0].AnchorOutpoint, client.exports[0]) + require.Equal(t, *client.rows[1].AnchorOutpoint, client.exports[1]) + + // Even a valid same-group proof cannot replace the selected output. + client.rows = client.rows[1:] + client.proofs[*client.rows[0].AnchorOutpoint] = bindingRaw(t, first) + chain.spent = wire.OutPoint{} + _, err = FundingProof( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + request, + ) + require.ErrorIs(t, err, swapkit.ErrInvalid) + + client.rows[0].AnchorOutpoint = nil + client.exports = nil + _, err = FundingProof( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + request, + ) + require.ErrorIs(t, err, swapkit.ErrInvalid) + require.Empty(t, client.exports) +} + +// TestFundingProofReportsChainState checks that an exact wallet output which +// only waits on the chain is reported as retryable, not as an invalid request. +func TestFundingProofReportsChainState(t *testing.T) { + first := bindingProof(t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, bindingGenesis().FirstPrevOut, + 100, false) + second := bindingProof(t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, + wire.OutPoint{Hash: chainhash.Hash{12}}, 101, false) + row := func(p *proof.Proof) (*sdk.AssetRecord, sdk.Outpoint) { + point := sdk.Outpoint{Txid: sdk.Hash(p.OutPoint().Hash), + Index: p.OutPoint().Index} + return &sdk.AssetRecord{ + Amount: 1000, AnchorOutpoint: &point, + Genesis: sdk.IssuanceGenesis{ + IssuanceID: sdk.AssetID(p.Asset.ID()), + }, + ScriptKey: sdk.ScriptKey{PubKey: bindingPub(2)}, + }, point + } + firstRow, firstPoint := row(first) + secondRow, secondPoint := row(second) + client := &fundingSDK{bindingSDK: &bindingSDK{valid: true}, + rows: []*sdk.AssetRecord{secondRow}, + proofs: map[sdk.Outpoint][]byte{ + firstPoint: bindingRaw(t, first), + secondPoint: bindingRaw(t, second), + }} + chain := &fundingChain{bindingChain: &bindingChain{tip: 101, + blocks: map[uint32]*wire.MsgBlock{ + 100: bindingBlock(first), + 101: bindingBlock(second), + }}} + r := &proofNode{client: client, chain: chain} + request := swapkit.CreateDepositRequest{ + GroupKey: bindingPub(11), Amount: 1000, + } + funding := func(minConfs uint32) ([]byte, error) { + return FundingProof( + t.Context(), r.wallet(), r.chain, minConfs, request, + ) + } + + // The only candidate has one of three required confirmations. + _, err := funding(3) + require.ErrorIs(t, err, swapkit.ErrPending) + require.NotErrorIs(t, err, swapkit.ErrInvalid) + + // A chain backend failure is reported as such. + chain.heightErr = errors.New("chain backend unavailable") + _, err = funding(1) + require.ErrorIs(t, err, chain.heightErr) + chain.heightErr = nil + chain.unspentErr = errors.New("mempool lookup unavailable") + _, err = funding(1) + require.ErrorIs(t, err, chain.unspentErr) + chain.unspentErr = nil + + // A spent output can never fund the deposit and stays invalid. + chain.spent = second.OutPoint() + _, err = funding(1) + require.ErrorIs(t, err, swapkit.ErrInvalid) + chain.spent = wire.OutPoint{} + + // A waiting candidate does not hide another one that is ready. + client.rows = []*sdk.AssetRecord{secondRow, firstRow} + raw, err := funding(2) + require.NoError(t, err) + require.Equal(t, bindingRaw(t, first), raw) + + // The waiting candidate is selected once it has confirmed. + client.rows = []*sdk.AssetRecord{secondRow} + chain.tip = 103 + raw, err = funding(3) + require.NoError(t, err) + require.Equal(t, bindingRaw(t, second), raw) +} diff --git a/swapkit/tapsdk/group.go b/swapkit/tapsdk/group.go new file mode 100644 index 000000000..9956c7d26 --- /dev/null +++ b/swapkit/tapsdk/group.go @@ -0,0 +1,21 @@ +package tapsdk + +import sdk "github.com/lightninglabs/tap-sdk" + +// SameGroupKey compares valid compressed group keys by their x-only identity. +// It preserves the caller's serialized key metadata and rejects malformed keys. +func SameGroupKey(first, second []byte) bool { + a, err := sdk.ParsePubKey(first) + if err != nil { + return false + } + b, err := sdk.ParsePubKey(second) + if err != nil { + return false + } + return sdk.AssetRefFromGroupKey(a).Equivalent(sdk.AssetRefFromGroupKey(b)) +} + +func sameGroupKeys(first, second []byte) bool { + return SameGroupKey(first, second) +} diff --git a/swapkit/tapsdk/group_proofs.go b/swapkit/tapsdk/group_proofs.go new file mode 100644 index 000000000..dc36245b0 --- /dev/null +++ b/swapkit/tapsdk/group_proofs.go @@ -0,0 +1,93 @@ +package tapsdk + +import ( + "bytes" + "context" + + assetpolicy "github.com/lightninglabs/loop/internal/assetpolicy" + "github.com/lightninglabs/loop/swapkit" + "github.com/lightninglabs/taproot-assets/address" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/taprpc" +) + +// IsGroupMember checks the fungible asset's declared group identity. It does +// not verify issuance authorization or replace full proof verification. +func IsGroupMember(a *asset.Asset, key []byte) bool { + return a != nil && a.Type == asset.Normal && a.GroupKey != nil && + SameGroupKey(a.GroupKey.GroupPubKey.SerializeCompressed(), key) +} + +// VerifyGroupMembership verifies an anchor-first set of genesis proofs for +// the required fungible issuances. The verifier authenticates each proof with +// tapd; matching a group key alone is insufficient. Callers supply the required +// issuances and their aggregate proof-byte limit, independently of peer input. +// Node errors remain distinguishable from invalid evidence. +func VerifyGroupMembership(ctx context.Context, verifier RPCProofVerifier, + params *address.ChainParams, groupKey []byte, required []asset.ID, + issuanceProofs [][]byte, maxProofBytes int) error { + + if verifier == nil || !SameGroupKey(groupKey, groupKey) || + len(required) == 0 || maxProofBytes <= 0 { + + return swapkit.ErrInvalid + } + needed := make(map[asset.ID]bool, len(required)) + for _, id := range required { + if id == asset.ZeroID { + return swapkit.ErrInvalid + } + needed[id] = true + } + if len(issuanceProofs) == 0 || len(issuanceProofs) > len(needed)+1 { + return swapkit.ErrInvalid + } + var total int + for i, raw := range issuanceProofs { + if len(raw) == 0 || len(raw) > maxProofBytes-total { + return swapkit.ErrInvalid + } + total += len(raw) + p, err := proof.Decode(raw) + if err != nil || !p.Asset.HasGenesisWitnessForGroup() || + !IsGroupMember(&p.Asset, groupKey) || + (i == 0) != (p.GroupKeyReveal != nil) { + + return swapkit.ErrInvalid + } + id := p.Asset.ID() + if i > 0 && !needed[id] { + return swapkit.ErrInvalid + } + delete(needed, id) + file, err := proof.NewFile(proof.V0, *p) + if err != nil { + return swapkit.ErrInvalid + } + if err := assetpolicy.ValidateProvenance(ctx, file, params); err != nil { + if ctx.Err() != nil { + return ctx.Err() + } + return swapkit.ErrInvalid + } + data, err := proof.EncodeFile(file) + if err != nil { + return swapkit.ErrInvalid + } + result, err := verifier.VerifyProof(ctx, &taprpc.ProofFile{RawProofFile: data}) + if err != nil { + return err + } + a := result.GetDecodedProof().GetAsset() + if !result.GetValid() || !bytes.Equal(a.GetAssetGenesis().GetAssetId(), id[:]) || + !SameGroupKey(a.GetAssetGroup().GetTweakedGroupKey(), groupKey) { + + return swapkit.ErrInvalid + } + } + if len(needed) != 0 { + return swapkit.ErrInvalid + } + return nil +} diff --git a/swapkit/tapsdk/group_proofs_test.go b/swapkit/tapsdk/group_proofs_test.go new file mode 100644 index 000000000..c1ba9d032 --- /dev/null +++ b/swapkit/tapsdk/group_proofs_test.go @@ -0,0 +1,90 @@ +package tapsdk + +import ( + "errors" + "testing" + + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + "github.com/lightninglabs/taproot-assets/address" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightningnetwork/lnd/keychain" + "github.com/stretchr/testify/require" +) + +func groupEvidence(t *testing.T, tag string, anchor bool) *proof.Proof { + t.Helper() + g := bindingGenesis() + g.Tag = tag + p := bindingProof(t, g, bindingKey(2).PubKey(), bindingKey(3).PubKey(), nil, g.FirstPrevOut, 100, false) + p.Asset.PrevWitnesses[0].TxWitness = wire.TxWitness{make([]byte, 64)} + if anchor { + var err error + p.GroupKeyReveal, err = asset.NewGroupKeyReveal( + asset.GroupKey{ + RawKey: keychain.KeyDescriptor{ + PubKey: bindingKey(11).PubKey(), + }, + }, g.ID(), + ) + require.NoError(t, err) + } + return p +} + +func TestVerifyGroupMembership(t *testing.T) { + anchor := groupEvidence(t, "anchor", true) + fund := groupEvidence(t, "fund", false) + pay := groupEvidence(t, "pay", false) + encode := func(p *proof.Proof) []byte { + raw, err := p.Bytes() + require.NoError(t, err) + return raw + } + proofs := [][]byte{encode(anchor), encode(fund), encode(pay)} + key := anchor.Asset.GroupKey.GroupPubKey.SerializeCompressed() + needed := []asset.ID{fund.Asset.ID(), pay.Asset.ID()} + limit := len(proofs[0]) + len(proofs[1]) + len(proofs[2]) + check := func(node *evidenceNode, ids []asset.ID, data [][]byte, + maxBytes int) error { + + return VerifyGroupMembership( + t.Context(), node, &address.RegressionNetTap, key, ids, + data, maxBytes, + ) + } + node := &evidenceNode{} + require.NoError(t, check(node, needed, proofs, limit)) + require.Equal(t, []string{verifyProofCall, verifyProofCall, verifyProofCall}, node.calls) + require.NoError(t, check(&evidenceNode{}, []asset.ID{fund.Asset.ID(), fund.Asset.ID()}, proofs[:2], limit)) + require.NoError(t, check(&evidenceNode{}, []asset.ID{anchor.Asset.ID()}, proofs[:1], limit)) + for _, test := range []struct { + name string + data [][]byte + node *evidenceNode + max int + }{ + {"missing issuance", proofs[:2], &evidenceNode{}, limit}, + {"wrong order", [][]byte{proofs[1], proofs[0], proofs[2]}, &evidenceNode{}, limit}, + {"duplicate issuance", [][]byte{proofs[0], proofs[1], proofs[1]}, &evidenceNode{}, limit}, + {"byte limit", proofs, &evidenceNode{}, limit - 1}, + {"invalid proof", proofs, &evidenceNode{invalid: true}, limit}, + {"wrong decoded issuance", proofs, &evidenceNode{wrongID: true}, limit}, + {"wrong decoded group", proofs, &evidenceNode{wrongGroup: true}, limit}, + } { + t.Run(test.name, func(t *testing.T) { + require.ErrorIs(t, check(test.node, needed, test.data, test.max), swapkit.ErrInvalid) + }) + } + node = &evidenceNode{verifyErr: errors.New("node unavailable")} + require.ErrorIs(t, check(node, needed, proofs, limit), node.verifyErr) + require.Len(t, node.calls, 1) + collectible := *fund + collectible.Asset = *fund.Asset.Copy() + collectible.Asset.Type = asset.Collectible + require.ErrorIs(t, check( + &evidenceNode{}, needed, + [][]byte{proofs[0], encode(&collectible), proofs[2]}, limit+1000, + ), swapkit.ErrInvalid) +} diff --git a/swapkit/tapsdk/group_test.go b/swapkit/tapsdk/group_test.go new file mode 100644 index 000000000..f39f12901 --- /dev/null +++ b/swapkit/tapsdk/group_test.go @@ -0,0 +1,72 @@ +package tapsdk + +import ( + "bytes" + "testing" + + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +func TestSameGroupKeys(t *testing.T) { + group := bindingPub(11) + opposite := group + opposite[0] ^= 1 + other := bindingPub(12) + invalidPrefix := group + invalidPrefix[0] = 4 + for _, test := range []struct { + name string + key []byte + want bool + }{ + {name: "same", key: group[:], want: true}, + {name: "opposite parity", key: opposite[:], want: true}, + {name: "different", key: other[:]}, + {name: "missing", key: nil}, + {name: "x-only", key: group[1:]}, + {name: "invalid prefix", key: invalidPrefix[:]}, + {name: "invalid point", key: make([]byte, 33)}, + } { + t.Run(test.name, func(t *testing.T) { + before := bytes.Clone(test.key) + require.Equal(t, test.want, sameGroupKeys(group[:], test.key)) + require.Equal(t, test.want, sameGroupKeys(test.key, group[:])) + require.Equal(t, before, test.key) + }) + } +} + +func TestInputBindingAcceptsGroupParity(t *testing.T) { + p := bindingProof(t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, bindingGenesis().FirstPrevOut, + 100, false) + group := sdk.PubKey(bindingPub(11)) + group[0] ^= 1 + binding := InputBinding{ + ID: "grouped input", IssuanceID: sdk.AssetID(p.Asset.ID()), + GroupKey: &group, Amount: p.Asset.Amount, ScriptKey: bindingPub(2), + AnchorOutpoint: sdk.Outpoint{ + Txid: sdk.Hash(p.OutPoint().Hash), Index: p.OutPoint().Index, + }, + } + require.NoError(t, binding.validate(p)) + other := sdk.PubKey(bindingPub(12)) + binding.GroupKey = &other + require.ErrorIs(t, binding.validate(p), swapkit.ErrInvalid) +} + +func TestVerifiedSummaryAcceptsGroupParity(t *testing.T) { + p := bindingProof(t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, bindingGenesis().FirstPrevOut, + 100, false) + response, err := fixtureVerified(bindingRaw(t, p), true) + require.NoError(t, err) + group := bindingPub(11) + group[0] ^= 1 + response.DecodedProof.AssetRef = sdk.AssetRefFromGroupKey(group) + require.NoError(t, checkVerifiedSummary(response, p)) + response.DecodedProof.AssetRef = sdk.AssetRefFromGroupKey(bindingPub(12)) + require.ErrorIs(t, checkVerifiedSummary(response, p), swapkit.ErrInvalid) +} diff --git a/swapkit/tapsdk/inputs.go b/swapkit/tapsdk/inputs.go new file mode 100644 index 000000000..eb3549331 --- /dev/null +++ b/swapkit/tapsdk/inputs.go @@ -0,0 +1,100 @@ +package tapsdk + +import ( + "context" + "fmt" + + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/internal/assetproof" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/proof" +) + +// CheckInputsCurrent repeats chain checks after SDK Build's verification RPCs. +// Call it before Commit so verification cannot authorize a now stale input. +func CheckInputsCurrent(ctx context.Context, chain Chain, minConfs uint32, + request *sdk.CustomAnchorRequest, unspent bool) error { + + if request == nil { + return swapkit.ErrInvalid + } + raws := make( + [][]byte, + 0, + len(request.Inputs)+len(request.PassiveAssets.Packets), + ) + for _, input := range request.Inputs { + raw := input.ProofFile + if input.ProofPath != nil { + if len(input.ProofPath.Steps) > 0 { + return fmt.Errorf( + "compact inputs require ApprovedParents.CheckCurrent", + ) + } + raw = input.ProofPath.ConfirmedBaseProof + } + raws = append(raws, raw) + } + for _, passive := range request.PassiveAssets.Packets { + raws = append(raws, passive.ProofFile) + } + var inventory []*proof.Proof + for _, raw := range raws { + p, err := LastProof(raw) + if err != nil { + return err + } + inventory = append(inventory, p) + if err := checkConfirmation(ctx, chain, minConfs, p, unspent); err != nil { + return err + } + } + if err := assetproof.VerifyCompleteAnchors(inventory); err != nil { + return err + } + if unspent { + packet, err := DecodePSBT(request.AnchorPSBT) + if err != nil { + return err + } + return checkFundingCurrent(ctx, chain, packet, nil) + } + + return nil +} + +// checkFundingCurrent checks all asset and Bitcoin-only funding inputs. Skip +// contains only the outputs supplied by independently approved signed parents. +func checkFundingCurrent(ctx context.Context, chain Chain, packet *psbt.Packet, + skip map[wire.OutPoint]bool) error { + + if chain == nil || packet == nil || packet.UnsignedTx == nil || + len(packet.Inputs) != len(packet.UnsignedTx.TxIn) { + + return swapkit.ErrInvalid + } + seen := make(map[wire.OutPoint]bool) + for _, input := range packet.UnsignedTx.TxIn { + if input == nil { + return swapkit.ErrInvalid + } + point := input.PreviousOutPoint + if seen[point] { + return fmt.Errorf("duplicate Bitcoin funding input") + } + seen[point] = true + if skip[point] { + continue + } + available, err := chain.Unspent(ctx, point) + if err != nil { + return err + } + if !available { + return swapkit.ErrPending + } + } + return nil +} diff --git a/swapkit/tapsdk/issuance.go b/swapkit/tapsdk/issuance.go new file mode 100644 index 000000000..08ce1f21a --- /dev/null +++ b/swapkit/tapsdk/issuance.go @@ -0,0 +1,98 @@ +package tapsdk + +import ( + "context" + + "github.com/btcsuite/btcd/btcec/v2/schnorr" + assetpolicy "github.com/lightninglabs/loop/internal/assetpolicy" + "github.com/lightninglabs/loop/swapkit" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/taprpc" + "github.com/lightninglabs/taproot-assets/taprpc/universerpc" + "google.golang.org/grpc" +) + +// RPCProofVerifier verifies full proof files with tapd. Verification alone +// does not establish the caller's expected asset, amount, contract or chain state. +type RPCProofVerifier interface { + VerifyProof(context.Context, *taprpc.ProofFile, + ...grpc.CallOption) (*taprpc.VerifyProofResponse, error) +} + +// IssuanceProofClient records verified issuance metadata and verifies history. +// Inserting issuance metadata does not register a received wallet asset. +type IssuanceProofClient interface { + RPCProofVerifier + InsertProof(context.Context, *universerpc.AssetProof, + ...grpc.CallOption) (*universerpc.AssetProofResponse, error) +} + +// VerifyProofWithIssuance registers the first issuance before asking tapd to +// verify the full history. This supports assets unknown to the local node and +// safely repeats after restart. Callers enforce their transport limits and +// expected output before calling; node errors are returned unchanged. +func VerifyProofWithIssuance(ctx context.Context, tap IssuanceProofClient, + req *taprpc.ProofFile, opts ...grpc.CallOption) ( + *taprpc.VerifyProofResponse, error) { + + if tap == nil || req == nil || len(req.RawProofFile) == 0 { + return nil, swapkit.ErrInvalid + } + if err := assetpolicy.CheckProofFileSize(req.RawProofFile); err != nil { + return nil, swapkit.ErrInvalid + } + file, err := proof.DecodeFile(req.RawProofFile) + if err != nil { + return nil, swapkit.ErrInvalid + } + first, err := file.ProofAt(0) + if err != nil || !first.Asset.IsGenesisAsset() || + first.Asset.ScriptKey.PubKey == nil { + + return nil, swapkit.ErrInvalid + } + last, err := file.LastProof() + if err != nil || first.Asset.ID() != last.Asset.ID() { + return nil, swapkit.ErrInvalid + } + raw, err := file.RawProofAt(0) + if err != nil { + return nil, swapkit.ErrInvalid + } + assetID := first.Asset.ID() + id := &universerpc.ID{ + Id: &universerpc.ID_AssetId{ + AssetId: assetID[:], + }, + ProofType: universerpc.ProofType_PROOF_TYPE_ISSUANCE, + } + if first.Asset.GroupKey != nil { + id.Id = &universerpc.ID_GroupKey{ + GroupKey: schnorr.SerializePubKey( + &first.Asset.GroupKey.GroupPubKey, + ), + } + } + _, err = tap.InsertProof(ctx, &universerpc.AssetProof{ + Key: &universerpc.UniverseKey{ + Id: id, + LeafKey: &universerpc.AssetKey{ + Outpoint: &universerpc.AssetKey_OpStr{ + OpStr: first.OutPoint().String(), + }, + ScriptKey: &universerpc.AssetKey_ScriptKeyBytes{ + ScriptKeyBytes: schnorr.SerializePubKey( + first.Asset.ScriptKey.PubKey, + ), + }, + }, + }, + AssetLeaf: &universerpc.AssetLeaf{ + Proof: raw, + }, + }, opts...) + if err != nil { + return nil, err + } + return tap.VerifyProof(ctx, req, opts...) +} diff --git a/swapkit/tapsdk/issuance_test.go b/swapkit/tapsdk/issuance_test.go new file mode 100644 index 000000000..4e8a35dda --- /dev/null +++ b/swapkit/tapsdk/issuance_test.go @@ -0,0 +1,116 @@ +package tapsdk + +import ( + "context" + "errors" + "testing" + + "github.com/lightninglabs/loop/swapkit" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/taprpc" + "github.com/lightninglabs/taproot-assets/taprpc/universerpc" + "github.com/stretchr/testify/require" + "google.golang.org/grpc" +) + +const ( + insertIssuanceCall = "insert issuance" + verifyProofCall = "verify proof" +) + +// evidenceNode models tapd's authenticated RPC boundary. The tests exercise +// evidence selection and call ordering; tapd performs cryptographic verification. +type evidenceNode struct { + calls []string + inserted *universerpc.AssetProof + insertErr error + verifyErr error + invalid bool + wrongID bool + wrongGroup bool +} + +func (n *evidenceNode) InsertProof(_ context.Context, req *universerpc.AssetProof, + _ ...grpc.CallOption) (*universerpc.AssetProofResponse, error) { + + n.calls = append(n.calls, insertIssuanceCall) + n.inserted = req + return &universerpc.AssetProofResponse{}, n.insertErr +} + +func (n *evidenceNode) VerifyProof(_ context.Context, req *taprpc.ProofFile, + _ ...grpc.CallOption) (*taprpc.VerifyProofResponse, error) { + + n.calls = append(n.calls, verifyProofCall) + if n.verifyErr != nil { + return nil, n.verifyErr + } + f, err := proof.DecodeFile(req.RawProofFile) + if err != nil { + return nil, err + } + p, err := f.LastProof() + if err != nil { + return nil, err + } + id := p.Asset.ID() + if n.wrongID { + id = asset.ID{9} + } + a := &taprpc.Asset{AssetGenesis: &taprpc.GenesisInfo{AssetId: id[:]}} + if p.Asset.GroupKey != nil { + key := p.Asset.GroupKey.GroupPubKey.SerializeCompressed() + if n.wrongGroup { + key = bindingKey(12).PubKey().SerializeCompressed() + } + a.AssetGroup = &taprpc.AssetGroup{TweakedGroupKey: key} + } + return &taprpc.VerifyProofResponse{Valid: !n.invalid, DecodedProof: &taprpc.DecodedProof{Asset: a}}, nil +} + +func TestVerifyProofWithIssuance(t *testing.T) { + p := bindingProof( + t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, bindingGenesis().FirstPrevOut, + 100, false, + ) + raw := bindingRaw(t, p) + node := &evidenceNode{} + req := &taprpc.ProofFile{RawProofFile: raw} + for range 2 { + node.calls = nil + result, err := VerifyProofWithIssuance(t.Context(), node, req) + require.NoError(t, err) + require.True(t, result.Valid) + require.Equal(t, []string{insertIssuanceCall, verifyProofCall}, node.calls) + require.Equal(t, universerpc.ProofType_PROOF_TYPE_ISSUANCE, node.inserted.Key.Id.ProofType) + require.Equal(t, p.Asset.GroupKey.GroupPubKey.SerializeCompressed()[1:], node.inserted.Key.Id.GetGroupKey()) + require.Equal(t, p.OutPoint().String(), node.inserted.Key.LeafKey.GetOpStr()) + } + node.calls = nil + node.insertErr = errors.New("issuance unavailable") + _, err := VerifyProofWithIssuance(t.Context(), node, req) + require.ErrorIs(t, err, node.insertErr) + require.Equal(t, []string{insertIssuanceCall}, node.calls) + node.calls = nil + node.insertErr = nil + node.verifyErr = errors.New("verification unavailable") + _, err = VerifyProofWithIssuance(t.Context(), node, req) + require.ErrorIs(t, err, node.verifyErr) + require.Equal(t, []string{insertIssuanceCall, verifyProofCall}, node.calls) + node.calls = nil + _, err = VerifyProofWithIssuance(t.Context(), node, &taprpc.ProofFile{RawProofFile: []byte{1}}) + require.ErrorIs(t, err, swapkit.ErrInvalid) + require.Empty(t, node.calls) + changed := *p + changed.Asset = *p.Asset.Copy() + changed.Asset.Genesis.Tag += "-other" + f, err := proof.NewFile(proof.V0, *p, changed) + require.NoError(t, err) + bytes, err := proof.EncodeFile(f) + require.NoError(t, err) + _, err = VerifyProofWithIssuance(t.Context(), node, &taprpc.ProofFile{RawProofFile: bytes}) + require.ErrorIs(t, err, swapkit.ErrInvalid) + require.Empty(t, node.calls) +} diff --git a/swapkit/tapsdk/policy.go b/swapkit/tapsdk/policy.go new file mode 100644 index 000000000..ca62243d5 --- /dev/null +++ b/swapkit/tapsdk/policy.go @@ -0,0 +1,135 @@ +package tapsdk + +import ( + "bytes" + "context" + "fmt" + + assetpolicy "github.com/lightninglabs/loop/internal/assetpolicy" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/address" + "github.com/lightninglabs/taproot-assets/proof" +) + +// CheckNodeVersion checks the live tapd compatibility floor for new on-chain +// asset operations. Local decoding and recovery of saved Bitcoin witnesses do +// not require a running node or change already funded contracts. +func CheckNodeVersion(ctx context.Context, wallet *sdk.Wallet) error { + _, err := nodeParams(ctx, wallet) + return err +} + +func nodeParams(ctx context.Context, wallet *sdk.Wallet) ( + *address.ChainParams, error) { + + if wallet == nil || wallet.Client() == nil { + return nil, fmt.Errorf("tapd wallet is required") + } + info, err := wallet.Client().GetInfo(ctx) + if err != nil { + return nil, err + } + if info == nil { + return nil, fmt.Errorf("tapd omitted node information") + } + if err := assetpolicy.CheckOnchainSwapTapdVersion(info.Version); err != nil { + return nil, err + } + var params address.ChainParams + switch info.Network { + case "mainnet": + params = address.MainNetTap + case "testnet", "testnet3": + params = address.TestNet3Tap + case "testnet4": + params = address.TestNet4Tap + case "regtest": + params = address.RegressionNetTap + case "signet": + params = address.SigNetTap + case "simnet": + params = address.SimNetTap + default: + return nil, fmt.Errorf( + "unsupported tapd network %q", + info.Network, + ) + } + return assetpolicy.CanonicalAddressParams(¶ms) +} + +func checkProvenance( + ctx context.Context, + wallet *sdk.Wallet, + raw []byte, +) error { + + if err := assetpolicy.CheckProofFileSize(raw); err != nil { + return err + } + params, err := nodeParams(ctx, wallet) + if err != nil { + return err + } + return checkProvenanceWithParams(ctx, raw, params) +} + +func checkProvenanceWithParams( + ctx context.Context, + raw []byte, + params *address.ChainParams, +) error { + + if err := assetpolicy.CheckProofFileSize(raw); err != nil { + return err + } + file, err := proof.DecodeFile(raw) + if err != nil { + return err + } + return assetpolicy.ValidateProvenance(ctx, file, params) +} + +func checkVerifiedSummary( + result *sdk.VerifyProofResponse, + p *proof.Proof, +) error { + + if result == nil || !result.Valid || result.DecodedProof == nil || + p == nil { + + return fmt.Errorf( + "%w: tapd did not verify the selected proof", + swapkit.ErrInvalid, + ) + } + decoded := result.DecodedProof + var group *sdk.PubKey + if p.Asset.GroupKey != nil { + key, err := sdk.ParsePubKey( + p.Asset.GroupKey.GroupPubKey.SerializeCompressed(), + ) + if err != nil { + return err + } + group = &key + } + ref := sdk.AssetRefFromTypedAsset( + sdk.AssetID(p.Asset.ID()), + group, + sdk.AssetType(p.Asset.Type), + ) + if decoded.IssuanceID != sdk.AssetID(p.Asset.ID()) || + !decoded.AssetRef.Equivalent(ref) || + decoded.Amount != p.Asset.Amount || + SDKPoint(decoded.Outpoint) != p.OutPoint() || + !bytes.Equal(decoded.ScriptKey[1:], p.Asset.ScriptKey.PubKey.SerializeCompressed()[1:]) { + + return fmt.Errorf( + "%w: tapd verified a different asset output", + swapkit.ErrInvalid, + ) + } + return nil +} diff --git a/swapkit/tapsdk/proofs.go b/swapkit/tapsdk/proofs.go new file mode 100644 index 000000000..965e991ea --- /dev/null +++ b/swapkit/tapsdk/proofs.go @@ -0,0 +1,184 @@ +package tapsdk + +import ( + "bytes" + "context" + + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + assetpolicy "github.com/lightninglabs/loop/internal/assetpolicy" + "github.com/lightninglabs/loop/internal/assetproof" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightninglabs/taproot-assets/proof" +) + +// LastProof decodes the final transition in a native asset proof file. +func LastProof(raw []byte) (*proof.Proof, error) { + if err := assetpolicy.CheckProofFileSize(raw); err != nil { + return nil, err + } + file, err := proof.DecodeFile(raw) + if err != nil { + return nil, err + } + p, err := file.LastProof() + if err != nil { + return nil, err + } + if err := p.Asset.Validate(); err != nil { + return nil, err + } + return p, nil +} + +func isolatedRoots(p *proof.Proof) (sdk.Hash, sdk.Hash, error) { + if p == nil || p.InclusionProof.CommitmentProof == nil || + p.InclusionProof.InternalKey == nil { + + return sdk.Hash{}, sdk.Hash{}, swapkit.ErrInvalid + } + tc, err := assetproof.VerifyCompleteAnchor(p) + if err != nil { + return sdk.Hash{}, sdk.Hash{}, err + } + return commitmentRoots(p, tc) +} + +func proofRoots(p *proof.Proof) (sdk.Hash, sdk.Hash, error) { + if p == nil { + return sdk.Hash{}, sdk.Hash{}, swapkit.ErrInvalid + } + tc, err := p.VerifyProofs() + if err != nil { + return sdk.Hash{}, sdk.Hash{}, err + } + return commitmentRoots(p, tc) +} + +func commitmentRoots( + p *proof.Proof, + tc *commitment.TapCommitment, +) (sdk.Hash, sdk.Hash, error) { + + _, sibling, err := commitment.MaybeEncodeTapscriptPreimage( + p.InclusionProof.CommitmentProof.TapSiblingPreimage) + if err != nil { + return sdk.Hash{}, sdk.Hash{}, err + } + root, assets := tc.TapscriptRoot(sibling), tc.TapscriptRoot(nil) + script, err := txscript.PayToTaprootScript( + txscript.ComputeTaprootOutputKey( + p.InclusionProof.InternalKey, + root[:], + ), + ) + index := p.OutPoint().Index + if err != nil || index >= uint32(len(p.AnchorTx.TxOut)) || + !bytes.Equal(script, p.AnchorTx.TxOut[index].PkScript) { + + return sdk.Hash{}, sdk.Hash{}, swapkit.ErrInvalid + } + return sdk.Hash(assets), sdk.Hash(root), nil +} + +// checkConfirmation requires current-chain inclusion and optional spendability. +func checkConfirmation(ctx context.Context, chain Chain, + minConfs uint32, p *proof.Proof, + unspent bool) error { + + if chain == nil || p == nil || minConfs == 0 || p.BlockHeight == 0 || + p.OutPoint().Index >= uint32(len(p.AnchorTx.TxOut)) { + + return swapkit.ErrInvalid + } + tip, err := chain.Height(ctx) + if err != nil { + return err + } + if tip < p.BlockHeight || tip-p.BlockHeight+1 < minConfs { + return swapkit.ErrPending + } + hash, err := chain.BlockHash(ctx, p.BlockHeight) + if err != nil { + return err + } + if hash != p.BlockHeader.BlockHash() { + return swapkit.ErrPending + } + if len(p.TxMerkleProof.Nodes) != len(p.TxMerkleProof.Bits) || + !p.TxMerkleProof.Verify(&p.AnchorTx, p.BlockHeader.MerkleRoot) { + + return swapkit.ErrInvalid + } + if unspent { + available, err := chain.Unspent(ctx, p.OutPoint()) + if err != nil { + return err + } + if !available { + return swapkit.ErrPending + } + } + return nil +} + +// DecodePSBT reads the native Bitcoin PSBT carried by an SDK transfer. +func DecodePSBT(raw []byte) (*psbt.Packet, error) { + return psbt.NewFromRawBytes(bytes.NewReader(raw), false) +} + +// SDKPoint converts a native SDK outpoint to the Bitcoin wire type. +func SDKPoint(p sdk.Outpoint) wire.OutPoint { + return wire.OutPoint{Hash: chainhash.Hash(p.Txid), Index: p.Index} +} + +// checkAsset checks negotiated native quantity and group membership. +func checkAsset(p *proof.Proof, group [33]byte, amount uint64) error { + if p == nil || p.Asset.GroupKey == nil || p.Asset.Amount != amount || + p.Asset.LockTime != 0 || p.Asset.RelativeLockTime != 0 || + !sameGroupKeys( + p.Asset.GroupKey.GroupPubKey.SerializeCompressed(), + group[:], + ) { + + return swapkit.ErrInvalid + } + return nil +} + +// inspectProof checks Loop policy and the current chain before SDK Build. +// SDK Build is responsible for generic proof verification on building paths. +func inspectProof(ctx context.Context, chain Chain, minConfs uint32, raw []byte, + group [33]byte, amount uint64, unspent bool) (*proof.Proof, error) { + + p, err := inspectAsset(raw, group, amount) + if err != nil { + return nil, err + } + if err := checkConfirmation(ctx, chain, minConfs, p, unspent); err != nil { + return nil, err + } + return p, nil +} + +// inspectAsset checks Loop's asset policy and isolated anchor of a proof +// without reading the chain. A failure is a property of the proof itself. +func inspectAsset(raw []byte, group [33]byte, amount uint64) (*proof.Proof, + error) { + + p, err := LastProof(raw) + if err != nil { + return nil, err + } + if err := checkAsset(p, group, amount); err != nil { + return nil, err + } + if _, _, err := isolatedRoots(p); err != nil { + return nil, err + } + return p, nil +} diff --git a/swapkit/tapsdk/test_constants_test.go b/swapkit/tapsdk/test_constants_test.go new file mode 100644 index 000000000..2b5aa75ee --- /dev/null +++ b/swapkit/tapsdk/test_constants_test.go @@ -0,0 +1,11 @@ +package tapsdk + +const ( + testSpoofedFeeValue = "spoofed fee value" + testValid = "valid" + testSpentOutput = "spent output" + testWrongSigner = "wrong signer" + testReorg = "reorg" + testSpentRefund = "spent refund" + testEven = "even" +) From d464aa59432979bd688e08681dcc060b053c6f83 Mon Sep 17 00:00:00 2001 From: Slyghtning Date: Tue, 3 Nov 2026 11:13:24 +0100 Subject: [PATCH 5/9] tapsdk: Approve transfer plans against agreed terms Prepare confirmed inputs for native Build and check its allocations, Bitcoin template, change policy and fee before granting authority. Verify wallet-funded fees again after native Commit. --- swapkit/tapsdk/approval.go | 331 +++++++++++++++++++++++++ swapkit/tapsdk/approval_test.go | 214 ++++++++++++++++ swapkit/tapsdk/bindings_test.go | 101 ++++++++ swapkit/tapsdk/deposit.go | 80 ++++++ swapkit/tapsdk/deposit_cache_test.go | 65 +++++ swapkit/tapsdk/funding_guard_test.go | 60 +++++ swapkit/tapsdk/inputs.go | 140 +++++++++++ swapkit/tapsdk/paths_test.go | 335 ++++++++++++++++++++++++++ swapkit/tapsdk/proofs.go | 79 ++++++ swapkit/tapsdk/signing.go | 8 + swapkit/tapsdk/signing_policy.go | 63 +++++ swapkit/tapsdk/signing_policy_test.go | 25 ++ 12 files changed, 1501 insertions(+) create mode 100644 swapkit/tapsdk/approval.go create mode 100644 swapkit/tapsdk/approval_test.go create mode 100644 swapkit/tapsdk/bindings_test.go create mode 100644 swapkit/tapsdk/deposit_cache_test.go create mode 100644 swapkit/tapsdk/funding_guard_test.go create mode 100644 swapkit/tapsdk/paths_test.go create mode 100644 swapkit/tapsdk/signing.go create mode 100644 swapkit/tapsdk/signing_policy.go create mode 100644 swapkit/tapsdk/signing_policy_test.go diff --git a/swapkit/tapsdk/approval.go b/swapkit/tapsdk/approval.go new file mode 100644 index 000000000..ab6d4a5c0 --- /dev/null +++ b/swapkit/tapsdk/approval.go @@ -0,0 +1,331 @@ +package tapsdk + +import ( + "bytes" + "fmt" + "math" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/tappsbt" +) + +// OutputBinding is an independently approved concrete asset allocation. A +// grouped allocation expanded into multiple issuances needs one entry per +// issuance. The caller retains these terms before accepting a peer request. +// ScriptKey includes the raw derivation so a peer cannot change later wallet +// recovery authority while retaining the same public output key. +type OutputBinding struct { + ID string + IssuanceID sdk.AssetID + AssetRef sdk.AssetRef + Amount uint64 + AnchorOutputIndex uint32 + AnchorValueSat int64 + ScriptMode sdk.CustomAssetScriptMode + ScriptKey sdk.ScriptKey + Anchor swapkit.AnchorPlan + OPTrue *sdk.CustomAssetOPTrueSpendInfo +} + +// ApprovePlan checks every native allocation and the whole Bitcoin template +// before Commit can sign virtual inputs. The independent template fixes every +// input, sequence, lock time, output value and non-asset output script; asset +// scripts are derived from approved contracts and native SDK commitment +// previews. No output ordering or fee is inferred from a peer's proposal. +// Native Build/Commit and durable approval remain owned by the caller's FSM. +func ApprovePlan(plan *sdk.CustomAnchorPlan, template *wire.MsgTx, + outputs []OutputBinding, maxFee uint64) error { + + return approvePlan(plan, template, outputs, maxFee, false) +} + +// ApproveWalletFundedPlan checks fixed allocations and template terms before +// wallet funding. A deficit template cannot establish a final fee or wallet +// change. Set the native request MaxFeeSat from independent policy and call +// CheckFundedPackage on Commit's result before signing, releasing or publishing +// its Bitcoin anchor. Only newly added wallet-generated change is supported. +func ApproveWalletFundedPlan(plan *sdk.CustomAnchorPlan, template *wire.MsgTx, + outputs []OutputBinding) error { + + return approvePlan(plan, template, outputs, 0, true) +} + +func approvePlan(plan *sdk.CustomAnchorPlan, template *wire.MsgTx, + outputs []OutputBinding, maxFee uint64, deferredFunding bool) error { + + if plan == nil || template == nil { + return swapkit.ErrInvalid + } + actual, err := DecodePSBT(plan.AnchorPSBT()) + if err != nil { + return err + } + request := plan.Request() + if request == nil { + return swapkit.ErrInvalid + } + if err := checkSigningPlans(actual, request.SigningPlans); err != nil { + return err + } + if deferredFunding || request.Funding.Mode == + sdk.CustomAnchorFundingWalletFunded { + + if err := checkWalletFunding(request.Funding); err != nil { + return err + } + } + tx := actual.UnsignedTx + if tx.Version != template.Version || tx.LockTime != template.LockTime || + len( + tx.TxIn, + ) != len( + template.TxIn, + ) || len(tx.TxOut) != len(template.TxOut) || + len(actual.Inputs) != len(tx.TxIn) { + + return fmt.Errorf("Bitcoin template differs from approval") + } + for i, input := range tx.TxIn { + expected := template.TxIn[i] + if input == nil || expected == nil || + input.PreviousOutPoint != expected.PreviousOutPoint || + input.Sequence != expected.Sequence { + + return fmt.Errorf( + "Bitcoin funding differs from approval", + ) + } + } + planned := plan.Outputs() + previews, err := plan.PreviewOutputCommitments() + if err != nil { + return err + } + if len(planned) != len(outputs) || len(previews) != len(outputs) { + return fmt.Errorf( + "asset allocation count differs from approval", + ) + } + active, passive := plan.ActiveVirtualPSBTs(), plan.PassiveVirtualPSBTs() + anchors := make(map[uint32][]byte) + matched := make([]bool, len(outputs)) + for i, out := range planned { + index := -1 + for j, expected := range outputs { + if !matched[j] && out.LogicalOutputID == expected.ID && + out.IssuanceID == expected.IssuanceID { + + index = j + break + } + } + if index < 0 { + return fmt.Errorf( + "unapproved asset issuance or allocation", + ) + } + matched[index] = true + expected := outputs[index] + if expected.ID == "" || + expected.IssuanceID == (sdk.AssetID{}) || + expected.Amount == 0 || + !out.AssetRef.Equivalent(expected.AssetRef) || + out.Amount != expected.Amount || + out.ScriptMode != expected.ScriptMode || + out.ScriptKey != expected.ScriptKey.PubKey || + out.AnchorOutputIndex != expected.AnchorOutputIndex || + out.AnchorValueSat != uint64(expected.AnchorValueSat) || + expected.AnchorValueSat < 330 { + + return fmt.Errorf( + "asset allocation differs from approval", + ) + } + preview := previews[i] + if preview.LogicalOutputID != out.LogicalOutputID || + preview.PacketIndex != out.PacketIndex || + preview.VirtualOutputIndex != out.VirtualOutputIndex || + preview.AnchorOutputIndex != out.AnchorOutputIndex { + + return swapkit.ErrInvalid + } + script, err := anchorScript( + expected.Anchor, + preview.TaprootAssetRoot, + ) + if err != nil { + return err + } + // Preview's full root incorporates the peer's anchor plan; deriving its + // output key from the independent plan catches a substituted Bitcoin tree. + actualScript, err := previewAnchorScript( + expected.Anchor.InternalKey, + preview.TaprootMerkleRoot, + ) + if err != nil { + return err + } + if !bytes.Equal(script, actualScript) { + return fmt.Errorf( + "output contract differs from approval", + ) + } + if prior := anchors[out.AnchorOutputIndex]; prior != nil && + !bytes.Equal(prior, script) { + + return fmt.Errorf( + "asset output has conflicting contracts", + ) + } + anchors[out.AnchorOutputIndex] = script + packets := active + if out.PacketRole == sdk.CustomAnchorPacketRolePassive { + packets = passive + } + if out.PacketIndex >= uint32(len(packets)) { + return swapkit.ErrInvalid + } + packet, err := tappsbt.Decode(packets[out.PacketIndex]) + if err != nil { + return err + } + if out.VirtualOutputIndex >= uint32(len(packet.Outputs)) { + return swapkit.ErrInvalid + } + virtual := packet.Outputs[out.VirtualOutputIndex] + if virtual.AnchorOutputInternalKey == nil || + !bytes.Equal( + virtual.AnchorOutputInternalKey.SerializeCompressed(), + expected.Anchor.InternalKey[:], + ) || + virtual.LockTime != 0 || + virtual.RelativeLockTime != 0 { + + return fmt.Errorf( + "asset anchor authority or timelocks differ from approval", + ) + } + key := virtual.ScriptKey + if key.TweakedScriptKey == nil || key.RawKey.PubKey == nil || + !bytes.Equal( + key.RawKey.PubKey.SerializeCompressed(), + expected.ScriptKey.KeyDesc.RawKeyBytes[:], + ) || + uint32( + key.RawKey.Family, + ) != expected.ScriptKey.KeyDesc.KeyLocator.Family || + key.RawKey.Index != expected.ScriptKey.KeyDesc.KeyLocator.Index || + !bytes.Equal(key.Tweak, expected.ScriptKey.TapTweak) { + + return fmt.Errorf( + "asset key derivation differs from approval", + ) + } + if expected.OPTrue != nil { + if err := expected.OPTrue.Validate(out.ScriptKey); err != nil { + return err + } + } + } + var inputValue, outputValue uint64 + for _, input := range actual.Inputs { + if input.WitnessUtxo == nil || input.WitnessUtxo.Value < 0 || + uint64( + input.WitnessUtxo.Value, + ) > math.MaxUint64-inputValue { + + return swapkit.ErrInvalid + } + inputValue += uint64(input.WitnessUtxo.Value) + } + for i, output := range tx.TxOut { + expected := template.TxOut[i] + if output == nil || expected == nil || output.Value < 0 || + output.Value != expected.Value || + uint64(output.Value) > math.MaxUint64-outputValue { + + return swapkit.ErrInvalid + } + // The SDK installs asset commitments during Commit. The template still + // carries the caller's placeholder; the approved contract was checked above. + if anchors[uint32(i)] == nil && + !bytes.Equal(output.PkScript, expected.PkScript) { + + return fmt.Errorf( + "Bitcoin recipient differs from approval", + ) + } + outputValue += uint64(output.Value) + } + if !deferredFunding && + (outputValue > inputValue || inputValue-outputValue > maxFee) { + + return fmt.Errorf("Bitcoin fee exceeds approval") + } + return nil +} + +func previewAnchorScript(internalKey [33]byte, root sdk.Hash) ([]byte, error) { + internal, err := btcec.ParsePubKey(internalKey[:]) + if err != nil { + return nil, err + } + return txscript.PayToTaprootScript( + txscript.ComputeTaprootOutputKey(internal, root[:]), + ) +} + +// CheckFundedPackage validates native wallet funding and its independently held +// absolute fee cap. It supplements fixed-allocation preapproval; the caller +// also retains the SDK committed digest and owns anchor signing/publication. +func CheckFundedPackage( + pkg *sdk.CustomAnchorTransferPackage, + maxFee uint64, +) error { + + if pkg == nil || maxFee == 0 { + return swapkit.ErrInvalid + } + if err := CheckSigningPolicy(pkg); err != nil { + return err + } + if pkg.Funding.Mode != sdk.CustomAnchorFundingWalletFunded || + pkg.Funding.MaxFeeSat != maxFee || pkg.Funding.ActualFeeSat > maxFee { + + return fmt.Errorf( + "native wallet funding differs from approved fee cap", + ) + } + if pkg.ChangeOutputIndex >= 0 { + packet, err := DecodePSBT(pkg.CommittedAnchorPsbt) + if err != nil { + return err + } + if int(pkg.ChangeOutputIndex) != len(packet.UnsignedTx.TxOut)-1 { + return fmt.Errorf("wallet change must be the added final output") + } + for _, output := range pkg.Outputs { + if output.AnchorOutputIndex == uint32(pkg.ChangeOutputIndex) { + return fmt.Errorf("wallet change cannot replace an asset output") + } + } + } + return nil +} + +// checkWalletFunding retains fixed approved recipients by allowing only a new +// wallet-generated change output. Existing and NoNew can change the accounting +// of an independently approved recipient without changing its script. +func checkWalletFunding(funding sdk.CustomAnchorFundingPlan) error { + if funding.Mode != sdk.CustomAnchorFundingWalletFunded || + funding.WalletFunded == nil || funding.WalletFunded.ChangeOutput.Mode != + sdk.AnchorChangeOutputAdd { + + return fmt.Errorf("wallet funding requires newly added wallet change") + } + return nil +} diff --git a/swapkit/tapsdk/approval_test.go b/swapkit/tapsdk/approval_test.go new file mode 100644 index 000000000..3a756badc --- /dev/null +++ b/swapkit/tapsdk/approval_test.go @@ -0,0 +1,214 @@ +package tapsdk + +import ( + "bytes" + "fmt" + "testing" + + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/txscript" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +func newPlanApprovalFixture(t *testing.T) (*builderFixture, + *psbt.Packet, OutputBinding) { + + t.Helper() + fixture := newCustomAnchorBuilderFixture(t) + kit, err := swapkit.NewSwapKit(swapKitTestParams(t)) + require.NoError(t, err) + fixture.request.Outputs[0], err = LegacyOPTrueOutput( + fixture.request.Outputs[0], + kit.AnchorPlan(), + ) + require.NoError(t, err) + template, err := DecodePSBT(fixture.request.AnchorPSBT) + require.NoError(t, err) + input, err := LastProof(fixture.request.Inputs[0].ProofFile) + require.NoError(t, err) + key, spend, err := LegacyOPTrueDescriptor() + require.NoError(t, err) + output := fixture.request.Outputs[0] + approval := OutputBinding{ + ID: output.ID, + IssuanceID: sdk.AssetID(input.Asset.ID()), + AssetRef: output.AssetRef, + Amount: output.Amount, + AnchorOutputIndex: output.AnchorOutputIndex, + AnchorValueSat: int64(output.AnchorValueSat), + ScriptMode: sdk.CustomAssetScriptExternal, + ScriptKey: key, + Anchor: kit.AnchorPlan(), + OPTrue: spend, + } + return fixture, template, approval +} + +func TestPlanRequiresIndependentApproval(t *testing.T) { + fixture, template, approval := newPlanApprovalFixture(t) + wallet := sdk.NewWallet(fixture.client, sdk.NetworkRegtest) + plan, err := wallet.NewCustomAnchorTxBuilder(). + Build(t.Context(), fixture.request) + require.NoError(t, err) + require.NoError( + t, + ApprovePlan( + plan, + template.UnsignedTx, + []OutputBinding{approval}, + 100_000, + ), + ) + for _, test := range []struct { + name string + change func(*OutputBinding) + }{ + {"issuance", func(a *OutputBinding) { a.IssuanceID[0] ^= 1 }}, + {"amount", func(a *OutputBinding) { a.Amount++ }}, + {"script key", func(a *OutputBinding) { a.ScriptKey.PubKey = testKey(t, 12) }}, + {"raw key parity", func(a *OutputBinding) { a.ScriptKey.KeyDesc.RawKeyBytes[0] ^= 1 }}, + {"wallet locator", func(a *OutputBinding) { a.ScriptKey.KeyDesc.KeyLocator.Index++ }}, + {"Bitcoin contract", func(a *OutputBinding) { a.Anchor.InternalKey = testKey(t, 11) }}, + } { + t.Run(test.name, func(t *testing.T) { + altered := approval + test.change(&altered) + require.Error( + t, + ApprovePlan( + plan, + template.UnsignedTx, + []OutputBinding{altered}, + 100_000, + ), + ) + }) + } + changed := template.UnsignedTx.Copy() + changed.TxIn[0].Sequence-- + require.Error( + t, + ApprovePlan(plan, changed, []OutputBinding{approval}, 100_000), + ) + changed = template.UnsignedTx.Copy() + changed.TxOut[0].Value-- + require.Error( + t, + ApprovePlan(plan, changed, []OutputBinding{approval}, 100_000), + ) + require.NoError( + t, + ApprovePlan( + plan, + template.UnsignedTx, + []OutputBinding{approval}, + 0, + ), + ) + // A deferred wallet approval must actually select wallet funding. + require.Error( + t, + ApproveWalletFundedPlan( + plan, + template.UnsignedTx, + []OutputBinding{approval}, + ), + ) + require.Equal(t, 1, fixture.client.verifyCalls) +} + +func TestPlanRequiresDefaultSigningPolicy(t *testing.T) { + for _, hash := range []txscript.SigHashType{ + txscript.SigHashAll, txscript.SigHashNone, + txscript.SigHashSingle, + txscript.SigHashAll | txscript.SigHashAnyOneCanPay, + } { + t.Run(fmt.Sprintf("hash%d", hash), func(t *testing.T) { + fixture, template, approval := newPlanApprovalFixture(t) + template.Inputs[0].SighashType = hash + var err error + fixture.request.AnchorPSBT, err = EncodePSBT(template) + require.NoError(t, err) + wallet := sdk.NewWallet(fixture.client, sdk.NetworkRegtest) + plan, err := wallet.NewCustomAnchorTxBuilder().Build( + t.Context(), fixture.request, + ) + require.NoError(t, err) + require.ErrorIs(t, ApprovePlan(plan, template.UnsignedTx, + []OutputBinding{approval}, 100_000), ErrSigningRequest) + require.ErrorIs(t, ApproveWalletFundedPlan(plan, + template.UnsignedTx, []OutputBinding{approval}), + ErrSigningRequest) + }) + } +} + +func TestWalletFundingChangeApproval(t *testing.T) { + for name, mode := range map[string]sdk.AnchorChangeOutputMode{ + "new wallet change": sdk.AnchorChangeOutputAdd, + "existing output": sdk.AnchorChangeOutputExisting, + "no new output": sdk.AnchorChangeOutputNoNew, + } { + t.Run(name, func(t *testing.T) { + fixture, template, approval := newPlanApprovalFixture(t) + fee, err := sdk.NewFeeRateSatPerVByte(1) + require.NoError(t, err) + fixture.request.Funding = sdk.CustomAnchorFundingPlan{ + Mode: sdk.CustomAnchorFundingWalletFunded, + WalletFunded: &sdk.CustomAnchorWalletFunding{ + ChangeOutput: sdk.AnchorChangeOutput{ + Mode: mode, ExistingOutputIndex: 2, + }, + Fee: sdk.AnchorFee{ + Mode: sdk.AnchorFeeSatPerVByte, FeeRate: fee, + }, + MaxFeeSat: 10_000, + CustomLockID: bytes.Repeat([]byte{1}, 32), + }, + } + wallet := sdk.NewWallet(fixture.client, sdk.NetworkRegtest) + plan, err := wallet.NewCustomAnchorTxBuilder().Build( + t.Context(), fixture.request, + ) + require.NoError(t, err) + err = ApproveWalletFundedPlan(plan, template.UnsignedTx, + []OutputBinding{approval}) + if mode == sdk.AnchorChangeOutputAdd { + require.NoError(t, err) + } else { + require.ErrorContains(t, err, "newly added wallet change") + } + }) + } +} + +func TestFundedPackagePolicy(t *testing.T) { + f := newPathFixture(t) + plan, err := f.wallet.NewCustomAnchorTxBuilder().Build( + t.Context(), f.request, + ) + require.NoError(t, err) + pkg, err := plan.Commit(t.Context()) + require.NoError(t, err) + require.Error(t, CheckFundedPackage(pkg, 2_000)) + pkg.Funding.Mode = sdk.CustomAnchorFundingWalletFunded + pkg.Funding.MaxFeeSat = 2_000 + pkg.FundingLock.CustomLockID = bytes.Repeat([]byte{1}, 32) + pkg, err = pkg.Seal() + require.NoError(t, err) + require.NoError(t, CheckFundedPackage(pkg, 2_000)) + require.Error(t, CheckFundedPackage(pkg, 1_999)) + changedHash := withSigningHash(t, pkg, pkg.SigningPlans[0].InputIndex, + txscript.SigHashAll) + require.ErrorIs(t, CheckFundedPackage(changedHash, 2_000), + ErrSigningRequest) + for _, index := range []int32{0, 1} { + changed := pkg.Clone() + changed.ChangeOutputIndex = index + changed, err = changed.Seal() + require.NoError(t, err) + require.Error(t, CheckFundedPackage(changed, 2_000)) + } +} diff --git a/swapkit/tapsdk/bindings_test.go b/swapkit/tapsdk/bindings_test.go new file mode 100644 index 000000000..ddf48d33a --- /dev/null +++ b/swapkit/tapsdk/bindings_test.go @@ -0,0 +1,101 @@ +package tapsdk + +import ( + "testing" + + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +func TestDirectionNeutralProofBindings(t *testing.T) { + for _, test := range []struct { + name string + change func(*InputBinding) + }{ + {name: testValid}, + {"issuance", func(b *InputBinding) { b.IssuanceID[0] ^= 1 }}, + {"amount", func(b *InputBinding) { b.Amount++ }}, + {"unexpected group", func(b *InputBinding) { k := testKey(t, 11); b.GroupKey = &k }}, + {"outpoint", func(b *InputBinding) { b.AnchorOutpoint.Index++ }}, + {"script key", func(b *InputBinding) { b.ScriptKey = testKey(t, 12) }}, + {"contract authority", func(b *InputBinding) { b.Anchor.InternalKey = testKey(t, 12) }}, + {"spend root", func(b *InputBinding) { b.Spend.TaprootMerkleRoot[0] ^= 1 }}, + } { + t.Run(test.name, func(t *testing.T) { + f := newPathFixture(t) + binding := f.binding.clone() + if test.change != nil { + test.change(&binding) + } + _, err := VerifyInputProof( + t.Context(), + f.wallet, + f.chain, + 2, + f.request.Inputs[0].ProofFile, + binding, + true, + ) + if test.change == nil { + require.NoError(t, err) + require.Equal(t, 1, f.client.verifies) + } else { + require.Error(t, err) + require.Zero(t, f.client.verifies) + } + }) + } +} + +func TestApprovalChecksBitcoinOnlyFunding(t *testing.T) { + f := newPathFixture(t) + require.NoError( + t, + CheckInputsCurrent(t.Context(), f.chain, 2, f.request, true), + ) + delete(f.chain.utxos, requestPoint(t, f.request, 0)) + require.Error( + t, + CheckInputsCurrent(t.Context(), f.chain, 2, f.request, true), + ) + // Exact plan approval also caps a real nonzero native transfer fee. + f = newPathFixture(t) + template, err := DecodePSBT(f.request.AnchorPSBT) + require.NoError(t, err) + key, spend, err := LegacyOPTrueDescriptor() + require.NoError(t, err) + output := f.request.Outputs[0] + approved := OutputBinding{ + ID: output.ID, + IssuanceID: f.binding.IssuanceID, + AssetRef: output.AssetRef, + Amount: output.Amount, + AnchorOutputIndex: output.AnchorOutputIndex, + AnchorValueSat: int64(output.AnchorValueSat), + ScriptMode: sdk.CustomAssetScriptExternal, + ScriptKey: key, + Anchor: f.kit.AnchorPlan(), + OPTrue: spend, + } + plan, err := f.wallet.NewCustomAnchorTxBuilder(). + Build(t.Context(), f.request) + require.NoError(t, err) + require.NoError( + t, + ApprovePlan( + plan, + template.UnsignedTx, + []OutputBinding{approved}, + 2_000, + ), + ) + require.Error( + t, + ApprovePlan( + plan, + template.UnsignedTx, + []OutputBinding{approved}, + 1_999, + ), + ) +} diff --git a/swapkit/tapsdk/deposit.go b/swapkit/tapsdk/deposit.go index bdc4c0c7d..efd8ac803 100644 --- a/swapkit/tapsdk/deposit.go +++ b/swapkit/tapsdk/deposit.go @@ -5,10 +5,90 @@ import ( "context" "errors" + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" "github.com/lightninglabs/loop/swapkit" sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/proof" ) +// AnchorTemplate constructs the Bitcoin transaction for one asset input. +func AnchorTemplate(p *proof.Proof, receiver sdk.InternalKey, value int64, + spend *swapkit.SwapAnchorSpendInfo) ([]byte, error) { + + if value < 330 || p == nil || + p.OutPoint().Index >= uint32(len(p.AnchorTx.TxOut)) || + p.AnchorTx.TxOut[p.OutPoint().Index] == nil { + + return nil, swapkit.ErrInvalid + } + internal, err := btcec.ParsePubKey(receiver.PubKey[:]) + if err != nil { + return nil, err + } + placeholder, err := txscript.PayToTaprootScript( + txscript.ComputeTaprootKeyNoScript(internal)) + if err != nil { + return nil, err + } + point := p.OutPoint() + tx := wire.NewMsgTx(2) + tx.AddTxIn(wire.NewTxIn(&point, nil, nil)) + tx.AddTxOut(wire.NewTxOut(value, placeholder)) + tx.TxIn[0].Sequence = 0xfffffffc + prev := p.AnchorTx.TxOut[point.Index] + if spend != nil { + if !bytes.Equal(prev.PkScript, spend.PkScript) { + return nil, swapkit.ErrInvalid + } + tx.LockTime = spend.LockTime + tx.TxIn[0].Sequence = spend.Sequence + } + packet, err := psbt.NewFromUnsignedTx(tx) + if err != nil { + return nil, err + } + packet.Inputs[0].WitnessUtxo = prev + if spend != nil { + packet.Inputs[0].TaprootInternalKey = spend.InternalKey[1:] + packet.Inputs[0].TaprootMerkleRoot = spend.TaprootMerkleRoot[:] + leaf := &psbt.TaprootTapLeafScript{ + ControlBlock: spend.ControlBlock, + Script: spend.LeafScript, + LeafVersion: txscript.BaseLeafVersion, + } + leaves := []*psbt.TaprootTapLeafScript{leaf} + packet.Inputs[0].TaprootLeafScript = leaves + } + return EncodePSBT(packet) +} + +// CustomRequest fixes one input/output with no passive assets or asset loss. +func CustomRequest(input sdk.CustomAssetInput, + output sdk.CustomAssetOutput, anchor []byte, + signing sdk.CustomAnchorInputSigningPlan) *sdk.CustomAnchorRequest { + + exact := &sdk.CustomAnchorCallerFundedExact{} + mode := sdk.CustomAnchorFundingCallerFundedExact + return &sdk.CustomAnchorRequest{ + Inputs: []sdk.CustomAssetInput{input}, + Outputs: []sdk.CustomAssetOutput{output}, AnchorPSBT: anchor, + Funding: sdk.CustomAnchorFundingPlan{ + Mode: mode, + CallerFundedExact: exact, + }, + PassiveAssets: sdk.CustomAnchorPassiveAssets{ + Policy: sdk.CustomAnchorPassiveReject, + }, + LossPolicy: sdk.CustomAnchorLossPolicy{ + Mode: sdk.CustomAnchorLossReject, + }, + SigningPlans: []sdk.CustomAnchorInputSigningPlan{signing}, + } +} + // FundingProof selects the exact confirmed wallet output for a deposit. // It inspects Loop policy; the subsequent SDK Build verifies lineage once. // ErrInvalid means the wallet holds no matching unspent output. A matching diff --git a/swapkit/tapsdk/deposit_cache_test.go b/swapkit/tapsdk/deposit_cache_test.go new file mode 100644 index 000000000..96f270a68 --- /dev/null +++ b/swapkit/tapsdk/deposit_cache_test.go @@ -0,0 +1,65 @@ +package tapsdk + +import ( + "testing" + + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +// TestSDKBuilderOwnsInputVerification covers the real SDK builder call. The +// Loop checks on each side must not call verifyProof a second time, and the +// post-build check rejects chain changes during the SDK verification RPC. +func TestSDKBuilderOwnsInputVerification(t *testing.T) { + for _, change := range []string{"none", testReorg, "mempool spend"} { + t.Run(change, func(t *testing.T) { + fixture := newCustomAnchorBuilderFixture(t) + p, err := LastProof(fixture.request.Inputs[0].ProofFile) + require.NoError(t, err) + chain := &bindingChain{ + tip: p.BlockHeight + 1, + unspent: true, + blocks: map[uint32]*wire.MsgBlock{ + p.BlockHeight: bindingBlock(p), + }, + } + fixture.client.afterVerify = func() { + switch change { + case testReorg: + chain.blocks[p.BlockHeight].Header.Nonce++ + case "mempool spend": + chain.unspent = false + } + } + require.NoError( + t, + CheckInputsCurrent(t.Context(), chain, 1, + fixture.request, true), + ) + require.Zero(t, fixture.client.verifyCalls) + wallet := sdk.NewWallet( + fixture.client, + sdk.NetworkRegtest, + ) + _, err = wallet.NewCustomAnchorTxBuilder(). + Build(t.Context(), fixture.request) + require.NoError(t, err) + require.Equal(t, 1, fixture.client.verifyCalls) + err = CheckInputsCurrent( + t.Context(), + chain, + 1, + fixture.request, + true, + ) + if change == "none" { + require.NoError(t, err) + } else { + require.ErrorIs(t, err, swapkit.ErrPending) + } + require.Equal(t, 1, fixture.client.verifyCalls) + }) + } +} diff --git a/swapkit/tapsdk/funding_guard_test.go b/swapkit/tapsdk/funding_guard_test.go new file mode 100644 index 000000000..707db9f05 --- /dev/null +++ b/swapkit/tapsdk/funding_guard_test.go @@ -0,0 +1,60 @@ +package tapsdk + +import ( + "context" + "testing" + + "github.com/btcsuite/btcd/wire" + "github.com/stretchr/testify/require" +) + +type fundingPrevouts map[wire.OutPoint]*wire.TxOut + +func (p fundingPrevouts) Prevout( + _ context.Context, + point wire.OutPoint, +) (*wire.TxOut, error) { + + return p[point], nil +} + +func TestFundingInputsRequireAuthenticatedPrevouts(t *testing.T) { + f := newPathFixture(t) + plan, err := f.wallet.NewCustomAnchorTxBuilder(). + Build(t.Context(), f.request) + require.NoError(t, err) + source := fundingPrevouts(f.chain.utxos) + require.NoError( + t, + CheckFundingInputs(t.Context(), source, plan.AnchorPSBT()), + ) + for _, test := range []struct { + name string + change func(*wire.TxOut) + }{ + {"fee amount", func(output *wire.TxOut) { output.Value++ }}, + {"fee script", func(output *wire.TxOut) { output.PkScript = []byte{0x51} }}, + } { + t.Run(test.name, func(t *testing.T) { + point := requestPoint(t, f.request, 0) + original := source[point] + fake := wire.NewTxOut(original.Value, original.PkScript) + test.change(fake) + source[point] = fake + require.Error( + t, + CheckFundingInputs( + t.Context(), + source, + plan.AnchorPSBT(), + ), + ) + source[point] = original + }) + } + delete(source, requestPoint(t, f.request, 0)) + require.Error( + t, + CheckFundingInputs(t.Context(), source, plan.AnchorPSBT()), + ) +} diff --git a/swapkit/tapsdk/inputs.go b/swapkit/tapsdk/inputs.go index eb3549331..2ee321573 100644 --- a/swapkit/tapsdk/inputs.go +++ b/swapkit/tapsdk/inputs.go @@ -1,17 +1,129 @@ package tapsdk import ( + "bytes" "context" "fmt" "github.com/btcsuite/btcd/btcutil/psbt" "github.com/btcsuite/btcd/wire" + assetpolicy "github.com/lightninglabs/loop/internal/assetpolicy" "github.com/lightninglabs/loop/internal/assetproof" "github.com/lightninglabs/loop/swapkit" sdk "github.com/lightninglabs/tap-sdk" "github.com/lightninglabs/taproot-assets/proof" ) +// PrepareInputs restores proof lineage and declares OP_TRUE inputs in tapd. +// The SDK builder owns full input proof verification; this does not repeat it. +func PrepareInputs(ctx context.Context, wallet *sdk.Wallet, + request *sdk.CustomAnchorRequest) error { + + if request == nil { + return swapkit.ErrInvalid + } + // Bound the complete request before decoding or importing any history. + var size int + var raws [][]byte + for _, input := range request.Inputs { + raw := input.ProofFile + if input.ProofPath != nil { + if len(raw) != 0 { + return swapkit.ErrInvalid + } + if err := input.ProofPath.Validate(); err != nil { + return err + } + encoded, err := input.ProofPath.MarshalBinary() + if err != nil { + return err + } + if len(encoded) > assetpolicy.MaxProvenanceBytes-size { + return swapkit.ErrInvalid + } + size += len(encoded) + raw = input.ProofPath.ConfirmedBaseProof + } else { + if len(raw) > assetpolicy.MaxProvenanceBytes-size { + return swapkit.ErrInvalid + } + size += len(raw) + } + raws = append(raws, raw) + } + for _, passive := range request.PassiveAssets.Packets { + if len( + passive.ProofFile, + ) > assetpolicy.MaxProvenanceBytes-size { + + return swapkit.ErrInvalid + } + size += len(passive.ProofFile) + raws = append(raws, passive.ProofFile) + } + request = request.Clone() + for i := range raws { + raws[i] = bytes.Clone(raws[i]) + } + params, err := nodeParams(ctx, wallet) + if err != nil { + return err + } + var inventory []*proof.Proof + for _, raw := range raws { + if err := checkProvenanceWithParams(ctx, raw, params); err != nil { + return err + } + p, err := LastProof(raw) + if err != nil { + return err + } + inventory = append(inventory, p) + } + if err := assetproof.VerifyCompleteAnchors(inventory); err != nil { + return err + } + for _, input := range request.Inputs { + raw := input.ProofFile + var p *proof.Proof + if input.ProofPath != nil { + raw = input.ProofPath.ConfirmedBaseProof + if len(input.ProofPath.Steps) > 0 { + p, err = proof.Decode( + input.ProofPath.Steps[len(input.ProofPath.Steps)-1].TransitionProof, + ) + } + } + if p == nil && err == nil { + p, err = LastProof(raw) + } + if err != nil { + return err + } + if input.Witness.Mode == sdk.CustomAssetWitnessCallerProvided { + pub, err := sdk.ParsePubKey( + p.Asset.ScriptKey.PubKey.SerializeCompressed(), + ) + if err != nil { + return err + } + if err := declareOPTrue(ctx, wallet, pub, input.Witness.Stack); err != nil { + return err + } + } + if err := importProof(ctx, wallet, raw); err != nil { + return err + } + } + for _, passive := range request.PassiveAssets.Packets { + if err := importProof(ctx, wallet, passive.ProofFile); err != nil { + return err + } + } + + return nil +} + // CheckInputsCurrent repeats chain checks after SDK Build's verification RPCs. // Call it before Commit so verification cannot authorize a now stale input. func CheckInputsCurrent(ctx context.Context, chain Chain, minConfs uint32, @@ -65,6 +177,34 @@ func CheckInputsCurrent(ctx context.Context, chain Chain, minConfs uint32, return nil } +// commit rebuilds an already observed transfer's proof. It never signs a +// wallet transaction; the caller applies the observed Bitcoin witness. +func commit( + ctx context.Context, + wallet *sdk.Wallet, + chain Chain, + minConfs uint32, + request *sdk.CustomAnchorRequest, +) (*sdk.CustomAnchorTransferPackage, error) { + + if err := PrepareInputs(ctx, wallet, request); err != nil { + return nil, err + } + plan, err := wallet.NewCustomAnchorTxBuilder().Build(ctx, request) + if err != nil { + return nil, err + } + err = CheckInputsCurrent(ctx, chain, minConfs, request, false) + if err != nil { + return nil, err + } + return plan.Commit(ctx, sdk.CustomAnchorCommitOptions{ + Publish: sdk.CustomAnchorPublishMetadata{ + Label: "Loop asset transfer", + }, + }) +} + // checkFundingCurrent checks all asset and Bitcoin-only funding inputs. Skip // contains only the outputs supplied by independently approved signed parents. func checkFundingCurrent(ctx context.Context, chain Chain, packet *psbt.Packet, diff --git a/swapkit/tapsdk/paths_test.go b/swapkit/tapsdk/paths_test.go new file mode 100644 index 000000000..fb10bbe11 --- /dev/null +++ b/swapkit/tapsdk/paths_test.go @@ -0,0 +1,335 @@ +package tapsdk + +import ( + "bytes" + "context" + "fmt" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/tappsbt" + "github.com/lightninglabs/taproot-assets/tapsend" + "github.com/stretchr/testify/require" +) + +type pathChain struct { + Chain + + blocks map[uint32]*wire.MsgBlock + utxos map[wire.OutPoint]*wire.TxOut +} + +func (c *pathChain) Prevout(_ context.Context, point wire.OutPoint) (*wire.TxOut, error) { + return c.utxos[point], nil +} + +func (c *pathChain) Height(context.Context) (uint32, error) { return 200, nil } + +func (c *pathChain) Block(_ context.Context, h uint32) (*wire.MsgBlock, error) { + return c.blocks[h], nil +} + +func (c *pathChain) BlockHash(_ context.Context, + height uint32) (chainhash.Hash, error) { + + block := c.blocks[height] + if block == nil { + return chainhash.Hash{}, swapkit.ErrPending + } + return block.BlockHash(), nil +} + +func (c *pathChain) Unspent(_ context.Context, p wire.OutPoint) (bool, error) { + return c.utxos[p] != nil, nil +} + +type pathClient struct { + sdk.Client + + t *testing.T + verifies, commits, publishes int + afterVerify func() + afterInfo func() +} + +func (c *pathClient) GetInfo(context.Context) (*sdk.Info, error) { + if c.afterInfo != nil { + c.afterInfo() + } + return fixtureNodeInfo(), nil +} + +func (c *pathClient) VerifyProof(_ context.Context, raw []byte) (*sdk.VerifyProofResponse, error) { + c.verifies++ + if c.afterVerify != nil { + c.afterVerify() + } + return fixtureVerified(raw, true) +} + +func (c *pathClient) CustomAnchorCapabilities(context.Context) (*sdk.CustomAnchorCapabilities, error) { + v := sdk.DefaultTapdCustomAnchorCapabilities() + return &v, nil +} + +func (c *pathClient) PublishAndLogTransferWithRequest(context.Context, + *sdk.PublishAndLogTransferRequest) (*sdk.AssetPacket, error) { + + c.publishes++ + return nil, fmt.Errorf("publication is outside this test") +} + +// The actual SDK builds and validates transitions and verifies this deterministic +// test backend's commit response. Production uses tapd's implementation. +func (c *pathClient) CommitVirtualPsbtsWithRequest(_ context.Context, + r *sdk.CommitVirtualPsbtsRequest) (*sdk.CommitVirtualPsbtsResponse, error) { + + c.commits++ + t := c.t + anchor, err := DecodePSBT(r.AnchorPsbt) + require.NoError(t, err) + decode := func(raws [][]byte) []*tappsbt.VPacket { + v := make([]*tappsbt.VPacket, len(raws)) + for i, raw := range raws { + v[i], err = tappsbt.Decode(raw) + require.NoError(t, err) + } + return v + } + active, passive := decode(r.VirtualPsbts), decode(r.PassiveAssetPsbts) + all := append(append([]*tappsbt.VPacket(nil), active...), passive...) + commits, err := tapsend.CreateOutputCommitments(all, tapsend.WithSpenderLeaves()) + require.NoError(t, err) + for _, p := range all { + require.NoError(t, tapsend.UpdateTaprootOutputKeys(anchor, p, commits)) + } + for _, p := range all { + for i := range p.Outputs { + p.Outputs[i].ProofSuffix, err = tapsend.CreateProofSuffix( + anchor.UnsignedTx, anchor.Outputs, p, commits, i, all, + proof.WithVersion(proof.TransitionV1), + ) + require.NoError(t, err) + } + } + encode := func(packets []*tappsbt.VPacket) [][]byte { + raw := make([][]byte, len(packets)) + for i, p := range packets { + raw[i], err = tappsbt.Encode(p) + require.NoError(t, err) + } + return raw + } + raw, err := EncodePSBT(anchor) + require.NoError(t, err) + return &sdk.CommitVirtualPsbtsResponse{ + AnchorPsbt: raw, VirtualPsbts: encode(active), + PassiveAssetPsbts: encode(passive), ChangeOutputIndex: -1, + }, nil +} + +type pathFixture struct { + wallet *sdk.Wallet + client *pathClient + chain *pathChain + request *sdk.CustomAnchorRequest + binding InputBinding + kit *swapkit.SwapKit +} + +func newPathFixture(t *testing.T) *pathFixture { + t.Helper() + f := &pathFixture{client: &pathClient{t: t}, chain: &pathChain{ + blocks: make(map[uint32]*wire.MsgBlock), + utxos: make(map[wire.OutPoint]*wire.TxOut), + }} + f.wallet = sdk.NewWallet(f.client, sdk.NetworkRegtest) + deposit, err := swapkit.NewDepositKit(swapkit.DepositKitParams{ + ClientKey: bindingPub(1), ServerKey: bindingPub(2), CSVExpiry: 144, + }) + require.NoError(t, err) + params := swapKitTestParams(t) + params.Policy, params.Expiry = swapkit.SwapHTLCCLTV, 1_000_000 + f.kit, err = swapkit.NewSwapKit(params) + require.NoError(t, err) + key, optrue, err := LegacyOPTrueDescriptor() + require.NoError(t, err) + pub, err := btcec.ParsePubKey(key.PubKey[:]) + require.NoError(t, err) + genesis := asset.Genesis{ + FirstPrevOut: wire.OutPoint{Hash: chainhash.Hash{1}, Index: 1}, + Tag: "native-path", OutputIndex: 0, Type: asset.Normal, + } + a, err := asset.New(genesis, 1_000, 0, 0, asset.NewScriptKey(pub), nil, asset.WithAssetVersion(asset.V1)) + require.NoError(t, err) + version := commitment.TapCommitmentV2 + tc, err := commitment.FromAssets(&version, a) + require.NoError(t, err) + root := tc.TapscriptRoot(nil) + spend, err := deposit.TimeoutSpend(swapkit.Hash(root)) + require.NoError(t, err) + mint := wire.NewMsgTx(2) + mint.AddTxIn(wire.NewTxIn(&genesis.FirstPrevOut, nil, nil)) + mint.AddTxOut(wire.NewTxOut(1_000, spend.PkScript)) + block := &wire.MsgBlock{Header: wire.BlockHeader{MerkleRoot: mint.TxHash()}, Transactions: []*wire.MsgTx{mint}} + plan := deposit.AnchorPlan() + internal, err := btcec.ParsePubKey(plan.InternalKey[:]) + require.NoError(t, err) + sibling, err := commitment.NewPreimageFromLeaf(txscript.NewBaseTapLeaf(plan.Leaves[0])) + require.NoError(t, err) + generated, err := proof.NewMintingBlobs(&proof.MintParams{ + Block: block, BlockHeight: 101, Tx: mint, TxIndex: 0, + OutputIndex: 0, InternalKey: internal, TaprootAssetRoot: tc, + TapscriptSibling: sibling, GenesisPoint: genesis.FirstPrevOut, + }, proof.MockVerifierCtx, proof.WithSiblingPreimage(sibling), + proof.WithGenOption(proof.WithVersion(proof.TransitionV1))) + require.NoError(t, err) + p := generated[asset.ToSerialized(a.ScriptKey.PubKey)] + raw, err := proof.EncodeAsProofFile(p) + require.NoError(t, err) + f.chain.blocks[101] = block + f.chain.utxos[p.OutPoint()] = mint.TxOut[0] + f.binding = InputBinding{ + ID: "asset", IssuanceID: sdk.AssetID(a.ID()), Amount: a.Amount, + ScriptKey: key.PubKey, Anchor: &plan, Spend: spend, + AnchorOutpoint: sdk.Outpoint{Txid: sdk.Hash(p.OutPoint().Hash), Index: 0}, + } + output, err := LegacyOPTrueOutput(sdk.CustomAssetOutput{ + ID: "next", AssetRef: sdk.AssetRefFromAssetID(sdk.AssetID(a.ID())), + Amount: a.Amount, AnchorOutputIndex: 1, AnchorValueSat: 1_000, + }, f.kit.AnchorPlan()) + require.NoError(t, err) + input := sdk.CustomAssetInput{ + ID: "asset", AssetRef: output.AssetRef, Amount: a.Amount, ProofFile: raw, + Witness: sdk.CustomAssetWitnessPlan{ + Mode: sdk.CustomAssetWitnessCallerProvided, Stack: optrue.WitnessStack(), + }, + } + f.request = f.requestFor(t, p, spend, input, output, wire.OutPoint{Hash: chainhash.Hash{99}}, 50_000) + return f +} + +func (f *pathFixture) requestFor(t *testing.T, p *proof.Proof, + spend *swapkit.SwapAnchorSpendInfo, input sdk.CustomAssetInput, + output sdk.CustomAssetOutput, feePoint wire.OutPoint, + feeValue int64) *sdk.CustomAnchorRequest { + + t.Helper() + feeKey := bindingKey(5) + feeScript, err := txscript.PayToTaprootScript(txscript.ComputeTaprootKeyNoScript(feeKey.PubKey())) + require.NoError(t, err) + feeOut := wire.NewTxOut(feeValue, feeScript) + if f.chain.utxos[feePoint] == nil { + f.chain.utxos[feePoint] = feeOut + } + tx := wire.NewMsgTx(2) + tx.LockTime = spend.LockTime + tx.AddTxIn(&wire.TxIn{PreviousOutPoint: feePoint, Sequence: wire.MaxTxInSequenceNum - 1}) + tx.AddTxIn(&wire.TxIn{PreviousOutPoint: p.OutPoint(), Sequence: spend.Sequence}) + tx.AddTxOut(wire.NewTxOut(feeValue-2_000, feeScript)) + tx.AddTxOut(wire.NewTxOut(1_000, feeScript)) + packet, err := psbt.NewFromUnsignedTx(tx) + require.NoError(t, err) + packet.Inputs[0].WitnessUtxo = feeOut + pub := feeKey.PubKey().SerializeCompressed() + packet.Inputs[0].TaprootInternalKey = bytes.Clone(pub[1:]) + packet.Outputs[0].TaprootInternalKey = bytes.Clone(pub[1:]) + packet.Inputs[1].WitnessUtxo = p.AnchorTx.TxOut[p.OutPoint().Index] + packet.Inputs[1].TaprootInternalKey = bytes.Clone(spend.InternalKey[1:]) + packet.Inputs[1].TaprootMerkleRoot = bytes.Clone(spend.TaprootMerkleRoot[:]) + packet.Inputs[1].TaprootLeafScript = []*psbt.TaprootTapLeafScript{{ + ControlBlock: spend.ControlBlock, Script: spend.LeafScript, + LeafVersion: txscript.BaseLeafVersion, + }} + raw, err := EncodePSBT(packet) + require.NoError(t, err) + return &sdk.CustomAnchorRequest{ + Inputs: []sdk.CustomAssetInput{input}, Outputs: []sdk.CustomAssetOutput{output}, + AnchorPSBT: raw, Funding: sdk.CustomAnchorFundingPlan{ + Mode: sdk.CustomAnchorFundingCallerFundedExact, + CallerFundedExact: &sdk.CustomAnchorCallerFundedExact{}, + }, + SigningPlans: []sdk.CustomAnchorInputSigningPlan{{InputIndex: 0, + KeyPath: &sdk.CustomAnchorKeyPathSigningPlan{Signer: sdk.XOnlyPubKey(pub[1:])}}, + ScriptSigningPlan(spend, 1)}, + } +} + +func pathFinal(t *testing.T, pkg *sdk.CustomAnchorTransferPackage) *sdk.CustomAnchorTransferPackage { + t.Helper() + packet, err := DecodePSBT(pkg.AnchorPsbt) + require.NoError(t, err) + requests, err := pkg.SigningRequests() + require.NoError(t, err) + for _, req := range requests.KeyPath { + key := txscript.TweakTaprootPrivKey(*bindingKey(5), req.TaprootMerkleRoot) + sig, err := schnorr.Sign(key, req.Sighash[:]) + require.NoError(t, err) + packet.Inputs[req.InputIndex].TaprootKeySpendSig = sig.Serialize() + } + for _, req := range requests.ScriptPath { + sig, err := schnorr.Sign(bindingKey(1), req.Sighash[:]) + require.NoError(t, err) + var b bytes.Buffer + require.NoError(t, psbt.WriteTxWitness(&b, [][]byte{sig.Serialize(), req.LeafScript, req.ControlBlock})) + packet.Inputs[req.InputIndex].FinalScriptWitness = b.Bytes() + } + require.NoError(t, psbt.MaybeFinalizeAll(packet)) + raw, err := EncodePSBT(packet) + require.NoError(t, err) + final, err := pkg.WithFinalAnchorPSBT(raw) + require.NoError(t, err) + return final +} + +func (f *pathFixture) parent(t *testing.T) (*sdk.CustomAnchorTransferPackage, *sdk.CustomAnchorTransferPackage) { + t.Helper() + plan, err := f.wallet.NewCustomAnchorTxBuilder().Build(t.Context(), f.request) + require.NoError(t, err) + unsigned, err := plan.Commit(t.Context(), sdk.CustomAnchorCommitOptions{}) + require.NoError(t, err) + return unsigned, pathFinal(t, unsigned) +} + +func (f *pathFixture) child(t *testing.T, + parent *sdk.CustomAnchorTransferPackage) (*sdk.CustomAnchorRequest, InputBinding) { + + t.Helper() + p, err := proof.Decode(parent.ProofUpdates[0].ProofBlob) + require.NoError(t, err) + root, _, err := isolatedRoots(p) + require.NoError(t, err) + spend, err := f.kit.TimeoutSpend(swapkit.Hash(root)) + require.NoError(t, err) + binding := f.binding + plan := f.kit.AnchorPlan() + binding.Anchor, binding.Spend = &plan, spend + binding.AnchorOutpoint = sdk.Outpoint{Txid: sdk.Hash(p.OutPoint().Hash), Index: p.OutPoint().Index} + input := f.request.Inputs[0] + input.ProofPath = &sdk.AssetProofPath{ + ConfirmedBaseProof: input.ProofFile, + Steps: []sdk.AssetProofPathStep{{TransitionProof: parent.ProofUpdates[0].ProofBlob}}, + } + input.ProofFile = nil + request := f.requestFor(t, p, spend, input, f.request.Outputs[0], + wire.OutPoint{Hash: p.OutPoint().Hash, Index: 0}, 48_000) + delete(f.chain.utxos, requestPoint(t, request, 0)) + return request, binding +} + +func requestPoint(t *testing.T, request *sdk.CustomAnchorRequest, index int) wire.OutPoint { + t.Helper() + p, err := DecodePSBT(request.AnchorPSBT) + require.NoError(t, err) + return p.UnsignedTx.TxIn[index].PreviousOutPoint +} diff --git a/swapkit/tapsdk/proofs.go b/swapkit/tapsdk/proofs.go index 965e991ea..b1cb924bb 100644 --- a/swapkit/tapsdk/proofs.go +++ b/swapkit/tapsdk/proofs.go @@ -131,6 +131,85 @@ func DecodePSBT(raw []byte) (*psbt.Packet, error) { return psbt.NewFromRawBytes(bytes.NewReader(raw), false) } +// EncodePSBT serializes a native Bitcoin PSBT. +func EncodePSBT(p *psbt.Packet) ([]byte, error) { + var b bytes.Buffer + err := p.Serialize(&b) + return b.Bytes(), err +} + +// MaxPackageBytes bounds native JSON package decoding, including base64 proof +// files and PSBTs. The encoded package must fit before signing and on recovery. +const MaxPackageBytes = 2 * assetpolicy.MaxProvenanceBytes + +// importProof restores lineage missing from tapd's exact-output proof archive. +func importProof(ctx context.Context, wallet *sdk.Wallet, raw []byte) error { + p, err := LastProof(raw) + if err != nil { + return err + } + key, err := sdk.ParsePubKey( + p.Asset.ScriptKey.PubKey.SerializeCompressed(), + ) + if err != nil { + return err + } + point := sdk.Outpoint{Txid: sdk.Hash(p.OutPoint().Hash), + Index: p.OutPoint().Index} + file, err := wallet.ExportProofFile(ctx, + sdk.AssetRefFromAssetID(sdk.AssetID(p.Asset.ID())), key, &point) + if err == nil && file != nil { + existing, err := LastProof(file.RawProofFile) + if err != nil { + return err + } + if existing.OutPoint() != p.OutPoint() || + existing.Asset.ID() != p.Asset.ID() || + existing.Asset.Amount != p.Asset.Amount || + !existing.Asset.ScriptKey.PubKey.IsEqual( + p.Asset.ScriptKey.PubKey, + ) { + + return swapkit.ErrInvalid + } + return nil + } + _, err = wallet.ImportProofFile(ctx, + &sdk.ProofFile{RawProofFile: raw}) + return err +} + +// declareOPTrue registers the exact public asset script tree with tapd. +func declareOPTrue(ctx context.Context, wallet *sdk.Wallet, + scriptKey sdk.PubKey, + witness [][]byte) error { + + if len(witness) != 2 || + !bytes.Equal(witness[0], []byte{txscript.OP_TRUE}) { + + return swapkit.ErrInvalid + } + control, err := txscript.ParseControlBlock(witness[1]) + if err != nil { + return err + } + internal, err := sdk.ParsePubKey( + control.InternalKey.SerializeCompressed(), + ) + if err != nil { + return err + } + _, err = wallet.Client(). + DeclareScriptKey(ctx, &sdk.DeclareScriptKeyRequest{ + ScriptKey: sdk.ScriptKey{PubKey: scriptKey, + KeyDesc: sdk.KeyDescriptor{ + RawKeyBytes: internal, + }, + TapTweak: control.RootHash(witness[0])}, + }) + return err +} + // SDKPoint converts a native SDK outpoint to the Bitcoin wire type. func SDKPoint(p sdk.Outpoint) wire.OutPoint { return wire.OutPoint{Hash: chainhash.Hash(p.Txid), Index: p.Index} diff --git a/swapkit/tapsdk/signing.go b/swapkit/tapsdk/signing.go new file mode 100644 index 000000000..0e1c90c53 --- /dev/null +++ b/swapkit/tapsdk/signing.go @@ -0,0 +1,8 @@ +package tapsdk + +import ( + "errors" +) + +// ErrSigningRequest means an SDK signing request failed its fixed binding. +var ErrSigningRequest = errors.New("invalid asset signing request") diff --git a/swapkit/tapsdk/signing_policy.go b/swapkit/tapsdk/signing_policy.go new file mode 100644 index 000000000..893bcf39d --- /dev/null +++ b/swapkit/tapsdk/signing_policy.go @@ -0,0 +1,63 @@ +package tapsdk + +import ( + "fmt" + + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/txscript" + sdk "github.com/lightninglabs/tap-sdk" +) + +// CheckSigningPolicy validates a native package and requires SIGHASH_DEFAULT +// for every caller-declared signing plan. Call it before creating a MuSig2 +// session or signing a caller-funded package. The native serialized package +// must also fit DecodePackage's recovery limit before signatures are exposed. +// Backend-managed wallet fee inputs retain the native wallet's signing policy. +func CheckSigningPolicy(pkg *sdk.CustomAnchorTransferPackage) error { + if pkg == nil { + return ErrSigningRequest + } + if err := pkg.Validate(); err != nil { + return err + } + // Finalized PSBTs may omit sighash metadata. The immutable committed + // PSBT is the source used by the SDK's signing requests. + packet, err := DecodePSBT(pkg.CommittedAnchorPsbt) + if err != nil { + return err + } + if err := checkSigningPlans(packet, pkg.SigningPlans); err != nil { + return err + } + raw, err := pkg.MarshalBinary() + if err != nil { + return err + } + if len(raw) > MaxPackageBytes { + return fmt.Errorf("%w: native package exceeds %d-byte recovery limit", + ErrSigningRequest, MaxPackageBytes) + } + return nil +} + +func checkSigningPlans(packet *psbt.Packet, + plans []sdk.CustomAnchorInputSigningPlan) error { + + if packet == nil || packet.UnsignedTx == nil || + len(packet.Inputs) != len(packet.UnsignedTx.TxIn) { + + return ErrSigningRequest + } + for _, plan := range plans { + if plan.InputIndex >= uint32(len(packet.Inputs)) { + return ErrSigningRequest + } + if packet.Inputs[plan.InputIndex].SighashType != + txscript.SigHashDefault { + + return fmt.Errorf("%w: input %d requires SIGHASH_DEFAULT", + ErrSigningRequest, plan.InputIndex) + } + } + return nil +} diff --git a/swapkit/tapsdk/signing_policy_test.go b/swapkit/tapsdk/signing_policy_test.go new file mode 100644 index 000000000..5fb2f61ff --- /dev/null +++ b/swapkit/tapsdk/signing_policy_test.go @@ -0,0 +1,25 @@ +package tapsdk + +import ( + "testing" + + "github.com/btcsuite/btcd/txscript" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +func withSigningHash(t *testing.T, pkg *sdk.CustomAnchorTransferPackage, + index uint32, hash txscript.SigHashType) *sdk.CustomAnchorTransferPackage { + + t.Helper() + pkg = pkg.Clone() + packet, err := DecodePSBT(pkg.CommittedAnchorPsbt) + require.NoError(t, err) + packet.Inputs[index].SighashType = hash + raw, err := EncodePSBT(packet) + require.NoError(t, err) + pkg.CommittedAnchorPsbt, pkg.AnchorPsbt = raw, raw + pkg, err = pkg.Seal() + require.NoError(t, err) + return pkg +} From 79e4171c89d1d292f9494bb6efa0daf21dc7489b Mon Sep 17 00:00:00 2001 From: Slyghtning Date: Tue, 3 Nov 2026 11:13:30 +0100 Subject: [PATCH 6/9] tapsdk: Bind signing to the approved package Check signing policy and the saved package before using LND, and accept peer witnesses only for the approved transaction. Preserve durable recovery while ephemeral signing sessions remain caller-owned. Separate contract-input signing from finalization so wallet-funded callers can sign fee inputs before sealing the final anchor transaction. --- staticaddr/script/signing.go | 62 +++ swapkit/tapsdk/approval_test.go | 25 ++ swapkit/tapsdk/bindings_test.go | 23 ++ .../tapsdk/native_package_regression_test.go | 128 ++++++ swapkit/tapsdk/package_decode_test.go | 54 +++ swapkit/tapsdk/proofs.go | 44 +++ swapkit/tapsdk/signing.go | 86 ++++ swapkit/tapsdk/signing_policy_test.go | 68 ++++ swapkit/tapsdk/signing_test.go | 366 ++++++++++++++++++ swapkit/tapsdk/spend_test.go | 28 ++ swapkit/tapsdk/testdata/musig.package | Bin 0 -> 14402 bytes swapkit/tapsdk/testdata/script.package | Bin 0 -> 14467 bytes 12 files changed, 884 insertions(+) create mode 100644 staticaddr/script/signing.go create mode 100644 swapkit/tapsdk/native_package_regression_test.go create mode 100644 swapkit/tapsdk/package_decode_test.go create mode 100644 swapkit/tapsdk/signing_test.go create mode 100644 swapkit/tapsdk/spend_test.go create mode 100644 swapkit/tapsdk/testdata/musig.package create mode 100644 swapkit/tapsdk/testdata/script.package diff --git a/staticaddr/script/signing.go b/staticaddr/script/signing.go new file mode 100644 index 000000000..47658ce47 --- /dev/null +++ b/staticaddr/script/signing.go @@ -0,0 +1,62 @@ +package script + +import ( + "bytes" + "context" + "errors" + "time" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/lightninglabs/lndclient" + "github.com/lightningnetwork/lnd/input" + "github.com/lightningnetwork/lnd/keychain" +) + +// CreateMuSig2Session starts a normal LND session for the complete Taproot +// root. Asset deposits include the asset commitment alongside the CSV leaf. +// The caller owns this ephemeral session and retires it after any ambiguity. +func CreateMuSig2Session(ctx context.Context, signer lndclient.SignerClient, + key keychain.KeyLocator, participants [][]byte, root []byte) ( + *input.MuSig2SessionInfo, error) { + + keys := make([]*btcec.PublicKey, len(participants)) + for i, raw := range participants { + var err error + keys[i], err = btcec.ParsePubKey(raw) + if err != nil { + return nil, err + } + } + expected, err := input.MuSig2CombineKeys(input.MuSig2Version100RC2, + keys, true, &input.MuSig2Tweaks{ + TaprootTweak: root, TaprootBIP0086Tweak: len(root) == 0, + }) + if err != nil { + return nil, err + } + session, err := signer.MuSig2CreateSession( + ctx, + input.MuSig2Version100RC2, + &key, + participants, + lndclient.MuSig2TaprootTweakOpt(root, len(root) == 0), + ) + if err != nil { + return nil, err + } + if session != nil && session.CombinedKey != nil && + bytes.Equal(schnorr.SerializePubKey(session.CombinedKey), + schnorr.SerializePubKey(expected.FinalKey)) { + + return session, nil + } + if session != nil { + cleanup, cancel := context.WithTimeout( + context.WithoutCancel(ctx), 5*time.Second, + ) + defer cancel() + _ = signer.MuSig2Cleanup(cleanup, session.SessionID) + } + return nil, errors.New("LND returned an unexpected MuSig2 output key") +} diff --git a/swapkit/tapsdk/approval_test.go b/swapkit/tapsdk/approval_test.go index 3a756badc..8919fd842 100644 --- a/swapkit/tapsdk/approval_test.go +++ b/swapkit/tapsdk/approval_test.go @@ -212,3 +212,28 @@ func TestFundedPackagePolicy(t *testing.T) { require.Error(t, CheckFundedPackage(changed, 2_000)) } } + +func TestBackendFeeSigningPolicy(t *testing.T) { + f := newPathFixture(t) + plan, err := f.wallet.NewCustomAnchorTxBuilder().Build( + t.Context(), f.request, + ) + require.NoError(t, err) + pkg, err := plan.Commit(t.Context()) + require.NoError(t, err) + packet, err := DecodePSBT(pkg.CommittedAnchorPsbt) + require.NoError(t, err) + fee := packet.UnsignedTx.TxIn[0].PreviousOutPoint + pkg.Funding.Mode = sdk.CustomAnchorFundingWalletFunded + pkg.Funding.MaxFeeSat = 2_000 + pkg.FundingLock.CustomLockID = bytes.Repeat([]byte{1}, 32) + pkg.BackendManagedInputIndices = []uint32{0} + pkg.LockedUTXOs = []sdk.CustomAnchorLockedUTXO{{ + Outpoint: sdk.Outpoint{Txid: sdk.Hash(fee.Hash), Index: fee.Index}, + }} + pkg.SigningPlans = pkg.SigningPlans[1:] + // The wallet owns its fee-input signatures; the explicit contract plan + // still uses SIGHASH_DEFAULT. + pkg = withSigningHash(t, pkg, 0, txscript.SigHashAll) + require.NoError(t, CheckFundedPackage(pkg, 2_000)) +} diff --git a/swapkit/tapsdk/bindings_test.go b/swapkit/tapsdk/bindings_test.go index ddf48d33a..79a7f31ef 100644 --- a/swapkit/tapsdk/bindings_test.go +++ b/swapkit/tapsdk/bindings_test.go @@ -1,6 +1,7 @@ package tapsdk import ( + "context" "testing" sdk "github.com/lightninglabs/tap-sdk" @@ -47,6 +48,28 @@ func TestDirectionNeutralProofBindings(t *testing.T) { } } +type unsupportedNode struct{ sdk.Client } + +func (*unsupportedNode) GetInfo(context.Context) (*sdk.Info, error) { + return &sdk.Info{Version: "0.8.7", Network: "regtest"}, nil +} + +func TestLiveFloorPreservesLocalRecovery(t *testing.T) { + wallet := sdk.NewWallet(&unsupportedNode{}, sdk.NetworkRegtest) + require.ErrorContains(t, CheckNodeVersion(t.Context(), wallet), "0.8.8") + // Native saved-package and witness decoding has no tapd-version gate. + _, final := nativeSignedFixture(t) + raw, err := final.MarshalBinary() + require.NoError(t, err) + recovered, err := DecodeFinalPackage(raw) + require.NoError(t, err) + require.Equal( + t, + final.CommittedPackageDigest, + recovered.CommittedPackageDigest, + ) +} + func TestApprovalChecksBitcoinOnlyFunding(t *testing.T) { f := newPathFixture(t) require.NoError( diff --git a/swapkit/tapsdk/native_package_regression_test.go b/swapkit/tapsdk/native_package_regression_test.go new file mode 100644 index 000000000..359322f49 --- /dev/null +++ b/swapkit/tapsdk/native_package_regression_test.go @@ -0,0 +1,128 @@ +package tapsdk + +import ( + "bytes" + "testing" + + "github.com/btcsuite/btcd/btcutil/psbt" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +// nativeSignedFixture completes the public package using the existing LND +// session fixture. Both packages retain the same committed transaction. +func nativeSignedFixture(t *testing.T) (*sdk.CustomAnchorTransferPackage, + *sdk.CustomAnchorTransferPackage) { + + t.Helper() + approved := signingPackage(t) + signed, err := signTestPackage( + t.Context(), + signingWallet(t, 2), + signingWallet(t, 3), + approved, + ) + require.NoError(t, err) + finalized, err := approved.WithFinalAnchorPSBT( + finishSigningFixture(t, signed), + ) + require.NoError(t, err) + return approved, finalized +} + +// TestNativeFinalPackageBindsApprovedPolicy checks the claim-acceptance helper +// used by VerifyClaim. A valid final witness and matching unsigned transaction +// do not authorize replacing the approved signing policy or package metadata. +func TestNativeFinalPackageBindsApprovedPolicy(t *testing.T) { + approved, finalized := nativeSignedFixture(t) + raw, err := finalized.MarshalBinary() + require.NoError(t, err) + bound, err := BindFinalPackage(approved, raw) + require.NoError(t, err) + require.Equal(t, finalized.PackageDigest, bound.PackageDigest) + require.Equal(t, approved.CommittedPackageDigest, + bound.CommittedPackageDigest) + require.NotEqual(t, approved.PackageDigest, bound.PackageDigest) + + for _, test := range []struct { + name string + change func(*sdk.CustomAnchorTransferPackage) + }{ + { + name: "publish metadata", + change: func(p *sdk.CustomAnchorTransferPackage) { + p.Publish.Label += " changed" + }, + }, + { + name: "signing session context", + change: func(p *sdk.CustomAnchorTransferPackage) { + for i := range p.SigningPlans { + plan := &p.SigningPlans[i] + if plan.MuSig2 != nil { + plan.MuSig2.SessionContext = []byte( + "another approved operation", + ) + } + } + }, + }, + } { + t.Run(test.name, func(t *testing.T) { + changed := finalized.Clone() + test.change(changed) + changed, err := changed.Seal() + require.NoError(t, err) + require.Equal(t, approved.UnsignedTxDigest, + changed.UnsignedTxDigest) + require.NotEqual(t, approved.CommittedPackageDigest, + changed.CommittedPackageDigest) + // The substitute is internally valid, including its final + // witnesses. Only binding to the approved policy rejects it. + _, err = changed.WithFinalAnchorPSBT(changed.AnchorPsbt) + require.NoError(t, err) + raw, err := changed.MarshalBinary() + require.NoError(t, err) + bound, err := BindFinalPackage(approved, raw) + require.Error(t, err) + require.Nil(t, bound) + }) + } +} + +// TestNativeClaimPackageRequiresFinalWitness prevents validated SDK package +// decoding from being mistaken for full witness validation at claim acceptance. +func TestNativeClaimPackageRequiresFinalWitness(t *testing.T) { + approved, finalized := nativeSignedFixture(t) + for _, name := range []string{"unsigned", "partial", "invalid witness"} { + t.Run(name, func(t *testing.T) { + proposed := approved.Clone() + switch name { + case "unsigned": + proposed.AnchorPsbt = proposed.CommittedAnchorPsbt + case "invalid witness": + proposed = finalized.Clone() + packet, err := DecodePSBT(proposed.AnchorPsbt) + require.NoError(t, err) + var witness bytes.Buffer + require.NoError(t, psbt.WriteTxWitness( + &witness, [][]byte{{1}}, + )) + packet.Inputs[0].FinalScriptWitness = witness.Bytes() + proposed.AnchorPsbt, err = EncodePSBT(packet) + require.NoError(t, err) + } + proposed, err := proposed.Seal() + require.NoError(t, err) + raw, err := proposed.MarshalBinary() + require.NoError(t, err) + var decoded sdk.CustomAnchorTransferPackage + require.NoError(t, decoded.UnmarshalBinary(raw)) + require.Equal(t, approved.CommittedPackageDigest, + decoded.CommittedPackageDigest) + bound, err := BindFinalPackage(approved, raw) + require.Error(t, err) + require.Nil(t, bound) + }) + } +} diff --git a/swapkit/tapsdk/package_decode_test.go b/swapkit/tapsdk/package_decode_test.go new file mode 100644 index 000000000..4169b4a78 --- /dev/null +++ b/swapkit/tapsdk/package_decode_test.go @@ -0,0 +1,54 @@ +package tapsdk + +import ( + "bytes" + "encoding/binary" + "encoding/json" + "testing" + + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +func TestDecodePackage(t *testing.T) { + approved, final := nativeSignedFixture(t) + for _, pkg := range []*sdk.CustomAnchorTransferPackage{approved, final} { + raw, err := pkg.MarshalBinary() + require.NoError(t, err) + decoded, err := DecodePackage(raw) + require.NoError(t, err) + require.Equal(t, pkg.PackageDigest, decoded.PackageDigest) + require.Equal(t, pkg.CommittedPackageDigest, + decoded.CommittedPackageDigest) + } + + changed := approved.Clone() + changed.Outputs[0].Amount++ + raw, err := approved.MarshalBinary() + require.NoError(t, err) + // Encode an inconsistent DTO without the SDK's validating marshaler. + type packageJSON sdk.CustomAnchorTransferPackage + // Preserve the existing SDK/contract JSON field names. + //nolint:musttag + payload, err := json.Marshal((*packageJSON)(changed)) + require.NoError(t, err) + headerSize := bytes.IndexByte(raw, '{') + require.Positive(t, headerSize) + raw = append(raw[:headerSize:headerSize], payload...) + binary.BigEndian.PutUint32(raw[headerSize-4:headerSize], + uint32(len(payload))) + decoded, err := DecodePackage(raw) + require.Error(t, err) + require.Nil(t, decoded) + + _, err = DecodePackage(raw[:len(raw)-1]) + require.Error(t, err) + _, err = DecodePackage(nil) + require.Error(t, err) +} + +func TestDecodePackageSizeLimit(t *testing.T) { + _, err := DecodePackage(make([]byte, MaxPackageBytes+1)) + require.ErrorIs(t, err, swapkit.ErrInvalid) +} diff --git a/swapkit/tapsdk/proofs.go b/swapkit/tapsdk/proofs.go index b1cb924bb..6522d3307 100644 --- a/swapkit/tapsdk/proofs.go +++ b/swapkit/tapsdk/proofs.go @@ -142,6 +142,50 @@ func EncodePSBT(p *psbt.Packet) ([]byte, error) { // files and PSBTs. The encoded package must fit before signing and on recovery. const MaxPackageBytes = 2 * assetpolicy.MaxProvenanceBytes +// DecodePackage bounds decoding and checks native integrity and signing policy. +func DecodePackage(raw []byte) (*sdk.CustomAnchorTransferPackage, error) { + if len(raw) > MaxPackageBytes { + return nil, swapkit.ErrInvalid + } + var pkg sdk.CustomAnchorTransferPackage + if err := pkg.UnmarshalBinary(raw); err != nil { + return nil, err + } + if err := CheckSigningPolicy(&pkg); err != nil { + return nil, err + } + return &pkg, nil +} + +// DecodeFinalPackage also verifies the complete Bitcoin witness. +func DecodeFinalPackage(raw []byte) (*sdk.CustomAnchorTransferPackage, error) { + pkg, err := DecodePackage(raw) + if err != nil { + return nil, err + } + return pkg.WithFinalAnchorPSBT(pkg.AnchorPsbt) +} + +// BindFinalPackage accepts only the approved transfer's finalized witness. +// The SDK committed digest binds transaction metadata and signing policy. +func BindFinalPackage(approved *sdk.CustomAnchorTransferPackage, + raw []byte) (*sdk.CustomAnchorTransferPackage, error) { + + if err := CheckSigningPolicy(approved); err != nil { + return nil, err + } + proposed, err := DecodePackage(raw) + if err != nil { + return nil, err + } + if proposed.CommittedPackageDigest != + approved.CommittedPackageDigest { + + return nil, swapkit.ErrInvalid + } + return approved.WithFinalAnchorPSBT(proposed.AnchorPsbt) +} + // importProof restores lineage missing from tapd's exact-output proof archive. func importProof(ctx context.Context, wallet *sdk.Wallet, raw []byte) error { p, err := LastProof(raw) diff --git a/swapkit/tapsdk/signing.go b/swapkit/tapsdk/signing.go index 0e1c90c53..e416f9352 100644 --- a/swapkit/tapsdk/signing.go +++ b/swapkit/tapsdk/signing.go @@ -1,8 +1,94 @@ package tapsdk import ( + "bytes" + "context" "errors" + + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/lndclient" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightningnetwork/lnd/input" + "github.com/lightningnetwork/lnd/keychain" ) // ErrSigningRequest means an SDK signing request failed its fixed binding. var ErrSigningRequest = errors.New("invalid asset signing request") + +// FinalizeScriptSpend uses the normal LND signer for a unilateral spend. +// The SDK checks the resulting complete witness against its sealed package. +func FinalizeScriptSpend(ctx context.Context, signer lndclient.SignerClient, + key keychain.KeyLocator, pkg *sdk.CustomAnchorTransferPackage, + preimage *[32]byte) (*sdk.CustomAnchorTransferPackage, error) { + + final, err := SignScriptSpend(ctx, signer, key, pkg, preimage) + if err != nil { + return nil, err + } + packet, err := DecodePSBT(final.AnchorPsbt) + if err != nil { + return nil, err + } + if err := psbt.MaybeFinalizeAll(packet); err != nil { + return nil, err + } + raw, err := EncodePSBT(packet) + if err != nil { + return nil, err + } + return pkg.WithFinalAnchorPSBT(raw) +} + +// SignScriptSpend signs the one bound contract input. A wallet-funded +// caller can then sign its fee inputs before sealing the final anchor PSBT. +func SignScriptSpend(ctx context.Context, signer lndclient.SignerClient, + key keychain.KeyLocator, pkg *sdk.CustomAnchorTransferPackage, + preimage *[32]byte) (*sdk.CustomAnchorTransferPackage, error) { + + if err := CheckSigningPolicy(pkg); err != nil { + return nil, err + } + requests, err := pkg.SigningRequests() + if err != nil || len(requests.ScriptPath) != 1 { + return nil, ErrSigningRequest + } + request := requests.ScriptPath[0] + packet, err := psbt.NewFromRawBytes( + bytes.NewReader(pkg.AnchorPsbt), + false, + ) + if err != nil { + return nil, err + } + previous := make([]*wire.TxOut, len(packet.Inputs)) + for i := range packet.Inputs { + previous[i] = packet.Inputs[i].WitnessUtxo + if previous[i] == nil { + return nil, ErrSigningRequest + } + } + signatures, err := signer.SignOutputRawKeyLocator(ctx, + packet.UnsignedTx, []*lndclient.SignDescriptor{{ + KeyDesc: keychain.KeyDescriptor{KeyLocator: key}, + SignMethod: input.TaprootScriptSpendSignMethod, + WitnessScript: request.LeafScript, + HashType: txscript.SigHashType( + request.SighashType, + ), + Output: previous[request.InputIndex], + InputIndex: int(request.InputIndex), + }}, previous) + if err != nil { + return nil, err + } + if len(signatures) != 1 { + return nil, ErrSigningRequest + } + unlock := [][]byte{signatures[0]} + if preimage != nil { + unlock = append([][]byte{preimage[:]}, unlock...) + } + return pkg.ApplyScriptPathWitness(request.ID, unlock) +} diff --git a/swapkit/tapsdk/signing_policy_test.go b/swapkit/tapsdk/signing_policy_test.go index 5fb2f61ff..bb851d0d5 100644 --- a/swapkit/tapsdk/signing_policy_test.go +++ b/swapkit/tapsdk/signing_policy_test.go @@ -1,13 +1,27 @@ package tapsdk import ( + "fmt" "testing" "github.com/btcsuite/btcd/txscript" sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightningnetwork/lnd/keychain" "github.com/stretchr/testify/require" ) +func signingPolicyPackage( + t *testing.T, file string, +) *sdk.CustomAnchorTransferPackage { + + t.Helper() + raw, err := signingFixtures.ReadFile("testdata/" + file + ".package") + require.NoError(t, err) + var pkg sdk.CustomAnchorTransferPackage + require.NoError(t, pkg.UnmarshalBinary(raw)) + return &pkg +} + func withSigningHash(t *testing.T, pkg *sdk.CustomAnchorTransferPackage, index uint32, hash txscript.SigHashType) *sdk.CustomAnchorTransferPackage { @@ -23,3 +37,57 @@ func withSigningHash(t *testing.T, pkg *sdk.CustomAnchorTransferPackage, require.NoError(t, err) return pkg } + +func TestPackageSigningPolicy(t *testing.T) { + require.ErrorIs(t, CheckSigningPolicy(nil), ErrSigningRequest) + for _, file := range []string{"musig", "script"} { + original := signingPolicyPackage(t, file) + for _, plan := range original.SigningPlans { + for _, hash := range []txscript.SigHashType{ + txscript.SigHashDefault, txscript.SigHashAll, + txscript.SigHashNone, txscript.SigHashSingle, + txscript.SigHashAll | txscript.SigHashAnyOneCanPay, + } { + name := fmt.Sprintf("%s/input%d/hash%d", file, + plan.InputIndex, hash) + t.Run(name, func(t *testing.T) { + pkg := withSigningHash(t, original, + plan.InputIndex, hash) + err := CheckSigningPolicy(pkg) + if hash == txscript.SigHashDefault { + require.NoError(t, err) + } else { + require.ErrorIs(t, err, ErrSigningRequest) + } + }) + } + } + } +} + +func TestScriptSigningChecksPolicyBeforeSigner(t *testing.T) { + pkg := signingPolicyPackage(t, "script") + var index uint32 + for _, plan := range pkg.SigningPlans { + if plan.ScriptPath != nil { + index = plan.InputIndex + break + } + } + pkg = withSigningHash(t, pkg, index, txscript.SigHashAll) + wallet := &scriptWallet{} + final, err := FinalizeScriptSpend(t.Context(), wallet, + keychain.KeyLocator{}, pkg, nil) + require.ErrorIs(t, err, ErrSigningRequest) + require.Nil(t, final) + require.Zero(t, wallet.calls) +} + +func TestCallerProvidedSigningPolicy(t *testing.T) { + pkg := signingPolicyPackage(t, "musig") + plan := &pkg.SigningPlans[0] + plan.KeyPath, plan.MuSig2, plan.ScriptPath = nil, nil, nil + plan.CallerSigned = &sdk.CustomAnchorCallerSignedPlan{} + pkg = withSigningHash(t, pkg, plan.InputIndex, txscript.SigHashAll) + require.ErrorIs(t, CheckSigningPolicy(pkg), ErrSigningRequest) +} diff --git a/swapkit/tapsdk/signing_test.go b/swapkit/tapsdk/signing_test.go new file mode 100644 index 000000000..08eab927e --- /dev/null +++ b/swapkit/tapsdk/signing_test.go @@ -0,0 +1,366 @@ +package tapsdk + +import ( + "bytes" + "context" + "embed" + "errors" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/btcec/v2/schnorr/musig2" + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/txscript" + "github.com/lightninglabs/lndclient" + "github.com/lightninglabs/loop/staticaddr/script" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightningnetwork/lnd/input" + "github.com/lightningnetwork/lnd/keychain" + "github.com/lightningnetwork/lnd/lnrpc/signrpc" + "github.com/stretchr/testify/require" +) + +// Public packages generated with the SDK builder and deterministic test keys. +// They contain no private keys or secret nonces. +// +//go:embed testdata/*.package +var signingFixtures embed.FS + +var errLostSigningReply = errors.New("signing reply lost") + +// sessionWallet uses LND's real session manager. It never imports or exports a +// private nonce; reconstructing this wallet discards all unfinished sessions. +type sessionWallet struct { + lndclient.SignerClient + + t *testing.T + manager *input.MusigSessionManager + loseSign, loseCombine bool + wrongKey bool +} + +func signingWallet(t *testing.T, value byte) *sessionWallet { + t.Helper() + key, _ := btcec.PrivKeyFromBytes([]byte{value}) + return &sessionWallet{t: t, manager: input.NewMusigSessionManager( + func(*keychain.KeyDescriptor) (*btcec.PrivateKey, error) { + return key, nil + })} +} + +func (w *sessionWallet) MuSig2CreateSession(_ context.Context, + version input.MuSig2Version, key *keychain.KeyLocator, + pubkeys [][]byte, opts ...lndclient.MuSig2SessionOpts) ( + *input.MuSig2SessionInfo, error) { + + request := &signrpc.MuSig2SessionRequest{} + for _, opt := range opts { + opt(request) + } + require.Empty(w.t, request.PregeneratedLocalNonce) + keys := make([]*btcec.PublicKey, len(pubkeys)) + for i, raw := range pubkeys { + var err error + keys[i], err = btcec.ParsePubKey(raw) + require.NoError(w.t, err) + } + session, err := w.manager.MuSig2CreateSession(version, *key, keys, + &input.MuSig2Tweaks{ + TaprootBIP0086Tweak: request.TaprootTweak.KeySpendOnly, + TaprootTweak: request.TaprootTweak.ScriptRoot, + }, nil, nil) + if err != nil { + return nil, err + } + // Match the signrpc/lndclient boundary, which returns an x-only key. + result := *session + result.CombinedKey, err = schnorr.ParsePubKey( + schnorr.SerializePubKey(session.CombinedKey), + ) + if w.wrongKey { + key, _ := btcec.PrivKeyFromBytes([]byte{4}) + result.CombinedKey = key.PubKey() + } + return &result, err +} + +func (w *sessionWallet) MuSig2RegisterNonces(_ context.Context, + id [32]byte, nonces [][66]byte) (bool, error) { + + return w.manager.MuSig2RegisterNonces(id, nonces) +} + +func (w *sessionWallet) MuSig2Sign(_ context.Context, + id [32]byte, digest [32]byte, cleanup bool) ([]byte, error) { + + partial, err := w.manager.MuSig2Sign(id, digest, cleanup) + if err != nil { + return nil, err + } + if w.loseSign { + return nil, errLostSigningReply + } + var raw bytes.Buffer + err = partial.Encode(&raw) + return raw.Bytes(), err +} + +func (w *sessionWallet) MuSig2CombineSig(_ context.Context, + id [32]byte, raw [][]byte) (bool, []byte, error) { + + partials := make([]*musig2.PartialSignature, len(raw)) + for i := range raw { + partials[i] = &musig2.PartialSignature{} + if err := partials[i].Decode(bytes.NewReader(raw[i])); err != nil { + return false, nil, err + } + } + signature, all, err := w.manager.MuSig2CombineSig(id, partials) + if err != nil { + return false, nil, err + } + if w.loseCombine { + return false, nil, errLostSigningReply + } + return all, signature.Serialize(), nil +} + +func (w *sessionWallet) MuSig2Cleanup(_ context.Context, + id [32]byte) error { + + return w.manager.MuSig2Cleanup(id) +} + +func signingPackage(t *testing.T) *sdk.CustomAnchorTransferPackage { + t.Helper() + raw, err := signingFixtures.ReadFile("testdata/musig.package") + require.NoError(t, err) + var pkg sdk.CustomAnchorTransferPackage + require.NoError(t, pkg.UnmarshalBinary(raw)) + // This SDK fixture has two independent inputs in addition to MuSig2. + // Complete those first so this test exercises the real full anchor. + requests, err := pkg.SigningRequests() + require.NoError(t, err) + key, _ := btcec.PrivKeyFromBytes([]byte{2}) + keyRequest := requests.KeyPath[0] + tweaked := txscript.TweakTaprootPrivKey( + *key, + keyRequest.TaprootMerkleRoot, + ) + sig, err := schnorr.Sign(tweaked, keyRequest.Sighash[:]) + require.NoError(t, err) + complete, err := pkg.ApplyKeyPathSignature( + keyRequest.ID, + sig.Serialize(), + ) + require.NoError(t, err) + return complete +} + +func TestLNDSessionXOnlyOutputKey(t *testing.T) { + for name, parity := range map[string]byte{testEven: 2, "odd": 3} { + t.Run(name, func(t *testing.T) { + pkg := signingPackage(t) + requests, err := pkg.SigningRequests() + require.NoError(t, err) + request := requests.MuSig2[0] + internal, err := schnorr.ParsePubKey( + request.InternalKey[:], + ) + require.NoError(t, err) + packet, err := DecodePSBT(pkg.CommittedAnchorPsbt) + require.NoError(t, err) + + // This fixture's MuSig2 input is an external Bitcoin input. + // Vary its root to exercise both output parities without + // changing the participants or asset transfer. + var root [32]byte + var output *btcec.PublicKey + for i := range 256 { + root[0] = byte(i) + output = txscript.ComputeTaprootOutputKey( + internal, root[:], + ) + if output.SerializeCompressed()[0] == parity { + break + } + } + require.Equal( + t, + parity, + output.SerializeCompressed()[0], + ) + input := &packet.Inputs[request.InputIndex] + input.TaprootMerkleRoot = root[:] + input.WitnessUtxo.PkScript, err = + txscript.PayToTaprootScript(output) + require.NoError(t, err) + raw, err := EncodePSBT(packet) + require.NoError(t, err) + pkg.CommittedAnchorPsbt, pkg.AnchorPsbt = raw, raw + pkg, err = pkg.Seal() + require.NoError(t, err) + + wallet := signingWallet(t, 2) + round, _, err := newTestSession( + t.Context(), + wallet, + pkg, + ) + require.NoError(t, err) + require.Equal(t, byte(2), + round.CombinedKey.SerializeCompressed()[0]) + require.NoError( + t, + wallet.MuSig2Cleanup( + t.Context(), + round.SessionID, + ), + ) + + wallet.wrongKey = true + _, _, err = newTestSession(t.Context(), wallet, pkg) + require.Error(t, err) + }) + } +} + +// newTestSession uses the same ordinary helper as Bitcoin/asset FSM actions. +func newTestSession(ctx context.Context, signer lndclient.SignerClient, + pkg *sdk.CustomAnchorTransferPackage) (*input.MuSig2SessionInfo, + sdk.CustomAnchorMuSig2SigningRequest, error) { + + requests, err := pkg.SigningRequests() + if err != nil || len(requests.MuSig2) != 1 { + return nil, sdk.CustomAnchorMuSig2SigningRequest{}, ErrSigningRequest + } + request := requests.MuSig2[0] + participants := make([][]byte, len(request.Participants)) + for i := range participants { + participants[i] = request.Participants[i][:] + } + session, err := script.CreateMuSig2Session( + ctx, + signer, + keychain.KeyLocator{}, + participants, + request.TaprootMerkleRoot, + ) + return session, request, err +} + +// signTestPackage supplies native LND signing fixtures, not a production +// session wrapper. Both session objects are discarded on any failed RPC. +func signTestPackage( + ctx context.Context, + client, server *sessionWallet, + pkg *sdk.CustomAnchorTransferPackage, +) (*sdk.CustomAnchorTransferPackage, error) { + + c, request, err := newTestSession(ctx, client, pkg) + if err != nil { + return nil, err + } + defer func() { _ = client.MuSig2Cleanup(ctx, c.SessionID) }() + s, _, err := newTestSession(ctx, server, pkg) + if err != nil { + return nil, err + } + defer func() { _ = server.MuSig2Cleanup(ctx, s.SessionID) }() + if _, err := server.MuSig2RegisterNonces(ctx, s.SessionID, [][66]byte{c.PublicNonce}); err != nil { + return nil, err + } + partial, err := server.MuSig2Sign( + ctx, + s.SessionID, + request.Sighash, + true, + ) + if err != nil { + return nil, err + } + if _, err := client.MuSig2RegisterNonces(ctx, c.SessionID, [][66]byte{s.PublicNonce}); err != nil { + return nil, err + } + if _, err := client.MuSig2Sign(ctx, c.SessionID, request.Sighash, false); err != nil { + return nil, err + } + all, signature, err := client.MuSig2CombineSig( + ctx, + c.SessionID, + [][]byte{partial}, + ) + if err != nil { + return nil, err + } + if !all { + return nil, ErrSigningRequest + } + return pkg.ApplyKeyPathSignature(request.ID, signature) +} + +func TestFreshLNDSessionAfterLostReplies(t *testing.T) { + pkg := signingPackage(t) + for _, failure := range []string{"server partial", "client partial", "combine"} { + t.Run(failure, func(t *testing.T) { + client, server := signingWallet( + t, + 2, + ), signingWallet( + t, + 3, + ) + server.loseSign = failure == "server partial" + client.loseSign = failure == "client partial" + client.loseCombine = failure == "combine" + _, err := signTestPackage( + t.Context(), + client, + server, + pkg, + ) + require.ErrorIs(t, err, errLostSigningReply) + // Recreated normal LND session managers generate fresh secret nonces; + // the persisted unsigned SDK package still fixes the authorization. + signed, err := signTestPackage( + t.Context(), + signingWallet(t, 2), + signingWallet(t, 3), + pkg, + ) + require.NoError(t, err) + require.NoError( + t, + pkg.VerifyFinalAnchorPSBT( + finishSigningFixture(t, signed), + ), + ) + }) + } +} + +// finishSigningFixture finalizes all inputs together. The remaining unrelated +// script input is OP_TRUE; the caller, rather than the signer, owns witnesses. +func finishSigningFixture(t *testing.T, + pkg *sdk.CustomAnchorTransferPackage) []byte { + + t.Helper() + requests, err := pkg.SigningRequests() + require.NoError(t, err) + request := requests.ScriptPath[0] + packet, err := psbt.NewFromRawBytes( + bytes.NewReader(pkg.AnchorPsbt), + false, + ) + require.NoError(t, err) + var witness bytes.Buffer + require.NoError(t, psbt.WriteTxWitness(&witness, [][]byte{ + request.LeafScript, request.ControlBlock, + })) + packet.Inputs[request.InputIndex].FinalScriptWitness = witness.Bytes() + require.NoError(t, psbt.MaybeFinalizeAll(packet)) + var raw bytes.Buffer + require.NoError(t, packet.Serialize(&raw)) + return raw.Bytes() +} diff --git a/swapkit/tapsdk/spend_test.go b/swapkit/tapsdk/spend_test.go new file mode 100644 index 000000000..6c2d679ad --- /dev/null +++ b/swapkit/tapsdk/spend_test.go @@ -0,0 +1,28 @@ +package tapsdk + +import ( + "context" + + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/lndclient" +) + +type scriptWallet struct { + lndclient.SignerClient + + signature []byte + failure error + calls int +} + +func (w *scriptWallet) SignOutputRawKeyLocator(context.Context, *wire.MsgTx, + []*lndclient.SignDescriptor, []*wire.TxOut) ([][]byte, error) { + + w.calls++ + if w.failure != nil { + err := w.failure + w.failure = nil + return nil, err + } + return [][]byte{w.signature}, nil +} diff --git a/swapkit/tapsdk/testdata/musig.package b/swapkit/tapsdk/testdata/musig.package new file mode 100644 index 0000000000000000000000000000000000000000..2cea2383f2197e8e98f7f82524cb654904b4f110 GIT binary patch literal 14402 zcmeHOX_KQ!lAZl4`Bj?b5(3(6K5z>iNCx=Q~UYqmsON!Pd^dEry{Yl=g52d z>7UeiNRY&kA&10>7?PtQ%M1w${!jrs9MMCPV28w*8WId#j)x=#)kwI6-^2)q-{_iz zYS4&7tthyLdoof2@8j>9JOAiSansV&FhEHyurcqt{-g9BQu^sr&UKIFM4MGtt zKBTE34lT$b^hdBD0?iF+W=KId&=uJWOATQVf*C;t=ozPm?0CqMLo@<0q}hI4f`qo* z5DNN9Kyw!U;3hFJ`qP8w0WlZmZYQLLccBvqIU zHil1djwL9DI^MRE`(Z!vm*(hxUCsQmfo(I{mp!+DBr4B?%i-X#Zij#jjru%UiGHH9PJ+r|snmV2x z{js6vVt`~DWg;K%ebvG9$Y$pv-qhiIP-NNYpjPK%J1v_l+jJ76w!FZb*PL%(MiZxN zP2O)V8EZy^?K%p5)?DJ!&S|!5-W)Sn;}2$5G&crV%G9bB?ge_fa#&Z^gOz@m#IYQ= z)kau!l}z)?(PSrktIOsxILr6-Lfp8p3^yr`xog)NB+n9oZyKg0c7}XcTPx<7z&ot* zL1C8Tg{8|a=x!D|nsK6HXL<>j-oX*i%Z{x>O=K)wNMur)8q)nh1@)1DSqOs3UwMBY z?iV>Rv9Wt74Jhf}Ud8b03I6UHX+`GC%zb3!7v4}>O{8{axGRG(mw74KmDJ+s?^pGn zHl$#+xXX!jx#7}srPB$&mxH-?oGErAm83^Hj(T;wgmwqSDdCqqdtaEFWjQw%BbG`x zAkIJj@ict;>w*01f&A-%{4+g}ZXI3y=WA5fjh*zCvH}eAZY!0M*q?|W?8nOq`MIy% zdqZSfx}>Y|8=v3C7IBzP4SjkljQhoD(oo-~D`SVnWt0ynO|BmO@8MiFlup>MLw7R8 z`Mn0$d?W-@`kEdG1MkL^$}Tt*`(@Zx6TY~zFDoK<56*FIPzGNY6M1@E`O37| z`*WL5X2vKkNpdk0s3f1qV%_N{@&q_4gme7?K9FKIx!^`%2ZbHqUQ$l4V{X|^jalN^ zLSc9FlW|lUY^=vxrNHv-9UbHMi}&_mgFI0dyI_qa@}xfP@OHfsn#2`YQt7C3+$@;; zExU}{X|wIxtl0>j$?w!4#1}TrW?N@86)<^O9|m}7pK3?2B=V@%n@KjFv!hL*jCfw5 zIb^$ysSW$$D<45tmAgxB@%di3IV6|Dcj&2~2Y0W739zSxK#4^%7LKiwyq5pL-%Hr+ zybSs$W7kMxZnQ}gZ&c^vrjR1@>Kxj9;_rgSm{Br;9kIP-%7TBTLOxjw8wD1xpMWe* z(KGXvkFoyRN^OPSae{&u&PQ=B9IWk@ zyq_LeQG;=3f9=74tNQC)`=o{ysW`< z0-n|U{36F=XdX1LdgqjfcKgP7Ri#cea& zD{?;88u{vVVOpN%7kyh)v2>-SSQv=%-1WxH&8NKCbUVKfcC%ce=yH1KPJ&Ci7{PG< zA{c~hFX^w@V;60yy$pLpxqYzw0@$mNk63~B758@DcqO)!SB$$_iR?_}aD}!9T9kSt z>$(cX2>j%|!!29r%aFz0`?>LNH~$ZXYaw(gJ@G`MbyMzojEMHIU*|v6`^^Fa&aZ=T zR>Z=LKov}vPtU^JD3ib=6-sg_DqYE$H-oV!1 zTy-&?-?$h3(}}MtwX1gE&tAFG*lvui06V=mBmy59cD-w7Wa^9^&K1OSyxt@c&Pn53 zSnO5(T+~gpm#8=x93QqoMxO5f-6v__(0Tg^)n9R}*Ep64&$oERh2@_G3yyK&0$A`X zxCSlk7wpzoaGhiX3U7)PUL097-!QzY40wJ%tJEW2>o+`?uXR>6RUj=Ac9pbUc+%?G zoWsLxMhaHZD0fz*?6FOq@1u++_K96M*N}5uzV{Ce&6ulum9jMPJTF$;AWnEZ86?uO zXvVfo><*mZ49sSBX57GR?;KxLZ}?I(v@gV|Rve#>eiu7$^>%(b10Tb16+fJLPOdMk zc+So`=Vam1RlS(Dfq4rtu4i31U$Xo82MqdYaKNw=x|PM~d>1m^*cw81DE6t+>eH8`iYtxv1%+GZJG zy|Hf3;#oW~5-G^!R6naqR3{6C1b@E(oCL4KNVuv%%-s}+LR_jHIj|@=<^TdXf zE8~NiXum^;ihi|!`9SH zX<}_{skCHvJ`LoUziEQDiX}qCP8-b2G<>$4WM+J<=gyMZELKdSp9S8>RJ<+Z^I8f3 zJPLfspK~I=7#G76H%rkq59Es132|^b``dfBZOn43Qq+C4-fdle-+n}#!pZ1S=*xCd z2EL(XZ~f*u+aB*5Wy2rYi$PW6V??Wm2)|G(JvCPgIn)-OzRj2Q!fLCOHw{S(lCjmrZ!rv*^moaU|7czV^f#kaLDq!iwdz2@ToDHcGL5L<*Ch_ z9_aLbrR?Zgy>U*bRj3@dE&tRrV^#I<0&R${3hfN|!@Q}Brhbkx&+ndo`aAHPN$$o# z>NRzjLrgAfl4SUFYBDd%f@gH^>8Ec`Zd28H+F$mR=%W_8`|Ni`RN6JLrq7k{=9veb z;6J~0fm)}z=Rf^K0dYs#-w8lMu-@%sf+yd9u52LC@ZnQxchB$F&{>p$&?sW~4a5y1 z7h;HgQ7_DsT~&Vl_r3sv|KC-3OcXjrtfBul^Y?->Pe3|Q#A|f&rRTSXFKogO#c0&$ z(mw&`SKCENTrQXEY1Gy>Ri29O+StvN>N-3~u5=RI7`CHEH`2RZMkNzh&9zIpdzI3c zv*%W41_Y0)s)4cm2kA_3Ksyq^Kq3|r2ucPRNT7%b#GulMkpzkrh|KoTpsGnp123rEr>cAo+*16|( z8R!MLXBd*e=^=+WT%<{udS8ZUb|?Tsyl37~BMu}%d^rrrA@O@fBT5~#0_y5j2FyB| z69eoz62?yR2B`y)!cRq+=cnf?Z%P-m_U$Q#r>oyl@Ho_d273-=5ugP`Qug@(AR}}| zKp6>yKM9ILsRD=xN6X%)1U$rryGSNrozaRTf*Z95j+=lPfwDlku(D7LISGg=hhKdU zFc1TBI!W%p{@lunv3?wB0%puZbPYZP7TKsTDUXHup{t^U;+kNr#6(48n1!Rw=HHV`5B4LteJKf?j>zyrTDt*;mXPOTT)`Y8EeTwkla z8Ocvu*B@GbFfs4I1kCZn68*omuV9qmIEN!2j44hGAxjCYK7p)06oTzQHiHB+KqE^D z#+Cwe0Ea$GZbD{cjI0f`MkXI+qCqYci7Xqc3Vrox02w1>Yai)OG)k>{F|x$ZZ>Ilh zC(R2oV_?`G>g0L-{IWdo6Kq?b0ypZ7Dl$Cqhw{N7v#Za)>aoGA#e*`iqeu)$itB%Z zy+=7_kO~HJqTDMmy(ozcCWOo*2n!Gh89)SPprlVFBS2V$x{xTTU&e|5jDG)NvU~?g zkWx{iA3z$Uc9f!r%r;CAO$5{hMjB-Yq9i`32Gb?MdXFJ>4R8=FDZ)Vrrh&%c7l1hu za2Dj}p>#WhOklN9IvmOrgueT%xL-h$7jfQ^cMnlKKLPKc1l08Hsr22bh+fgj6Fl24 z0GP-xpKZ@8{R)l*$oNCmE59tphNGjfFR(RIzqUQQwjaI&Y@ED! zu1mCM3LoJhfb6~v@TkXZ(CNnLb9DN`_k2rG76_2lfX1Hzv>>rta+JuJ-0AioE z2*v1$f@LCLaS$@a(YnHuhSn1$Huk6tz9C~0r92`;3vd=K%wxG>KO?9OP!uJHzTh~L zWdGG4zYplx6re!=uS59va&rCz59=dk6dA+s{Hj0v+<$Dz501k}N8zi1=KsJ^_;tMb z%e&t>3eM!=C@j9>Z1g>%gj?gk!dZ&fsEl6yqzSY?R}=N$tycDu)1a0d7C?w zu?JKi&5l&KglO|@7RVB2OdEa^_v@^EAz@1pzvke43?6SL!ag^%-B_|@TExU^N8udL zbeA}dSCqvUbF(^__p5Tl-=Bd`J5vKp7`Oueg+Ob^E0Dkq&q5@LV?UF8-D@Dpn2zY< z!64Uix-G~O8_C$fxKA*?80jP5Hr7D8Or*=fZO+2(;AqrM--TJiu5C`T$Ewa`NY|c)a=FY6wm`>bZ zGc1wbKJSG8t_06Z(hM)uG#|Nd!S~M-W!*}=9fT>rhcwoW;l^w5MQ4#Gm;s}NkX7sUL!#=Y|v+7&GLKl^vYz{Q1^vtT5&*f0xlbsjHd!Av0( zfF=hHZ0`euoV`CwAzukO#*fGZa&Td9pm+u70KK0D%T4#x0Q3j%Uy%gN4uaaf-{c@N zC-a_DJA=34yjL~|SSuI#Q4fBqXq+TMGQy^eqvH7`(gd%sIc08pu8m%#L#`^2Mz-T8 YppggB_4h|j@Du&+#ZUaM#m_(g4-SMzBLDyZ literal 0 HcmV?d00001 diff --git a/swapkit/tapsdk/testdata/script.package b/swapkit/tapsdk/testdata/script.package new file mode 100644 index 0000000000000000000000000000000000000000..4f9b0141354b2b843e25f76a17f242d9e5dac55c GIT binary patch literal 14467 zcmeHOX_Ko~lI{5`^;PO&7vPBgz$zgLBqX$UbX2ej5UW@O(hL9h$%|_9v%{|HiMBm4 z){A<;P21WgP{ddRUuf`UJkzzu0;ND|zT7*Rulg~!p5q#zp!k8n@WINYOW60$)d z9+jft8QwAQuFucHl^&8j)XNMB4vO;JzlKk4o~BV<``&Y5yRjYk&t4SxRSiNBBPat^ zGEm(Js=}!uM?j582zJN~p&1e$NDz=yAp}>e6f}p4df(6O=Av6fj)DSYG z`dAur_I*RulQa&ZG+7k|8Awuh??R9?l9(Pse+d{R7#ardMm$J{57E03Ii#RM5EKcB zghT!7yAD@qj%9{Wo}lm{^nrjscn8wJ==Ot1p&o#U@B+q+Wk8Uhj|7Y^>KI8we{d*B zz&*}E_tC__2;&5rBOX%v!G#nwc`yRpXo%{EMu{Qb&o77%67>@>f?9cI$imQo6StSuJTOuDPrBd@^ykoJPG^2K>5L>UJI8nXHV{tOrm_ETf zmZ+NJ(YBr35BrI~Skw3Ga^{z%kTUy;{(94m2KZA87R z6h>Iklbzx%FPqEYtlU@nS%hoI2obq(aik3;J9McRFadp?vzbR z9j5Fi$1#8HT9XtwBJkJd+LAg`xsO{b7TCZ$tnfjxE=Rg$C@qZhtXeht=y1_0-X{kSHKj@{GllOC%-Frc#v$~|K@tcs}Miz0HPEBKaD$M)E zY0}Wxrb}~&#buNaC{3vz_3z=lH`PwuuR?b+#f7~F&q5>yQ|6i;2LtcMmg+7z6#GTk zRuiGPa^#I#%#7s7<*K7zgMBJKfWQEBav&%#YWvZxmrjIgmJW^?%TV*C+S+22xTA^G zx>AbWow-Zr(9I1BHIc{|Je#;j*nm zPen{w)Q16H+NatPEtx!y>&+w^%{h7#sI(xc4Bw(PGPPk{eB~!9WA*NmTYSD3Zw|?) za1Fij=RxCZVv#@O1%;T~J{B$=EfMn5Q>s;?Z?3Z3;PBU!6mn zPyAibm@`Ttup_p&){5v~sZdB(;zotZ>pP%GQ?zHk@-tUon+d3UTy86=F494Y?FBPu zl#Vb>S-6|^IgjWy zPmRZR%{4i(OK;`^i^u(x%8by0u7thSpNt=Oo}j3j^!fTU)4fJKV~hhgh>0Cu+%~hl zs^lZBQLbJWrsZjVF}6h&%U4E@#et;EU2nwRe9D_mxAXg8H_KIuDW`|-B)X)F5iIZP z!64*%Nqm7ru_975$$2W%73lMFTXS4{5pt7 zp{WJC68|*V0oO!R2})zOJ1G}+(Td?I5Tsivrrz9g>zO!bkLHv-{$KG z^R(lw4mKkvbTOeOo3y66!F1qlncZc_(x)8-#^;MJ`vQIxeG}$;pF7@;DZF%h16_Y} z$NFe~<6p*~N&K-|yWOr4R#yP|ZCSDPfld3ltJ z`hIMji@J&SG8G4d<3krH$SVHN{gMU_owuJ@{pBBf^^ZxgzojcKF8(Z7aDtr)fg|$@S#gSX*8&(*r13{S2s__x8jT@dT*E*}3DvYbA)dt_7RJDoAaKCuhu8uE@S^!A~tne*{}Oj(+Ao)^n)5GMkj3=(-! zG$UIfb_ZT`2J2>aX5C=j-g%*@-teVnYG3eaEqNiOe-}M(^?H6f0~^D1RX?10PHyN{ zJm+SebFy&xI=-xJ6Z3Q_u4i31UvT^R2MqdYaKLgCrd6cqd>1pr+?rx`D`fu;4$Sx% z&DW*Nkw=Yd*I+*5#4Z@&cLj7AI;JE|pBE$7pb3(hsZKgil2AS>>*Fr7uUKGVjI5tH zDGR8ODMSTSjk_qq+elZBVRb%fggy56om%2XnICLAAa5sPusVZVT6bPOtgtFSk8@7# zbcw7EAx3Sjq^=AJadE*&jbG|%e!?u=n$`(j$_ZL=DS zh+Wp|groNQ`opj-Kid@^6Jo$HrY51bI%Pg?CL3i`Vuv%%-RuzKmn%KRX;U&lJ#iuB zD)?X~+3(Qd`02I=m>N75>6nTE%f9a4*=(tgT|(Rn zd17sCxwI5+J`I#uxM`xcjAcT?P8-b2G<>$0Wb61?&z%Lk(U)vuoJGOM#&}yO=an1) zcoc~HVgwpo|kF-6_!)o$ww`}QN^6i;T4LSL4P zI`B;`d#g9kx%PP9s2kzPT}-MP9V2FZi0})wG}84_S3*tqjBUQCb*rsXVQtD4$GmZd28H+CTOz>mwI>`|Ni`RN6HVvCoz7=9veT z;6J`qfl8;j=Rf^G0UJo#-w8m1W8dw4f+yd9u52LY@ZnQxchB$7P+63L(8y!>4a5y1 z7kr3)QZLMtT~&Vl_dWrLg6}dsItrB{D$;-J`Flc{CmN-3~u1pf#Sgxb!8|mFHbjik5bL~?8UZu?C z?77vM1;L}LYM?Fu!DACVP_)4El0e0hK-aQ3u&Tg*B3hO~tTphqKz{cBlR(>&zm*;zO7#|IR2Sqe7i8y4$vqE_s@<7#y3`Q(BdO2hec{}9DAqN>a#Gund;F*yq zNKkkSR4)TmG%62rAeI*;0vilGG_d$6GfshI+RKE%a;V%gD(dIhzrm7#Mxk+_#t|V6 z&9hJo5Zcfrfdi2YqX(j*EFc4J4f06*J`*t5XpCUE`XK{8 z9`y;>dI||+r+I^h1Du(#vdTO^Jy&^Cx-e?ro?_Tt{fdI^Q2QCIITVex?>bOp%x4?zb5M%ar<+HKju=P4`X3x&TUi8gx!DE0{qzUuiwAw^|`(3q@6{DYkNyYWH4RFi|LH7 z&r;wqw!{dfYwh`r_YBRvonCBTh@kkA-yYm(>a?GSNLC2*%-KBf;sznY>BlR#CHI;i~tgR8t-5)ct?y?;*VM*qMZ$PnLNs} z&81cgD=F#oEsPm$%~D6HU>HI$=xR2Q!1)cF`j0=t0r9{CKUJ--7y(YL7v1_u`Jh~1 zv%D$EPixnomHeP$-hm0I7ArMIsG>)D#3Zp};B71E2;_ z+!O)=6sQ9@^dYpWS0f{&ZJ;z#`6#%JMLH1PqpVO@j|Px3Lb?`Zf$CAb){BxQetc8? zS37B5kQocj_E0C!>*ts0fm_gReN-LYD^;X;;130vq2Me)FGy4My1mzUkcL9O;DRE- z&@JeDQ1>Xl4Dy0tB&c2#nFbv~>Jfy6N{|9XUXb=+yR(F zF>*ZQf;c^dOklQAj2()7gSz`ryPrUk7jfQ^cMnlKKLP8Y1l08Hsr22bh+fgj6YOml z08HeU&$j24eg#JYgb||bm0uR_4;a?Nod5PaJ1qb)!_iUL7g!ppU)!Et+Yj3T7EWF~ z*Ckprg^zF$Kz82-c+_JysB~lY@jQLvdk7~C76_2lfX1Hzv>>zNsr`c2zg}|en!1%h zL2fS8ZEGL6O(hffK1{c(5l8Wc<#J2vGP5)kO$1ohFEcPBUNI!v2>s@Q(S*$f0I`pS zgk-d%V46?>CPJn-npfCqXg*Q2WRJ?=%AuVJFVU6+7zY!BmTkZP5Yz@Jih>wla2!c; z|LTw52Xt%-7(oB8L-_YHa{dIH^%07Sl;L-F)gONDKbGVN!{MW$@Ks0izhNl+I^O*0 z+wTkoXYw!<^sg8jeT^uPSG&ABx_;Ws&!3csZwm$TuHJ$~f1d68lm{ocq`+gx$(r@3 z1Tu*mGkyyQMgdHCSlq>YdAm8&yyF%-noWqtyC1U(m?q3Cn9ypveY|n-kA}`_CB)2q z*4s|K(ZUNB1UUUgBK|x8>CZ(X>X1pBXFi%F!lPw;VTbbB8kb zfa;^!kqQ^!ZJx~nMaIl&BW&V+p0zIoY>Cp>44jY7 zB~IfdWeLT6T^-ih45XsWW&t%{58VE>cBIbB7 z$(53B3$ny$1sj<62__V@LHoA30@7t7Uk+|_7Iz0nqi)77%o1*8^Rhh}j~mUXGX4}F zsA_*6Kj{BQcRuTK$0$yECwL}`S=qE_T9+#yEv@_XGQn_Oxj9xSXt*lKw~5zU7M)Mu zKPnL8Pq)Q#Q$+B5-f8^5Ab8fUQ5=jY-j$)8V&i*YuN|yrayZ+#oSQVwon5UkgSfv& zSfX+Jyb=Dp5$8=Ho3GB3FOW-*VEBiQ{ypG4@)4kKi4YrrKC*g%)bD-afTH1} zr#eJvzyI>61VaqjK*+NSh!||U(ZkZ~4N$O(PzsOWFad~~Kwlpra|z5)5c0 zT0vfOJ&&$BFT}Rk0gd1Fly)ntiJzf1d)@yH)KF+f`=(D{Yw*-Knp!) z6V3V`GM^7C$wAaj<~^r&2A|b=uiOuCR4%fb9&A+6I7x(t4VGXW70)kzCHMl)DRbL% kZS*A`GE9LYvK>DG1M@*^{r!;>tU|wgu?oK{@#ByG0~f4WHvj+t literal 0 HcmV?d00001 From 9e4c1e6c85fc51a079bc4429d738c059e40c342d Mon Sep 17 00:00:00 2001 From: Slyghtning Date: Tue, 3 Nov 2026 11:13:38 +0100 Subject: [PATCH 7/9] tapsdk: Verify presigned descendants through confirmation Bind native compact paths to approved signed parents. After parents confirm, replace proof metadata with authenticated histories without altering the transaction or final witnesses. --- swapkit/tapsdk/confirmation_handoff.go | 388 +++++++++++++++++ swapkit/tapsdk/confirmation_handoff_test.go | 182 ++++++++ swapkit/tapsdk/paths.go | 441 ++++++++++++++++++++ swapkit/tapsdk/paths_test.go | 125 +++++- 4 files changed, 1130 insertions(+), 6 deletions(-) create mode 100644 swapkit/tapsdk/confirmation_handoff.go create mode 100644 swapkit/tapsdk/confirmation_handoff_test.go create mode 100644 swapkit/tapsdk/paths.go diff --git a/swapkit/tapsdk/confirmation_handoff.go b/swapkit/tapsdk/confirmation_handoff.go new file mode 100644 index 000000000..929618f75 --- /dev/null +++ b/swapkit/tapsdk/confirmation_handoff.go @@ -0,0 +1,388 @@ +package tapsdk + +import ( + "bytes" + "context" + "crypto/sha256" + "fmt" + "reflect" + + "github.com/btcsuite/btcd/btcutil/psbt" + assetpolicy "github.com/lightninglabs/loop/internal/assetpolicy" + "github.com/lightninglabs/loop/internal/assetproof" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/tappsbt" +) + +// ConfirmPackageInputs replaces a pre-signed child's compact input histories +// with verified confirmed histories. The saved digest identifies independently +// approved package terms. The package must also carry complete, valid Bitcoin +// witnesses, which are checked separately by the native SDK. Only proof +// metadata changes: Bitcoin signatures, asset state, allocations, commitments, +// fees and signing policy remain unchanged. Confirmation evidence is checked +// against both the current chain and the authenticated SDK proof verifier. +// +// The returned native package has a new CommittedPackageDigest because its +// proof histories changed. Persist the association with savedDigest and the +// updated package before publishing. The FSM must import each returned native +// ProofFile through wallet.ImportProofFile before PublishCustomAnchorTransfer; +// tapd's proof archive needs those histories to construct successor proofs. +// Import and publication retry/ambiguity remain owned by the caller. The chain +// must also implement PrevoutSource for authenticated Bitcoin funding outputs. +func ConfirmPackageInputs(ctx context.Context, wallet *sdk.Wallet, chain Chain, + minConfs uint32, approved *sdk.CustomAnchorTransferPackage, + savedDigest sdk.Hash, confirmations map[sdk.Hash]sdk.AnchorConfirmation, + bindings []InputBinding) (*sdk.CustomAnchorTransferPackage, + []*sdk.ProofFile, error) { + + if approved == nil || savedDigest == (sdk.Hash{}) || + approved.CommittedPackageDigest != savedDigest { + + return nil, nil, fmt.Errorf( + "child differs from saved committed digest", + ) + } + if err := CheckSigningPolicy(approved); err != nil { + return nil, nil, err + } + original, err := approved.WithFinalAnchorPSBT(approved.AnchorPsbt) + if err != nil { + return nil, nil, fmt.Errorf( + "child Bitcoin authorization: %w", err, + ) + } + if minConfs == 0 { + return nil, nil, fmt.Errorf("confirmation policy is required") + } + if chain == nil { + return nil, nil, fmt.Errorf("current chain backend is required") + } + if len(bindings) != len(original.Inputs) { + return nil, nil, fmt.Errorf( + "every asset input needs its agreed binding", + ) + } + byID := make(map[string]InputBinding, len(bindings)) + for _, binding := range bindings { + if binding.ID == "" { + return nil, nil, fmt.Errorf( + "asset input binding ID is required", + ) + } + if _, exists := byID[binding.ID]; exists { + return nil, nil, fmt.Errorf( + "duplicate asset input binding", + ) + } + byID[binding.ID] = binding.clone() + } + confirmations, err = cloneConfirmations(confirmations) + if err != nil { + return nil, nil, err + } + if err := CheckNodeVersion(ctx, wallet); err != nil { + return nil, nil, err + } + anchor, err := DecodePSBT(original.CommittedAnchorPsbt) + if err != nil { + return nil, nil, err + } + updated := original.Clone() + proofs := make([]*proof.Proof, len(original.Inputs)) + raws := make([][]byte, len(original.Inputs)) + var totalBytes uint64 + for idx, input := range original.Inputs { + binding, ok := byID[input.LogicalInputID] + if !ok { + return nil, nil, fmt.Errorf( + "asset input binding is missing", + ) + } + delete(byID, input.LogicalInputID) + raw, source, err := confirmInputSource(input.ProofSource, + confirmations) + if err != nil { + return nil, nil, err + } + size := uint64(len(raw)) + if size > assetpolicy.MaxProvenanceBytes-totalBytes { + return nil, nil, fmt.Errorf( + "confirmed histories exceed size budget", + ) + } + totalBytes += size + err = checkProvenance(ctx, wallet, raw) + if err != nil { + return nil, nil, err + } + p, err := LastProof(raw) + if err != nil { + return nil, nil, err + } + if err := binding.validate(p); err != nil { + return nil, nil, err + } + if err := checkPathSigning(binding, anchor, + original.SigningPlans); err != nil { + return nil, nil, err + } + if err := replaceInputProof(updated, input, p); err != nil { + return nil, nil, err + } + updated.Inputs[idx].ProofSource = source + proofs[idx], raws[idx] = p, raw + } + if err := assetproof.VerifyCompleteAnchors(proofs); err != nil { + return nil, nil, err + } + if err := checkConfirmedPackageCurrent(ctx, wallet, chain, minConfs, proofs, anchor); err != nil { + return nil, nil, err + } + // Verification reuse is scoped to this operation and exact history + // bytes. Every binding and current outpoint is checked independently. + verified := make(map[[32]byte]bool) + var files []*sdk.ProofFile + for idx, p := range proofs { + if err := checkConfirmation(ctx, chain, + minConfs, p, true); err != nil { + return nil, nil, err + } + digest := sha256.Sum256(raws[idx]) + if !verified[digest] { + result, err := wallet.Client().VerifyProof(ctx, + bytes.Clone(raws[idx])) + if err != nil { + return nil, nil, err + } + if err := checkVerifiedSummary(result, p); err != nil { + return nil, nil, err + } + verified[digest] = true + genesis := p.Asset.Genesis.FirstPrevOut + files = append(files, &sdk.ProofFile{ + RawProofFile: bytes.Clone(raws[idx]), + GenesisPoint: sdk.Outpoint{ + Txid: sdk.Hash(genesis.Hash), + Index: genesis.Index, + }, + }) + } + if err := checkConfirmation(ctx, chain, + minConfs, p, true); err != nil { + return nil, nil, err + } + } + if err := checkConfirmedPackageCurrent(ctx, wallet, chain, minConfs, proofs, anchor); err != nil { + return nil, nil, err + } + updated, err = updated.Seal() + if err != nil { + return nil, nil, fmt.Errorf( + "seal confirmed input metadata: %w", err, + ) + } + updated, err = updated.WithFinalAnchorPSBT(original.AnchorPsbt) + if err != nil { + return nil, nil, err + } + if err := checkConfirmationOnly(original, updated); err != nil { + return nil, nil, err + } + if err := checkConfirmedPackageCurrent(ctx, wallet, chain, minConfs, proofs, anchor); err != nil { + return nil, nil, err + } + return updated, files, nil +} + +func confirmInputSource(source sdk.CustomAnchorProofSourceSummary, + confirmations map[sdk.Hash]sdk.AnchorConfirmation) ([]byte, + sdk.CustomAnchorProofSourceSummary, error) { + + if source.Kind == sdk.CustomAnchorProofSourceConfirmedFile { + return bytes.Clone(source.Blob), source, nil + } + if source.Kind != sdk.CustomAnchorProofSourceCompactPath { + return nil, source, fmt.Errorf("unsupported input proof source") + } + var path sdk.AssetProofPath + if err := path.UnmarshalBinary(source.Blob); err != nil { + return nil, source, err + } + raw, err := path.ConfirmProofFile(confirmations) + if err != nil { + return nil, source, err + } + // A zero-step native path is a confirmed proof source accepted by the + // SDK publisher. Its public ContentID avoids duplicating a private hash + // domain or introducing another package/proof serialization. + confirmed := sdk.AssetProofPath{ConfirmedBaseProof: raw} + id, err := confirmed.ContentID() + if err != nil { + return nil, source, err + } + blob, err := confirmed.MarshalBinary() + if err != nil { + return nil, source, err + } + return raw, sdk.CustomAnchorProofSourceSummary{ + Kind: sdk.CustomAnchorProofSourceCompactPath, + ContentID: id, Blob: blob, + }, nil +} + +func replaceInputProof(pkg *sdk.CustomAnchorTransferPackage, + input sdk.CustomAnchorAssetInputSummary, confirmed *proof.Proof) error { + + packets := pkg.ActiveVirtualPsbts + if input.PacketRole == sdk.CustomAnchorPacketRolePassive { + packets = pkg.PassiveVirtualPsbts + } + if input.PacketIndex >= uint32(len(packets)) { + return fmt.Errorf("asset packet index is out of range") + } + packet, err := tappsbt.Decode(packets[input.PacketIndex]) + if err != nil { + return err + } + if input.VirtualInputIndex >= uint32(len(packet.Inputs)) { + return fmt.Errorf("asset input index is out of range") + } + selected := packet.Inputs[input.VirtualInputIndex] + if selected.Proof == nil || + selected.Proof.OutPoint() != confirmed.OutPoint() { + + return fmt.Errorf("confirmed proof selects another anchor") + } + var oldAsset, newAsset bytes.Buffer + if err := selected.Proof.Asset.Encode(&oldAsset); err != nil { + return err + } + if err := confirmed.Asset.Encode(&newAsset); err != nil { + return err + } + if !bytes.Equal(oldAsset.Bytes(), newAsset.Bytes()) { + return fmt.Errorf("confirmation changes the input asset state") + } + selected.Proof = confirmed + packets[input.PacketIndex], err = tappsbt.Encode(packet) + return err +} + +// checkConfirmationOnly compares native snapshots after removing only the +// permitted input-proof changes and the digests that necessarily cover them. +func checkConfirmationOnly(original, + updated *sdk.CustomAnchorTransferPackage) error { + + if original.UnsignedTxDigest != updated.UnsignedTxDigest || + !bytes.Equal(original.AnchorPsbt, updated.AnchorPsbt) || + !bytes.Equal(original.CommittedAnchorPsbt, + updated.CommittedAnchorPsbt) { + + return fmt.Errorf( + "confirmation changes the approved Bitcoin transaction", + ) + } + a, b := original.Clone(), updated.Clone() + if len(a.Inputs) != len(b.Inputs) { + return fmt.Errorf("confirmation changes asset input count") + } + for idx := range b.Inputs { + b.Inputs[idx].ProofSource = a.Inputs[idx].ProofSource + } + for _, pair := range [][2][][]byte{ + {a.ActiveVirtualPsbts, b.ActiveVirtualPsbts}, + {a.PassiveVirtualPsbts, b.PassiveVirtualPsbts}, + } { + if len(pair[0]) != len(pair[1]) { + return fmt.Errorf( + "confirmation changes virtual packet count", + ) + } + for idx, originalRaw := range pair[0] { + before, err := tappsbt.Decode(originalRaw) + if err != nil { + return err + } + after, err := tappsbt.Decode(pair[1][idx]) + if err != nil { + return err + } + if len(before.Inputs) != len(after.Inputs) { + return fmt.Errorf( + "confirmation changes virtual inputs", + ) + } + for j := range after.Inputs { + after.Inputs[j].Proof = before.Inputs[j].Proof + } + oldRaw, err := tappsbt.Encode(before) + if err != nil { + return err + } + newRaw, err := tappsbt.Encode(after) + if err != nil { + return err + } + if !bytes.Equal(oldRaw, newRaw) { + return fmt.Errorf( + "confirmation changes virtual state", + ) + } + pair[1][idx] = bytes.Clone(originalRaw) + } + } + b.CommittedPackageDigest = a.CommittedPackageDigest + b.PackageDigest = a.PackageDigest + if !reflect.DeepEqual(a, b) { + return fmt.Errorf( + "confirmation changes approved package policy", + ) + } + return nil +} + +// checkConfirmedPackageCurrent includes independent fee inputs, which are not +// selected by asset proof bindings, and repeats the live-node compatibility gate. +func checkConfirmedPackageCurrent(ctx context.Context, wallet *sdk.Wallet, + chain Chain, minConfs uint32, proofs []*proof.Proof, anchor *psbt.Packet) error { + + if err := CheckNodeVersion(ctx, wallet); err != nil { + return err + } + for _, p := range proofs { + if err := checkConfirmation(ctx, chain, minConfs, p, true); err != nil { + return err + } + } + source, ok := chain.(PrevoutSource) + if !ok { + return fmt.Errorf("confirmation handoff requires authenticated Bitcoin prevouts") + } + raw, err := EncodePSBT(anchor) + if err != nil { + return err + } + if err := CheckFundingInputs(ctx, source, raw); err != nil { + return err + } + return checkFundingCurrent(ctx, chain, anchor, nil) +} + +func cloneConfirmations(confirmations map[sdk.Hash]sdk.AnchorConfirmation) ( + map[sdk.Hash]sdk.AnchorConfirmation, error) { + + var total int + for _, c := range confirmations { + if len(c.Block) > assetpolicy.MaxProvenanceBytes-total { + return nil, fmt.Errorf("confirmation evidence exceeds size budget") + } + total += len(c.Block) + } + result := make(map[sdk.Hash]sdk.AnchorConfirmation, len(confirmations)) + for id, c := range confirmations { + c.Block = bytes.Clone(c.Block) + result[id] = c + } + return result, nil +} diff --git a/swapkit/tapsdk/confirmation_handoff_test.go b/swapkit/tapsdk/confirmation_handoff_test.go new file mode 100644 index 000000000..10d11be79 --- /dev/null +++ b/swapkit/tapsdk/confirmation_handoff_test.go @@ -0,0 +1,182 @@ +package tapsdk + +import ( + "bytes" + "testing" + + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/wire" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/stretchr/testify/require" +) + +type handoffFixture struct { + *pathFixture + + child *sdk.CustomAnchorTransferPackage + binding InputBinding + confirmations map[sdk.Hash]sdk.AnchorConfirmation +} + +func newHandoffFixture(t *testing.T) handoffFixture { + t.Helper() + f := newPathFixture(t) + _, parent := f.parent(t) + request, binding := f.child(t, parent) + parents, err := NewApprovedParents(t.Context(), f.wallet, f.chain, 2, + request, []InputBinding{binding}, []ParentApproval{{Package: parent, + Digest: parent.CommittedPackageDigest}}) + require.NoError(t, err) + builder := f.wallet.NewCustomAnchorTxBuilder() + builder.SetConfirmedProofVerifier(parents) + plan, err := builder.Build(t.Context(), request) + require.NoError(t, err) + child, err := plan.Commit(t.Context(), sdk.CustomAnchorCommitOptions{}) + require.NoError(t, err) + child = pathFinal(t, child) + packet, err := DecodePSBT(parent.AnchorPsbt) + require.NoError(t, err) + tx, err := psbt.Extract(packet) + require.NoError(t, err) + block := &wire.MsgBlock{Header: wire.BlockHeader{MerkleRoot: tx.TxHash()}, Transactions: []*wire.MsgTx{tx}} + f.chain.blocks[150] = block + for _, input := range tx.TxIn { + delete(f.chain.utxos, input.PreviousOutPoint) + } + for i, output := range tx.TxOut { + f.chain.utxos[wire.OutPoint{Hash: tx.TxHash(), Index: uint32(i)}] = output + } + var raw bytes.Buffer + require.NoError(t, block.Serialize(&raw)) + f.client.verifies = 0 + return handoffFixture{pathFixture: f, child: child, binding: binding, + confirmations: map[sdk.Hash]sdk.AnchorConfirmation{sdk.Hash(tx.TxHash()): {BlockHeight: 150, Block: raw.Bytes()}}} +} + +// TestConfirmPackageInputsNativePublish preserves every approved transaction, +// asset and policy field while installing native confirmed input histories. +// The real SDK publisher accepts the replacement without new signatures; its +// backend is a mock and publication/import retry state remains caller-owned. +func TestConfirmPackageInputsNativePublish(t *testing.T) { + f := newHandoffFixture(t) + before := f.child.Clone() + updated, files, err := ConfirmPackageInputs(t.Context(), f.wallet, f.chain, 2, + f.child, f.child.CommittedPackageDigest, f.confirmations, []InputBinding{f.binding}) + require.NoError(t, err) + require.Equal(t, before, f.child) + require.NoError(t, checkConfirmationOnly(before, updated)) + require.NotEqual(t, before.CommittedPackageDigest, updated.CommittedPackageDigest) + require.Equal(t, before.AnchorPsbt, updated.AnchorPsbt) + require.Equal(t, before.Outputs, updated.Outputs) + require.Len(t, files, 1) + require.Equal(t, 1, f.client.verifies) + var path sdk.AssetProofPath + require.NoError(t, path.UnmarshalBinary(updated.Inputs[0].ProofSource.Blob)) + require.Empty(t, path.Steps) + require.Equal(t, files[0].RawProofFile, path.ConfirmedBaseProof) + p, err := LastProof(files[0].RawProofFile) + require.NoError(t, err) + require.Equal(t, sdk.Outpoint{Txid: sdk.Hash(p.Asset.Genesis.FirstPrevOut.Hash), + Index: p.Asset.Genesis.FirstPrevOut.Index}, files[0].GenesisPoint) + _, err = f.wallet.PublishCustomAnchorTransfer(t.Context(), before, before.AnchorPsbt) + require.ErrorIs(t, err, sdk.ErrUnconfirmedCustomAnchorPublish) + require.Zero(t, f.client.publishes) + _, err = f.wallet.PublishCustomAnchorTransfer(t.Context(), updated, updated.AnchorPsbt) + require.ErrorContains(t, err, "publication is outside this test") + require.Equal(t, 1, f.client.publishes) + f.client.verifies = 0 + retried, _, err := ConfirmPackageInputs(t.Context(), f.wallet, f.chain, 2, + updated, updated.CommittedPackageDigest, nil, []InputBinding{f.binding}) + require.NoError(t, err) + require.Equal(t, updated.CommittedPackageDigest, retried.CommittedPackageDigest) + require.Equal(t, 1, f.client.verifies) +} + +func TestConfirmPackageInputsRejectsChanges(t *testing.T) { + const spentDuringVerification = "spent during verify" + for _, name := range []string{"saved digest", "unsigned child", "missing confirmation", + "fake block", "wrong asset", "spent fee input", testSpoofedFeeValue, + "spoofed fee script", spentDuringVerification} { + t.Run(name, func(t *testing.T) { + f := newHandoffFixture(t) + digest := f.child.CommittedPackageDigest + switch name { + case "saved digest": + digest[0] ^= 1 + case "unsigned child": + f.child = f.child.Clone() + f.child.AnchorPsbt = f.child.CommittedAnchorPsbt + var err error + f.child, err = f.child.Seal() + require.NoError(t, err) + case "missing confirmation": + f.confirmations = nil + case "fake block": + for id, c := range f.confirmations { + var block wire.MsgBlock + require.NoError(t, block.Deserialize(bytes.NewReader(c.Block))) + block.Header.Nonce++ + var raw bytes.Buffer + require.NoError(t, block.Serialize(&raw)) + c.Block = raw.Bytes() + f.confirmations[id] = c + } + case "wrong asset": + f.binding.Amount++ + case "spent fee input": + p, err := DecodePSBT(f.child.AnchorPsbt) + require.NoError(t, err) + delete(f.chain.utxos, p.UnsignedTx.TxIn[0].PreviousOutPoint) + case testSpoofedFeeValue, "spoofed fee script": + p, err := DecodePSBT(f.child.AnchorPsbt) + require.NoError(t, err) + point := p.UnsignedTx.TxIn[0].PreviousOutPoint + if name == testSpoofedFeeValue { + f.chain.utxos[point].Value++ + } else { + f.chain.utxos[point].PkScript = []byte{1} + } + case spentDuringVerification: + f.client.afterVerify = func() { clear(f.chain.utxos) } + } + updated, files, err := ConfirmPackageInputs(t.Context(), f.wallet, f.chain, 2, + f.child, digest, f.confirmations, []InputBinding{f.binding}) + require.Error(t, err) + require.Nil(t, updated) + require.Nil(t, files) + if name != spentDuringVerification { + require.Zero(t, f.client.verifies) + } + }) + } +} + +func TestConfirmationSnapshotRejectsOtherMetadata(t *testing.T) { + f := newHandoffFixture(t) + for _, mutate := range []func(*sdk.CustomAnchorTransferPackage){ + func(p *sdk.CustomAnchorTransferPackage) { p.Publish.Label += "changed" }, + func(p *sdk.CustomAnchorTransferPackage) { p.Outputs[0].Amount++ }, + } { + changed := f.child.Clone() + mutate(changed) + require.Error(t, checkConfirmationOnly(f.child, changed)) + } + // A proof for another input state cannot be installed as metadata. + p, err := proof.Decode(f.child.ProofUpdates[0].ProofBlob) + require.NoError(t, err) + p.Asset.Amount++ + require.Error(t, replaceInputProof(f.child.Clone(), f.child.Inputs[0], p)) +} + +func TestConfirmationSnapshotsBeforeRPC(t *testing.T) { + f := newHandoffFixture(t) + f.client.afterInfo = func() { + f.binding.Anchor.Leaves[0][0] ^= 1 + clear(f.confirmations) + } + _, files, err := ConfirmPackageInputs(t.Context(), f.wallet, f.chain, 2, + f.child, f.child.CommittedPackageDigest, f.confirmations, []InputBinding{f.binding}) + require.NoError(t, err) + require.Len(t, files, 1) +} diff --git a/swapkit/tapsdk/paths.go b/swapkit/tapsdk/paths.go new file mode 100644 index 000000000..250d2ee54 --- /dev/null +++ b/swapkit/tapsdk/paths.go @@ -0,0 +1,441 @@ +package tapsdk + +import ( + "bytes" + "context" + "crypto/sha256" + "fmt" + "reflect" + "slices" + + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + assetpolicy "github.com/lightninglabs/loop/internal/assetpolicy" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/proof" +) + +// ParentApproval identifies independently approved native package terms. Its +// committed digest excludes final witness encoding; the complete Bitcoin +// witnesses are validated separately before any child is authorized. +type ParentApproval struct { + Package *sdk.CustomAnchorTransferPackage + Digest sdk.Hash +} + +// ApprovedParents implements the native SDK's compact-path verification +// interfaces for one build. The SDK retains ownership of virtual transitions +// and proof-path verification. Create a fresh verifier for each operation; +// install it with builder.SetConfirmedProofVerifier before native Build, then +// call CheckPlan before Commit. Persist parent approvals in the FSM. +// Compact paths currently require isolated asset anchors in the native SDK. +type ApprovedParents struct { + wallet *sdk.Wallet + chain Chain + source PrevoutSource + minConfs uint32 + parents map[chainhash.Hash]*wire.MsgTx + outputs map[wire.OutPoint]*wire.TxOut + prevouts map[wire.OutPoint]*wire.TxOut + bases map[[32]byte]*proof.Proof + verified map[[32]byte]bool + anchor *psbt.Packet + request *sdk.CustomAnchorRequest +} + +// NewApprovedParents binds every request input to independently agreed terms, +// authenticates fully signed parents, and checks current root funding. It does +// not build, commit, sign, publish or persist a transfer. Root funding must +// remain unspent (including mempool lookup) while pre-signing descendants. The +// chain must also implement PrevoutSource to authenticate their values/scripts. +func NewApprovedParents(ctx context.Context, wallet *sdk.Wallet, chain Chain, + minConfs uint32, request *sdk.CustomAnchorRequest, bindings []InputBinding, + approvals []ParentApproval) (*ApprovedParents, error) { + + if request == nil || chain == nil || minConfs == 0 { + return nil, fmt.Errorf("request, current chain and confirmation policy are required") + } + source, ok := chain.(PrevoutSource) + if !ok { + return nil, fmt.Errorf("compact parents require authenticated Bitcoin prevouts") + } + if err := checkCompactRequestBudget(request); err != nil { + return nil, err + } + request = request.Clone() + g := &ApprovedParents{wallet: wallet, chain: chain, source: source, + minConfs: minConfs, request: request, + parents: make(map[chainhash.Hash]*wire.MsgTx), outputs: make(map[wire.OutPoint]*wire.TxOut), + prevouts: make(map[wire.OutPoint]*wire.TxOut), bases: make(map[[32]byte]*proof.Proof), + verified: make(map[[32]byte]bool)} + if err := g.addParents(approvals); err != nil { + return nil, err + } + var err error + g.anchor, err = DecodePSBT(request.AnchorPSBT) + if err != nil { + return nil, err + } + byID := make(map[string]InputBinding, len(bindings)) + for _, binding := range bindings { + if binding.ID == "" { + return nil, fmt.Errorf("input binding ID is required") + } + if _, duplicate := byID[binding.ID]; duplicate { + return nil, fmt.Errorf("duplicate input binding") + } + byID[binding.ID] = binding.clone() + } + if err := CheckNodeVersion(ctx, wallet); err != nil { + return nil, err + } + inspect := func(id string, raw []byte, path *sdk.AssetProofPath) error { + binding, ok := byID[id] + if !ok { + return fmt.Errorf("input binding is missing") + } + delete(byID, id) + var p *proof.Proof + var err error + if path != nil { + if len(raw) != 0 { + return fmt.Errorf("input cannot select both proof sources") + } + p, err = g.inspectPath(ctx, path) + } else { + p, err = InspectInputProof(ctx, wallet, chain, minConfs, raw, binding, true) + if err == nil { + g.bases[sha256.Sum256(raw)] = p + } + } + if err != nil { + return err + } + if err := binding.validate(p); err != nil { + return err + } + return checkPathSigning(binding, g.anchor, request.SigningPlans) + } + for _, input := range request.Inputs { + if err := inspect(input.ID, input.ProofFile, input.ProofPath); err != nil { + return nil, err + } + } + for _, input := range request.PassiveAssets.Packets { + if err := inspect(input.ID, input.ProofFile, nil); err != nil { + return nil, err + } + } + if len(byID) != 0 { + return nil, fmt.Errorf("unused input bindings") + } + if err := g.CheckCurrent(ctx); err != nil { + return nil, err + } + return g, nil +} + +func (g *ApprovedParents) addParents(approvals []ParentApproval) error { + spenders := make(map[wire.OutPoint]chainhash.Hash) + for _, approval := range approvals { + if approval.Package == nil || approval.Digest == (sdk.Hash{}) || + approval.Package.CommittedPackageDigest != approval.Digest { + + return fmt.Errorf("parent differs from saved committed digest") + } + if err := CheckSigningPolicy(approval.Package); err != nil { + return err + } + parent, err := approval.Package.WithFinalAnchorPSBT(approval.Package.AnchorPsbt) + if err != nil { + return fmt.Errorf("parent Bitcoin authorization: %w", err) + } + packet, err := DecodePSBT(parent.AnchorPsbt) + if err != nil { + return err + } + tx, err := psbt.Extract(packet) + if err != nil { + return err + } + id := tx.TxHash() + if g.parents[id] != nil { + return fmt.Errorf("duplicate approved parent transaction") + } + g.parents[id] = tx + for idx, output := range tx.TxOut { + g.outputs[wire.OutPoint{Hash: id, Index: uint32(idx)}] = output + } + for idx, input := range tx.TxIn { + point := input.PreviousOutPoint + if previous, ok := spenders[point]; ok && previous != id { + return fmt.Errorf("approved parents double-spend an input") + } + spenders[point] = id + if packet.Inputs[idx].WitnessUtxo == nil { + return fmt.Errorf("approved parent previous output is missing") + } + g.prevouts[point] = packet.Inputs[idx].WitnessUtxo + } + } + return nil +} + +func (g *ApprovedParents) inspectPath(ctx context.Context, + path *sdk.AssetProofPath) (*proof.Proof, error) { + + if err := path.Validate(); err != nil { + return nil, err + } + params, err := nodeParams(ctx, g.wallet) + if err != nil { + return nil, err + } + pending := []*sdk.AssetProofPath{path} + var tip *proof.Proof + for len(pending) != 0 { + current := pending[len(pending)-1] + pending = pending[:len(pending)-1] + if err := checkProvenance(ctx, g.wallet, current.ConfirmedBaseProof); err != nil { + return nil, err + } + last, err := LastProof(current.ConfirmedBaseProof) + if err != nil { + return nil, err + } + if _, _, err := isolatedRoots(last); err != nil { + return nil, fmt.Errorf("compact parent paths require isolated asset anchors: %w", err) + } + g.bases[sha256.Sum256(current.ConfirmedBaseProof)] = last + for _, step := range current.Steps { + last, err = proof.Decode(step.TransitionProof) + if err != nil { + return nil, err + } + if last.ChallengeWitness != nil { + return nil, fmt.Errorf("compact path contains an ownership challenge") + } + if err := assetpolicy.ValidateTransitionVersion(last.Version); err != nil { + return nil, err + } + if height, active := assetpolicy.ActivationHeight(params); active { + if err := assetpolicy.ValidateActivation(last, height); err != nil { + return nil, err + } + } + pending = append(pending, step.CoInputPaths...) + } + if current == path { + tip = last + } + } + return tip, nil +} + +// VerifyConfirmedProof implements the native SDK confirmed-base boundary. +// Verification reuse is local to this factory instance and exact base bytes; +// every current-chain check repeats before and after authenticated tapd RPCs. +func (g *ApprovedParents) VerifyConfirmedProof(ctx context.Context, + raw []byte) (*sdk.ConfirmedProofVerification, error) { + + digest := sha256.Sum256(raw) + p := g.bases[digest] + if p == nil { + return nil, fmt.Errorf("compact base was not inspected") + } + if err := g.CheckCurrent(ctx); err != nil { + return nil, err + } + if !g.verified[digest] { + result, err := g.wallet.Client().VerifyProof(ctx, bytes.Clone(raw)) + if err != nil { + return nil, err + } + if err := checkVerifiedSummary(result, p); err != nil { + return nil, err + } + g.verified[digest] = true + } + if err := g.CheckCurrent(ctx); err != nil { + return nil, err + } + return &sdk.ConfirmedProofVerification{AnchorAssetInventoryComplete: true}, nil +} + +// VerifyUnconfirmedAnchor binds SDK-derived transitions to exact independently +// approved parents after executing their complete Bitcoin witnesses. +func (g *ApprovedParents) VerifyUnconfirmedAnchor(_ context.Context, + transition sdk.UnconfirmedAnchorVerification) error { + + var tx wire.MsgTx + if err := tx.Deserialize(bytes.NewReader(transition.AnchorTransaction)); err != nil { + return err + } + parent := g.parents[tx.TxHash()] + if parent == nil || transition.AnchorOutpoint.Txid != sdk.Hash(parent.TxHash()) || + transition.AnchorOutpoint.Index >= uint32(len(parent.TxOut)) { + + return fmt.Errorf("compact transition has no approved signed parent") + } + var actual, approved bytes.Buffer + if err := tx.SerializeNoWitness(&actual); err != nil { + return err + } + if err := parent.SerializeNoWitness(&approved); err != nil { + return err + } + if !bytes.Equal(actual.Bytes(), approved.Bytes()) { + return fmt.Errorf("compact transition differs from approved parent") + } + for _, input := range transition.PreviousAnchorOutpoints { + point := SDKPoint(input) + if !slices.ContainsFunc(parent.TxIn, func(in *wire.TxIn) bool { + return in.PreviousOutPoint == point + }) { + + return fmt.Errorf("compact transition uses an unapproved parent input") + } + } + return nil +} + +// CheckCurrent rechecks live node compatibility, current confirmed bases and +// every external Bitcoin input of the parent graph and child, including fees. +func (g *ApprovedParents) CheckCurrent(ctx context.Context) error { + if err := CheckNodeVersion(ctx, g.wallet); err != nil { + return err + } + for _, p := range g.bases { + if err := checkConfirmation(ctx, g.chain, g.minConfs, p, true); err != nil { + return err + } + } + skip := make(map[wire.OutPoint]bool, len(g.outputs)) + for point, output := range g.outputs { + skip[point] = true + if previous := g.prevouts[point]; previous != nil && + (previous.Value != output.Value || !bytes.Equal(previous.PkScript, output.PkScript)) { + + return fmt.Errorf("parent input differs from approved graph output") + } + } + for point, expected := range g.prevouts { + if skip[point] { + continue + } + actual, err := g.source.Prevout(ctx, point) + if err != nil { + return err + } + if !sameFundingOutput(expected, actual) { + return fmt.Errorf("parent root differs from authenticated Bitcoin prevout") + } + unspent, err := g.chain.Unspent(ctx, point) + if err != nil { + return err + } + if !unspent { + return fmt.Errorf("approved parent root funding is spent") + } + } + for idx, input := range g.anchor.UnsignedTx.TxIn { + if g.prevouts[input.PreviousOutPoint] != nil { + return fmt.Errorf("child double-spends an approved parent input") + } + if output := g.outputs[input.PreviousOutPoint]; output != nil { + previous := g.anchor.Inputs[idx].WitnessUtxo + if previous == nil || previous.Value != output.Value || + !bytes.Equal(previous.PkScript, output.PkScript) { + + return fmt.Errorf("child input differs from approved parent output") + } + } else { + actual, err := g.source.Prevout(ctx, input.PreviousOutPoint) + if err != nil { + return err + } + if !sameFundingOutput(g.anchor.Inputs[idx].WitnessUtxo, actual) { + return fmt.Errorf("child funding differs from authenticated Bitcoin prevout") + } + } + } + return checkFundingCurrent(ctx, g.chain, g.anchor, skip) +} + +func checkPathSigning(binding InputBinding, packet *psbt.Packet, + plans []sdk.CustomAnchorInputSigningPlan) error { + + if binding.Spend == nil { + return nil + } + spend := binding.Spend + index := slices.IndexFunc(packet.UnsignedTx.TxIn, func(in *wire.TxIn) bool { + return in.PreviousOutPoint == SDKPoint(binding.AnchorOutpoint) + }) + if index < 0 || packet.UnsignedTx.Version < 2 || + packet.UnsignedTx.TxIn[index].Sequence != spend.Sequence || + packet.UnsignedTx.LockTime < spend.LockTime || + (spend.LockTime != 0 && packet.UnsignedTx.LockTime >= txscript.LockTimeThreshold) { + + return fmt.Errorf("contract sequence and locktime must be set before native Build") + } + leaf := sdk.Hash(txscript.NewBaseTapLeaf(spend.LeafScript).TapHash()) + for _, plan := range plans { + if plan.InputIndex == uint32(index) && plan.ScriptPath != nil && + plan.ScriptPath.LeafHash == leaf && slices.Equal(plan.ScriptPath.RequiredSigners, + []sdk.XOnlyPubKey{sdk.XOnlyPubKey(spend.RequiredSigner)}) { + + return nil + } + } + return fmt.Errorf("contract signing plan differs from agreed spend") +} + +func checkCompactRequestBudget(request *sdk.CustomAnchorRequest) error { + var total int + add := func(size int) error { + if size > assetpolicy.MaxProvenanceBytes-total { + return fmt.Errorf("compact request histories exceed size budget") + } + total += size + return nil + } + for _, input := range request.Inputs { + if input.ProofPath == nil { + if err := add(len(input.ProofFile)); err != nil { + return err + } + continue + } + raw, err := input.ProofPath.MarshalBinary() + if err != nil { + return err + } + if err := add(len(raw)); err != nil { + return err + } + } + for _, input := range request.PassiveAssets.Packets { + if err := add(len(input.ProofFile)); err != nil { + return err + } + } + return nil +} + +// CheckPlan binds the native built plan to the exact request inspected by this +// verifier, then repeats current funding checks. Call before native Commit; a +// different request must obtain fresh independent bindings and a new verifier. +func (g *ApprovedParents) CheckPlan(ctx context.Context, plan *sdk.CustomAnchorPlan) error { + if plan == nil || !reflect.DeepEqual(plan.Request(), g.request) { + return fmt.Errorf("native plan differs from inspected compact request") + } + return g.CheckCurrent(ctx) +} + +func sameFundingOutput(expected, actual *wire.TxOut) bool { + return expected != nil && actual != nil && actual.Value >= 0 && + expected.Value == actual.Value && bytes.Equal(expected.PkScript, actual.PkScript) +} diff --git a/swapkit/tapsdk/paths_test.go b/swapkit/tapsdk/paths_test.go index fb10bbe11..96ed08c5d 100644 --- a/swapkit/tapsdk/paths_test.go +++ b/swapkit/tapsdk/paths_test.go @@ -34,11 +34,9 @@ func (c *pathChain) Prevout(_ context.Context, point wire.OutPoint) (*wire.TxOut } func (c *pathChain) Height(context.Context) (uint32, error) { return 200, nil } - func (c *pathChain) Block(_ context.Context, h uint32) (*wire.MsgBlock, error) { return c.blocks[h], nil } - func (c *pathChain) BlockHash(_ context.Context, height uint32) (chainhash.Hash, error) { @@ -48,7 +46,6 @@ func (c *pathChain) BlockHash(_ context.Context, } return block.BlockHash(), nil } - func (c *pathChain) Unspent(_ context.Context, p wire.OutPoint) (bool, error) { return c.utxos[p] != nil, nil } @@ -68,7 +65,6 @@ func (c *pathClient) GetInfo(context.Context) (*sdk.Info, error) { } return fixtureNodeInfo(), nil } - func (c *pathClient) VerifyProof(_ context.Context, raw []byte) (*sdk.VerifyProofResponse, error) { c.verifies++ if c.afterVerify != nil { @@ -76,12 +72,10 @@ func (c *pathClient) VerifyProof(_ context.Context, raw []byte) (*sdk.VerifyProo } return fixtureVerified(raw, true) } - func (c *pathClient) CustomAnchorCapabilities(context.Context) (*sdk.CustomAnchorCapabilities, error) { v := sdk.DefaultTapdCustomAnchorCapabilities() return &v, nil } - func (c *pathClient) PublishAndLogTransferWithRequest(context.Context, *sdk.PublishAndLogTransferRequest) (*sdk.AssetPacket, error) { @@ -333,3 +327,122 @@ func requestPoint(t *testing.T, request *sdk.CustomAnchorRequest, index int) wir require.NoError(t, err) return p.UnsignedTx.TxIn[index].PreviousOutPoint } + +func TestApprovedParentsNativeBuild(t *testing.T) { + f := newPathFixture(t) + unsigned, parent := f.parent(t) + request, binding := f.child(t, parent) + for _, approval := range []ParentApproval{ + {Package: unsigned, Digest: unsigned.CommittedPackageDigest}, + {Package: parent, Digest: sdk.Hash{1}}, + } { + _, err := NewApprovedParents(t.Context(), f.wallet, f.chain, 2, + request, []InputBinding{binding}, []ParentApproval{approval}) + require.Error(t, err) + } + parents, err := NewApprovedParents(t.Context(), f.wallet, f.chain, 2, + request, []InputBinding{binding}, []ParentApproval{{Package: parent, + Digest: parent.CommittedPackageDigest}}) + require.NoError(t, err) + f.client.verifies = 0 + builder := f.wallet.NewCustomAnchorTxBuilder() + builder.SetConfirmedProofVerifier(parents) + plan, err := builder.Build(t.Context(), request) + require.NoError(t, err) + require.Equal(t, 1, f.client.verifies) + require.NoError(t, parents.CheckPlan(t.Context(), plan)) + child, err := plan.Commit(t.Context(), sdk.CustomAnchorCommitOptions{}) + require.NoError(t, err) + require.NoError(t, child.Validate()) + require.Equal(t, sdk.CustomAnchorProofSourceCompactPath, child.Inputs[0].ProofSource.Kind) + delete(f.chain.utxos, requestPoint(t, f.request, 0)) + require.Error(t, parents.CheckCurrent(t.Context())) +} + +func TestApprovedParentsRejectUnapprovedTransition(t *testing.T) { + f := newPathFixture(t) + _, parent := f.parent(t) + request, binding := f.child(t, parent) + _, err := NewApprovedParents(t.Context(), f.wallet, f.chain, 2, + request, []InputBinding{binding}, nil) + require.Error(t, err) +} + +func TestApprovedParentsRequireIsolatedBases(t *testing.T) { + f := newPathFixture(t) + p := bindingProof(t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, bindingGenesis().FirstPrevOut, 100, true) + request := f.request.Clone() + request.Inputs[0].ProofFile = nil + request.Inputs[0].ProofPath = &sdk.AssetProofPath{ConfirmedBaseProof: bindingRaw(t, p)} + _, err := NewApprovedParents(t.Context(), f.wallet, f.chain, 2, + request, []InputBinding{f.binding}, nil) + require.ErrorContains(t, err, "compact parent paths require isolated asset anchors") + require.Zero(t, f.client.verifies) +} + +func TestApprovedParentsRecheckFundingAfterVerification(t *testing.T) { + f := newPathFixture(t) + _, parent := f.parent(t) + request, binding := f.child(t, parent) + parents, err := NewApprovedParents(t.Context(), f.wallet, f.chain, 2, + request, []InputBinding{binding}, []ParentApproval{{Package: parent, + Digest: parent.CommittedPackageDigest}}) + require.NoError(t, err) + f.client.verifies = 0 + f.client.afterVerify = func() { clear(f.chain.utxos) } + builder := f.wallet.NewCustomAnchorTxBuilder() + builder.SetConfirmedProofVerifier(parents) + _, err = builder.Build(t.Context(), request) + require.Error(t, err) + require.Equal(t, 1, f.client.verifies) +} + +func TestApprovedParentsSnapshotBeforeRPC(t *testing.T) { + f := newPathFixture(t) + _, parent := f.parent(t) + request, binding := f.child(t, parent) + f.client.afterInfo = func() { + binding.Anchor.Leaves[0][0] ^= 1 + request.Inputs[0].ProofPath.ConfirmedBaseProof[0] ^= 1 + } + _, err := NewApprovedParents(t.Context(), f.wallet, f.chain, 2, + request, []InputBinding{binding}, []ParentApproval{{Package: parent, + Digest: parent.CommittedPackageDigest}}) + require.NoError(t, err) +} + +func TestApprovedParentsBindNativePlan(t *testing.T) { + f := newPathFixture(t) + _, parent := f.parent(t) + request, binding := f.child(t, parent) + parents, err := NewApprovedParents(t.Context(), f.wallet, f.chain, 2, + request, []InputBinding{binding}, []ParentApproval{{Package: parent, + Digest: parent.CommittedPackageDigest}}) + require.NoError(t, err) + changed := request.Clone() + changed.Outputs[0].ProofDelivery.RecipientID = "substituted delivery" + builder := f.wallet.NewCustomAnchorTxBuilder() + builder.SetConfirmedProofVerifier(parents) + plan, err := builder.Build(t.Context(), changed) + require.NoError(t, err) + require.ErrorContains(t, parents.CheckPlan(t.Context(), plan), "differs from inspected") +} + +func TestApprovedParentsAuthenticateRootFunding(t *testing.T) { + for _, script := range []bool{false, true} { + f := newPathFixture(t) + _, parent := f.parent(t) + request, binding := f.child(t, parent) + point := requestPoint(t, f.request, 0) + if script { + f.chain.utxos[point].PkScript = []byte{txscript.OP_TRUE} + } else { + f.chain.utxos[point].Value++ + } + _, err := NewApprovedParents(t.Context(), f.wallet, f.chain, 2, + request, []InputBinding{binding}, []ParentApproval{{Package: parent, + Digest: parent.CommittedPackageDigest}}) + require.ErrorContains(t, err, "authenticated Bitcoin prevout") + } +} From 7ce20983278b7412911c5f7de444c64bad9d2a8c Mon Sep 17 00:00:00 2001 From: Slyghtning Date: Wed, 11 Nov 2026 14:19:42 +0100 Subject: [PATCH 8/9] tapsdk: Recover claims and refunds from observed spends Recover contract spends through native SDK packages and exact output proofs. Preserve the original contract descriptors, asset quantities and confirmation evidence across claims and refunds. Make publication retries consult exact archived proofs and the tapd transfer log before logging again. Report pending confirmations without creating duplicate transfer records or repeating their anchor fees. --- docs/release-notes/release-notes-next.md | 6 + swapkit/asset_types.go | 159 +++++++ swapkit/roles_test.go | 8 + swapkit/tapsdk/README.md | 177 ++++++++ swapkit/tapsdk/binding_test.go | 398 +++++++++++++++++- swapkit/tapsdk/confirmation_test.go | 109 +++++ swapkit/tapsdk/context.go | 230 ++++++++++ swapkit/tapsdk/deposit_cache_test.go | 109 +++++ swapkit/tapsdk/fallback.go | 152 +++++++ swapkit/tapsdk/group_test.go | 29 ++ .../tapsdk/native_package_regression_test.go | 87 ++++ swapkit/tapsdk/observed_refund_test.go | 131 ++++++ swapkit/tapsdk/original_refund.go | 110 +++++ swapkit/tapsdk/original_refund_test.go | 170 ++++++++ swapkit/tapsdk/output_key_test.go | 79 ++++ swapkit/tapsdk/partial_recovery_test.go | 262 ++++++++++++ swapkit/tapsdk/proof_archive_test.go | 94 +++++ swapkit/tapsdk/proofs.go | 237 +++++++++++ swapkit/tapsdk/publish_retry_test.go | 189 +++++++++ swapkit/tapsdk/recovery.go | 305 ++++++++++++++ swapkit/tapsdk/spend.go | 66 +++ swapkit/tapsdk/spend_test.go | 141 +++++++ swapkit/tapsdk/wallet_spend.go | 173 ++++++++ 23 files changed, 3420 insertions(+), 1 deletion(-) create mode 100644 swapkit/tapsdk/README.md create mode 100644 swapkit/tapsdk/confirmation_test.go create mode 100644 swapkit/tapsdk/context.go create mode 100644 swapkit/tapsdk/fallback.go create mode 100644 swapkit/tapsdk/observed_refund_test.go create mode 100644 swapkit/tapsdk/original_refund.go create mode 100644 swapkit/tapsdk/original_refund_test.go create mode 100644 swapkit/tapsdk/output_key_test.go create mode 100644 swapkit/tapsdk/partial_recovery_test.go create mode 100644 swapkit/tapsdk/proof_archive_test.go create mode 100644 swapkit/tapsdk/publish_retry_test.go create mode 100644 swapkit/tapsdk/recovery.go create mode 100644 swapkit/tapsdk/spend.go create mode 100644 swapkit/tapsdk/wallet_spend.go diff --git a/docs/release-notes/release-notes-next.md b/docs/release-notes/release-notes-next.md index 8ea78eedd..c95916444 100644 --- a/docs/release-notes/release-notes-next.md +++ b/docs/release-notes/release-notes-next.md @@ -2,6 +2,12 @@ #### New Features +* Share asset deposit, reservation and CSV/CLTV HTLC contracts through + `swapkit`, with transfer, signing, proof and recovery helpers backed by + `github.com/lightninglabs/tap-sdk` v0.1.1 and Taproot Assets v0.8.8. New on-chain + asset swaps require tapd v0.8.8 or later. Shared helpers also authenticate + group issuance evidence and register issuance metadata before verification. + #### Breaking Changes #### Bug Fixes diff --git a/swapkit/asset_types.go b/swapkit/asset_types.go index a14fd54b6..66096387e 100644 --- a/swapkit/asset_types.go +++ b/swapkit/asset_types.go @@ -1,7 +1,11 @@ package swapkit import ( + "bytes" + "encoding/json" "errors" + "io" + "time" ) var ( @@ -9,6 +13,126 @@ var ( ErrPending = errors.New("asset transaction pending") ) +// Terms contains the agreed asset swap terms. Admission is private +// server recovery data containing authenticated registration and input proofs. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type Terms struct { + Version uint32 `json:"Version"` + RequestID [32]byte `json:"RequestID"` + RequestDigest [32]byte `json:"RequestDigest"` + Owner [32]byte `json:"Owner"` + GroupKey [33]byte `json:"GroupKey"` + DepositOutpoints []string `json:"DepositOutpoints"` + DepositAmount uint64 `json:"DepositAmount"` + PayoutAmount uint64 `json:"PayoutAmount"` + AssetFee uint64 `json:"AssetFee"` + ChangeAmount uint64 `json:"ChangeAmount"` + MaxDebit uint64 `json:"MaxDebit"` + RefundHeight uint32 `json:"RefundHeight"` + MinPayoutExpiry uint32 `json:"MinPayoutExpiry"` + RecoveryDelta uint32 `json:"RecoveryDelta"` + ExecutionDelta uint32 `json:"ExecutionDelta"` + OfferExpiry time.Time `json:"OfferExpiry"` + Contract []byte `json:"Contract"` + Admission []byte `json:",omitempty"` +} + +// Offer commits to the server payment hash and exact native asset terms. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type Offer struct { + Hash [32]byte `json:"Hash"` + Terms Terms `json:"Terms"` +} + +// Registration is loaded from the authenticated owner's static address row. +// The manager must bind every deposit policy to these exact keys and CSV. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type Registration struct { + Owner [32]byte `json:"Owner"` + // #nosec G117 -- ClientKey is a public Bitcoin key. + ClientKey [33]byte `json:"ClientKey"` + ServerKey [33]byte `json:"ServerKey"` + CSV uint32 `json:"CSV"` + KeyFamily int32 `json:"KeyFamily"` + KeyIndex uint32 `json:"KeyIndex"` +} + +// Deposit preserves the proof and contract needed after process restart. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type Deposit struct { + Outpoint string `json:"Outpoint"` + GroupKey [33]byte `json:"GroupKey"` + Amount uint64 `json:"Amount"` + Proof []byte `json:"Proof"` + Contract []byte `json:"Contract"` + ConfirmationHeight uint32 `json:"ConfirmationHeight"` + RefundHeight uint32 `json:"RefundHeight"` + ValueSat uint64 `json:"ValueSat"` +} + +// Admission binds client-supplied proofs to server-authenticated registration +// and server policy before the normal Loop In flow reserves any deposit. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type Admission struct { + Registration Registration `json:"Registration"` + RequestID [32]byte `json:"RequestID"` + GroupKey [33]byte `json:"GroupKey"` + Deposits []Deposit `json:"Deposits"` + Contract []byte `json:"Contract"` + RefundHeight uint32 `json:"RefundHeight"` + MinConfirmations uint32 `json:"MinConfirmations"` +} + +// AdmissionResult contains the native total verified from all input proofs. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type AdmissionResult struct { + DepositAmount uint64 `json:"DepositAmount"` +} + +// Preparation binds the invoice and transaction recovery request. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type Preparation struct { + Invoice string `json:"Invoice"` + PaymentPlan []byte `json:"PaymentPlan"` + RecoveryRequest []byte `json:"RecoveryRequest"` +} + +// Bundle and Claim use the SDK adapter's versioned serialized transaction data. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type Bundle struct { + Data []byte `json:"Data"` +} + +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type Claim struct { + Data []byte `json:"Data"` +} + +// Resolution requires confirmed spends and valid spendable asset proofs. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type Resolution struct { + Claimed bool `json:"Claimed"` + Refunded bool `json:"Refunded"` + Evidence []byte `json:"Evidence"` +} + +// PreimageResult distinguishes a verified chain disclosure from no disclosure. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type PreimageResult struct { + Preimage [32]byte `json:"Preimage"` + Found bool `json:"Found"` +} + // CreateDepositRequest binds idempotent deposit funding to wallet key locators. // //nolint:tagliatelle // Preserve the existing recovery and wire format. @@ -23,3 +147,38 @@ type CreateDepositRequest struct { KeyFamily int32 `json:"KeyFamily"` KeyIndex uint32 `json:"KeyIndex"` } + +// Decode rejects unknown fields and trailing data in peer-supplied packages. +func Decode(raw []byte, target any) error { + decoder := json.NewDecoder(bytes.NewReader(raw)) + decoder.DisallowUnknownFields() + if err := decoder.Decode(target); err != nil { + return err + } + if err := decoder.Decode(new(any)); !errors.Is(err, io.EOF) { + return ErrInvalid + } + return nil +} + +// RefundDepositRequest selects a wallet-owned mature static asset deposit. +// The manager must reject deposits reserved by an active signing operation. +// +//nolint:tagliatelle // Preserve the existing recovery and wire format. +type RefundDepositRequest struct { + Outpoint string `json:"Outpoint"` +} + +// PublicRPCMaxBytes bounds complete external protobuf requests and responses. +// Complete proofs and packages must fit within the external RPC limit. +const PublicRPCMaxBytes = 16 << 20 + +// FallbackSignature binds one public MuSig2 partial to the agreed package. +// +//nolint:tagliatelle // Preserve the public signing response encoding. +type FallbackSignature struct { + PackageDigest [32]byte `json:"PackageDigest"` + ClientNonce [66]byte `json:"ClientNonce"` + ServerNonce [66]byte `json:"ServerNonce"` + Partial []byte `json:"Partial"` +} diff --git a/swapkit/roles_test.go b/swapkit/roles_test.go index 5864cb976..7eba0712b 100644 --- a/swapkit/roles_test.go +++ b/swapkit/roles_test.go @@ -257,3 +257,11 @@ func TestSwapKitSnapshots(t *testing.T) { require.NotEqual(t, spend.PkScript, fresh.PkScript) require.NotEqual(t, spend.ControlBlock, fresh.ControlBlock) } + +func TestFlowRecordDecode(t *testing.T) { + var offer Offer + require.NoError(t, Decode([]byte(`{"Hash":[1],"Terms":{"Version":1}}`), &offer)) + require.Equal(t, uint32(1), offer.Terms.Version) + require.Error(t, Decode([]byte(`{"Terms":{"Unknown":1}}`), &offer)) + require.Error(t, Decode([]byte(`{} {}`), &offer)) +} diff --git a/swapkit/tapsdk/README.md b/swapkit/tapsdk/README.md new file mode 100644 index 000000000..fbb7f4c8b --- /dev/null +++ b/swapkit/tapsdk/README.md @@ -0,0 +1,177 @@ +# Swapkit SDK integration + +This adapter uses the released `github.com/lightninglabs/tap-sdk` v0.1.1. +That release provides the v0.3.0 API on the pre-btcd-v2 dependency graph. +Loop does not maintain a copy of the SDK or depend on the migration PRs. + +`swapkit` owns Bitcoin contracts. This package adapts them to the native Taproot +Assets SDK and checks Loop's independently agreed terms. The ordinary caller's +FSM owns decisions, persistence, key locators, ephemeral LND sessions, signing, +proof import and publication. These helpers do not introduce another manager or +transaction engine, and this toolkit change does not install Sputnik's complete +production Loop In FSM. + +The release includes the exact proof-export locator and received-key metadata +fixes needed by these flows. Loop pins Taproot Assets v0.8.8 and the bounded +legacy TLV decoder from the same tag. Consumers must +copy the TLV replacement from Loop's `go.mod`, since Go does not inherit it. + +For an existing authenticated tapd connection, construct the wallet with +`sdk.NewWallet(tapsdk.NewClientFromConn(conn, timeout), network)`. This +adapter composes the released SDK RPC clients, preserves custom-anchor and +grouped-registration capabilities, and removes the SDK's empty macaroon +header so existing credentials remain authoritative. The caller +owns credentials and connection shutdown; closing this wallet does not close +the borrowed connection. Consumers do not need a separate SDK client wrapper. + +## Asset and Bitcoin contracts + +`LegacyOPTrueOutput` preserves the existing fixed NUMS internal key and single +`OP_TRUE` asset leaf using native External mode. `LegacyOPTrueDescriptor` returns +its exact key derivation and witness. New deposit, reservation and fallback +callers should select this policy. Contract changes never implicitly migrate +already funded asset script keys. + +`OPTrueOutput` retains Sputnik's explicit supplied-key SDK tree constructor; +`SDKOPTrueOutput` is its clearly named alias. They require deliberate selection. +`OPTrueSpendInfo` validates saved native SDK witnesses and reconstructs only the +exact legacy External tree when a saved output has no native OP_TRUE descriptor. +Ordinary External wallet outputs cannot be promoted to public witnesses. Native +External package summaries remain unchanged and correctly have a nil +`OPTrueSpend` field. + +`AnchorPlan`, `CooperativeSigningPlan` and `ScriptSigningPlan` accept the pure +core's contracts: CSV deposit, CLTV reservation, CSV HTLC and Sputnik's CLTV HTLC. +`InputBinding` records exact issuance, optional full group key, quantity, script +key, outpoint and optional Bitcoin contract/spend terms. It has no client/server +role assumptions, so the server-funded reservation and client-funded deposit use +the same policy boundary. The older `DepositContext`/`SwapContext` helpers retain +Sputnik's specific Loop In negotiation semantics. + +## Native construction and approval + +Use the following order for a confirmed-input transaction: + +1. Retain independent input/output terms and the Bitcoin template. Obtain every + funding `WitnessUtxo` from an authenticated Bitcoin backend; a peer's PSBT is + not its source of authority. `Chain.Unspent` includes mempool spends. Use `CheckFundingInputs` with + `PrevoutSource` to authenticate every value and script against the current + Bitcoin backend; `LNDChain.PrevOutput` supplies this optional full lookup. + Confirmation checks verify the proof's transaction Merkle path against a + fresh block hash, without downloading full blocks. `PrevOutput` can also + back `Unspent` when no separate callback is supplied. Callbacks + must use the current mempool-inclusive view; availability is never cached + across operations. +2. `InspectInputProof` checks one isolated input. `InspectInputProofs` checks a + complete batch of active and passive bindings and their union commitment. + Both enforce bounded genesis provenance and the live tapd v0.8.8 floor. +3. `PrepareInputs` restores exact confirmed proof lineage and declares public + asset witnesses. Call the native `wallet.NewCustomAnchorTxBuilder().Build`. + Native SDK Build verifies lineage and constructs allocations and commitments; + do not repeat generic proof verification before Build. +4. Call `ApprovePlan` with the independently retained Bitcoin template, concrete + `OutputBinding` allocations and absolute fee cap. It checks every issuance, + allocation, asset key derivation, Bitcoin contract and complete transaction + terms using native commitment previews. Group allocations expanded into + several issuances need a binding for each concrete issuance. +5. Immediately before direct native `plan.Commit`, repeat `CheckNodeVersion`, + `CheckFundingInputs` on the native plan PSBT, and `CheckInputsCurrent`. The latter checks complete active/passive inventory, + current chain inclusion, confirmation depth and every funding outpoint. +6. Call `CheckSigningPolicy` on the committed package before opening signing + sessions or signing through native SDK requests. Every declared input must + use SIGHASH_DEFAULT; wallet-managed fee inputs retain wallet policy. The + encoded package must fit the 128 MiB recovery bound before releasing authority. +7. Persist the native committed package and its independently approved + `CommittedPackageDigest` before exposing signatures. Use normal LND signing + and the SDK's signing requests/final-witness APIs. Persist completion before + external effects. + +For native WalletFunded mode, set `MaxFeeSat` and the deterministic lock ID from +independent caller policy. `ApproveWalletFundedPlan` checks the fixed template +and allocations before funding, when the final fee/change cannot yet be known. +Use `AnchorChangeOutputAdd` for newly generated wallet change. Existing-output +and NoNew change policies are rejected so funding cannot change fixed recipients. +`CheckFundedPackage` validates the returned native funding summary against the +independent cap before anchor signing, release or publication. Exact/P2A plans +use `ApprovePlan`, which also verifies the complete actual fee, including a zero +fee when explicitly approved. + +Validation-only acceptance uses `VerifyInputProof` or Sputnik's `VerifyDeposit`/ +outcome helpers instead. They bind authenticated SDK verification results to +the exact local proof and bracket the verification RPC with current-chain +checks. Verification reuse is confined to one operation. Never carry validation +across actions, retries or restarts. Local saved-package decoding and Bitcoin +witness recovery do not depend on the live node version. + +Known co-anchored active/passive assets remain supported by the batch inventory +boundary and native SDK passive policy. Omitting an asset fails closed. The +single-input Loop In contexts and SDK compact paths require isolated anchors. + +## Group evidence and issuance metadata + +`VerifyGroupMembership` authenticates an anchor-first set of genesis proofs +against an independently supplied group and required issuance IDs. The caller +sets the aggregate proof-byte limit and decides which issuances its quote needs. +`SameGroupKey` uses the SDK's x-only identity comparison after validating both +compressed keys. `IsGroupMember` checks declared fungible group identity only; +it is not proof verification. + +`VerifyProofWithIssuance` inserts the verified genesis proof into the local +universe before asking tapd to verify the full history. It does not import a +wallet asset or register a received transfer. The caller must still enforce +its message limit and bind the result to the expected contract and output. +These helpers accept authenticated tapd RPC clients and preserve node errors. + +## Presigned descendants and publication + +`NewApprovedParents` implements the SDK's native confirmed-proof and unconfirmed +anchor verification interfaces for one operation. It accepts exact saved parent +committed digests, validates complete Bitcoin witnesses and checks the signed +transaction graph and current root funding. Install it with +`builder.SetConfirmedProofVerifier(parents)`, call native Build, then repeat +`parents.CheckPlan(ctx, plan)` and the independent output/Bitcoin approval before +Commit. `CheckPlan` binds the exact native request snapshot and repeats current +root-funding checks; a verifier must not be reused for a substituted request. +The chain passed to compact-parent and confirmation-handoff helpers must also +implement `PrevoutSource`: external Bitcoin fee and asset inputs require full +authenticated value/script comparisons, as well as mempool-inclusive unspent +checks. Known parent edges use the exact independently approved signed outputs. + +The SDK owns compact asset transition validation. Do not replace this adapter +with an attestation that only checks a parent transaction ID. + +Native Publish rejects a child that still contains unconfirmed compact steps. +After the parents confirm, `ConfirmPackageInputs` requires the same authenticated +prevout source and materializes native confirmed histories, verifies their exact +bindings/current chain and updates only proof +metadata. It preserves all asset state, Bitcoin commitments and final +witnesses. The resulting native package has a new committed digest: persist the +old-to-new digest association and updated package first, then import every +returned native `ProofFile` through `wallet.ImportProofFile`, and finally call +`wallet.PublishCustomAnchorTransfer`. Import/publication ambiguity and retry +remain owned by the FSM. + +`LogAndExport` retains Sputnik's single-input/output publication/recovery +helper. It registers exact descriptors, uses exact issuance/script/outpoint +proof locators, and logs already observed Bitcoin spends without rebroadcast. +tapd records every publication request as a new transfer, so a retry never +logs again: an archived exact proof returns its own confirmation result, and an +anchor already in tapd's transfer log returns `ErrPending` until its proof is +archived. Call it again to poll; serialize invocations for one package, since +the lookup and the publication are not atomic. +Generic callers can use the native publication and proof APIs directly. +`BindFinalPackage` accepts a peer's final Bitcoin witnesses only for the saved +approved native package. `DecodePackage` rejects packages over 128 MiB before +JSON decoding and validates native consistency and signing policy. Saved-package +validation uses the committed PSBT because finalization can remove its sighash +metadata. Recovery of an observed refund preserves its mined version, locktime +and sequence, including older non-RBF refunds. A digest does not itself cover final witnesses: those +are independently validated by the native SDK. + +## Validation + +Run `go test ./swapkit/... ./internal/assetproof ./internal/assetpolicy` with the +pinned Go toolchain. The tests cover native Build/Commit and package encoding, +legacy script vectors, exact policy substitution, signed compact parents, +confirmation handoff and native publication boundaries. Run daemon-backed +asset lifecycle cases in the Loop server integration harness. diff --git a/swapkit/tapsdk/binding_test.go b/swapkit/tapsdk/binding_test.go index aa01f0dd7..6f319f3b4 100644 --- a/swapkit/tapsdk/binding_test.go +++ b/swapkit/tapsdk/binding_test.go @@ -2,10 +2,14 @@ package tapsdk import ( "context" + "crypto/sha256" + "encoding/json" "testing" "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/txscript" "github.com/btcsuite/btcd/wire" "github.com/lightninglabs/loop/swapkit" sdk "github.com/lightninglabs/tap-sdk" @@ -13,6 +17,7 @@ import ( "github.com/lightninglabs/taproot-assets/commitment" "github.com/lightninglabs/taproot-assets/proof" "github.com/lightninglabs/taproot-assets/tapsend" + "github.com/lightningnetwork/lnd/keychain" "github.com/stretchr/testify/require" ) @@ -149,6 +154,398 @@ func bindingBlock(p *proof.Proof) *wire.MsgBlock { } } +func TestProofRequiresExactPolicyAndCurrentChain(t *testing.T) { + for _, test := range []struct { + name string + mutate func(*bindingSDK, *bindingChain, *proof.Proof, + *[33]byte, *uint64) + hidden bool + }{ + {name: testValid}, + {name: "hidden co-anchored asset", hidden: true}, + {name: "invalid SDK proof", mutate: func(s *bindingSDK, + _ *bindingChain, _ *proof.Proof, + _ *[33]byte, _ *uint64) { + + s.valid = false + }}, + {name: "opposite group parity", mutate: func(_ *bindingSDK, + _ *bindingChain, _ *proof.Proof, + g *[33]byte, _ *uint64) { + + g[0] ^= 1 + }}, + {name: "different amount", mutate: func(_ *bindingSDK, + _ *bindingChain, _ *proof.Proof, + _ *[33]byte, a *uint64) { + + *a++ + }}, + {name: "insufficient depth", mutate: func(_ *bindingSDK, + c *bindingChain, _ *proof.Proof, + _ *[33]byte, _ *uint64) { + + c.tip = 100 + }}, + {name: "tip below proof", mutate: func(_ *bindingSDK, + c *bindingChain, _ *proof.Proof, + _ *[33]byte, _ *uint64) { + + c.tip = 99 + }}, + {name: "reorged proof", mutate: func(_ *bindingSDK, + c *bindingChain, _ *proof.Proof, + _ *[33]byte, _ *uint64) { + + c.blocks[100].Header.Nonce++ + }}, + {name: "invalid transaction merkle proof", mutate: func(_ *bindingSDK, + _ *bindingChain, p *proof.Proof, + _ *[33]byte, _ *uint64) { + + p.TxMerkleProof.Nodes = []chainhash.Hash{{1}} + p.TxMerkleProof.Bits = []bool{true} + }}, + {name: testSpentOutput, mutate: func(_ *bindingSDK, + c *bindingChain, _ *proof.Proof, + _ *[33]byte, _ *uint64) { + + c.unspent = false + }}, + } { + t.Run(test.name, func(t *testing.T) { + p := bindingProof(t, bindingGenesis(), + bindingKey(2).PubKey(), bindingKey(3).PubKey(), + nil, bindingGenesis().FirstPrevOut, + 100, test.hidden) + client := &bindingSDK{valid: true} + chain := &bindingChain{tip: 101, unspent: true, + blocks: map[uint32]*wire.MsgBlock{ + 100: bindingBlock(p), + }} + group, amount := bindingPub(11), uint64(1000) + if test.mutate != nil { + test.mutate(client, chain, p, &group, &amount) + } + r := &proofNode{ + client: client, + chain: chain, + minConfs: 2, + } + _, err := verifyProof( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + bindingRaw(t, p), + group, + amount, + true, + ) + if test.name == testValid || test.name == "opposite group parity" { + require.NoError(t, err) + } else { + require.Error(t, err) + } + }) + } +} + +func bindingOutcome(t *testing.T, refund bool) (*proofNode, *SwapContext, + *proof.Proof, *bindingChain) { + + t.Helper() + clientKey, serverKey := bindingPub(2), bindingPub(3) + dk, err := swapkit.NewDepositKit(swapkit.DepositKitParams{ + ClientKey: clientKey, ServerKey: serverKey, CSVExpiry: 100, + }) + require.NoError(t, err) + leaf := txscript.NewBaseTapLeaf([]byte{txscript.OP_TRUE}) + assetTree := txscript.AssembleTaprootScriptTree(leaf) + assetRoot := assetTree.RootNode.TapHash() + assetKey := bindingKey(5).PubKey() + assetOutputKey := txscript.ComputeTaprootOutputKey( + assetKey, assetRoot[:], + ) + assetOutputKey, err = schnorr.ParsePubKey( + schnorr.SerializePubKey(assetOutputKey)) + require.NoError(t, err) + control := assetTree.LeafMerkleProofs[0].ToControlBlock(assetKey) + controlRaw, err := control.ToBytes() + require.NoError(t, err) + spend := &sdk.CustomAssetOPTrueSpendInfo{ + LeafScript: leaf.Script, LeafVersion: uint8(leaf.LeafVersion), + InternalKey: bindingPub(5), ControlBlock: controlRaw, + } + timeout, err := dk.TimeoutSpend(sdk.Hash{1}) + require.NoError(t, err) + sibling, err := commitment.NewPreimageFromLeaf( + txscript.NewBaseTapLeaf(timeout.LeafScript)) + require.NoError(t, err) + anchorPlan := dk.AnchorPlan() + internal, err := btcec.ParsePubKey(anchorPlan.InternalKey[:]) + require.NoError(t, err) + deposit := bindingProof(t, bindingGenesis(), assetOutputKey, internal, + sibling, bindingGenesis().FirstPrevOut, 100, false) + assets, merkle, err := isolatedRoots(deposit) + require.NoError(t, err) + var script sdk.PubKey + copy(script[:], assetOutputKey.SerializeCompressed()) + ref := sdk.AssetRefFromGroupKey(bindingPub(11)) + c := DepositContract{Version: 1, ClientKey: clientKey, + ServerKey: serverKey, CSV: 100, + Output: sdk.CustomAnchorAssetOutputSummary{ + ScriptKey: script, OPTrueSpend: spend, AssetRef: ref, + IssuanceID: sdk.AssetID(deposit.Asset.ID()), + AssetType: sdk.AssetType(deposit.Asset.Genesis.Type), + Amount: 1000, AnchorValueSat: 10_000, + TaprootAssetRoot: assets, TaprootMerkleRoot: merkle, + AnchorOutpoint: sdk.Outpoint{Txid: sdk.Hash( + deposit.AnchorTx.TxHash())}, + }} + // Preserve the existing SDK/contract JSON field names. + //nolint:musttag + contract, err := json.Marshal(c) + require.NoError(t, err) + preimage := [32]byte{99} + s := &SwapContext{Offer: swapkit.Offer{Hash: sha256.Sum256(preimage[:]), + Terms: swapkit.Terms{Version: 1, GroupKey: bindingPub(11), + DepositOutpoints: []string{deposit.OutPoint().String()}, + DepositAmount: 1000, PayoutAmount: 900, + AssetFee: 100, + RefundHeight: 150, RecoveryDelta: 10, + Contract: contract}}} + prior := sdk.CustomAnchorAssetOutputSummary{ + AssetRef: ref, Amount: 1000, + IssuanceID: sdk.AssetID(deposit.Asset.ID()), + AnchorValueSat: 9000, TaprootAssetRoot: sdk.Hash{42}, + AnchorOutpoint: sdk.Outpoint{Txid: sdk.Hash{88}}, + } + s.Fallback = &sdk.CustomAnchorTransferPackage{ + Outputs: []sdk.CustomAnchorAssetOutputSummary{prior}, + } + policy, err := HTLC(s.Offer, c) + require.NoError(t, err) + path, err := policy.SuccessSpend(prior.TaprootAssetRoot) + require.NoError(t, err) + receiver := bindingKey(3) + if refund { + receiver = bindingKey(2) + path, err = policy.TimeoutSpend(prior.TaprootAssetRoot) + require.NoError(t, err) + } + outputKey := txscript.ComputeTaprootKeyNoScript(receiver.PubKey()) + outputKey, err = schnorr.ParsePubKey(schnorr.SerializePubKey(outputKey)) + require.NoError(t, err) + outcome := bindingProof(t, bindingGenesis(), outputKey, + receiver.PubKey(), nil, SDKPoint(prior.AnchorOutpoint), + 160, false) + outcome.AnchorTx.TxIn[0].Sequence = path.Sequence + outcome.AnchorTx.LockTime = path.LockTime + outcome.AnchorTx.TxOut[0].Value = 8000 + fetch := txscript.NewCannedPrevOutputFetcher(path.PkScript, 9000) + sig, err := txscript.RawTxInTapscriptSignature(&outcome.AnchorTx, + txscript.NewTxSigHashes(&outcome.AnchorTx, fetch), 0, 9000, + path.PkScript, txscript.NewBaseTapLeaf(path.LeafScript), + txscript.SigHashDefault, receiver) + require.NoError(t, err) + witness, err := policy.SuccessWitness( + prior.TaprootAssetRoot, sig, preimage, + ) + if refund { + witness, err = policy.TimeoutWitness( + prior.TaprootAssetRoot, sig, + ) + } + require.NoError(t, err) + outcome.AnchorTx.TxIn[0].Witness = witness + outcome.BlockHeader.MerkleRoot = outcome.AnchorTx.TxHash() + chain := &bindingChain{tip: 161, unspent: true, + blocks: map[uint32]*wire.MsgBlock{ + 100: bindingBlock(deposit), 160: bindingBlock(outcome), + }} + + r := &proofNode{ + client: &bindingSDK{valid: true}, + chain: chain, + minConfs: 1, + } + d := swapkit.Deposit{Outpoint: deposit.OutPoint().String(), + Proof: bindingRaw( + t, + deposit, + ), Contract: contract, GroupKey: bindingPub(11), Amount: 1000} + s.Deposit, err = LoadDeposit(d, keychain.KeyLocator{}) + require.NoError(t, err) + require.NoError( + t, + VerifyDeposit( + t.Context(), + r.wallet(), + chain, + 1, + s.Deposit, + false, + ), + ) + + return r, s, outcome, chain +} + +func TestOutcomeRequiresExactSpendAndFreshRefund(t *testing.T) { + for _, refund := range []bool{false, true} { + name := "claim" + if refund { + name = "refund" + } + for _, mutation := range []string{testValid, testWrongSigner, + "wrong control", "other prevout", "other issuance", + "wrong recipient", "other group", "other amount", testReorg, + testSpentRefund} { + if mutation == testSpentRefund && !refund { + continue + } + t.Run(name+"/"+mutation, func(t *testing.T) { + testOutcomeBinding(t, refund, mutation) + }) + } + } +} + +func testOutcomeBinding(t *testing.T, refund bool, mutation string) { + t.Helper() + r, s, p, chain := bindingOutcome(t, refund) + switch mutation { + case testWrongSigner: + p.AnchorTx.TxIn[0].Witness[0][0] ^= 1 + case "wrong control": + w := p.AnchorTx.TxIn[0].Witness + w[len(w)-1][0] ^= 1 + case "other prevout": + p.AnchorTx.TxIn[0].PreviousOutPoint.Index++ + case "other issuance": + s.Fallback.Outputs[0].IssuanceID[0] ^= 1 + case "other group": + s.Fallback.Outputs[0].AssetRef = + sdk.AssetRefFromGroupKey(bindingPub(12)) + case "other amount": + s.Fallback.Outputs[0].Amount++ + case "wrong recipient": + old := p + p = bindingProof(t, bindingGenesis(), bindingKey(9).PubKey(), + bindingKey(9).PubKey(), nil, old.PrevOut, 160, false) + p.AnchorTx.TxIn[0].Sequence = old.AnchorTx.TxIn[0].Sequence + p.AnchorTx.TxIn[0].Witness = old.AnchorTx.TxIn[0].Witness + p.AnchorTx.LockTime = old.AnchorTx.LockTime + p.BlockHeader.MerkleRoot = p.AnchorTx.TxHash() + chain.blocks[160] = bindingBlock(p) + // The wrong recipient still has a coherent asset commitment and + // confirmed transaction. The contract gate must reject it. + _, err := verifyProof( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + bindingRaw(t, p), + s.Offer.Terms.GroupKey, + 1000, + refund, + ) + require.NoError(t, err) + case testReorg: + chain.blocks[160].Header.Nonce++ + case testSpentRefund: + chain.unspent = false + } + err := VerifyOutcome( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + s, + bindingRaw(t, p), + refund, + refund, + ) + if mutation == testValid { + require.NoError(t, err) + } else { + require.Error(t, err) + } +} + +func TestPersistedRefundProofRecheckedAfterReorg(t *testing.T) { + r, s, p, chain := bindingOutcome(t, true) + raw := bindingRaw(t, p) + require.NoError( + t, + VerifyOutcome( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + s, + raw, + true, + true, + ), + ) + stored := append([]byte(nil), raw...) + + // Persisting a proof does not freeze its current-chain validity. + chain.blocks[160].Header.Nonce++ + err := VerifyOutcome( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + s, + stored, + true, + true, + ) + require.ErrorIs(t, err, swapkit.ErrPending) +} + +func TestReorgClassificationPrecedesSDKVerification(t *testing.T) { + p := bindingProof(t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, bindingGenesis().FirstPrevOut, + 100, false) + chain := &bindingChain{tip: 101, unspent: true, + blocks: map[uint32]*wire.MsgBlock{100: bindingBlock(p)}} + r := &proofNode{ + client: &bindingSDK{valid: false}, + chain: chain, + minConfs: 1, + } + chain.blocks[100].Header.Nonce++ + _, err := verifyProof( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + bindingRaw(t, p), + bindingPub(11), + 1000, + true, + ) + require.ErrorIs(t, err, swapkit.ErrPending) + + // Restoring the chain match never bypasses full SDK verification. + chain.blocks[100].Header.Nonce-- + _, err = verifyProof( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + bindingRaw(t, p), + bindingPub(11), + 1000, + true, + ) + require.ErrorIs(t, err, swapkit.ErrInvalid) +} + // proofNode holds only test services. Tests call production primitives directly. type proofNode struct { client sdk.Client @@ -168,7 +565,6 @@ func (s *bindingSDK) GetInfo( } func fixtureNodeInfo() *sdk.Info { return &sdk.Info{Version: "0.8.8", Network: "regtest"} } - func fixtureVerified(raw []byte, valid bool) (*sdk.VerifyProofResponse, error) { p, err := LastProof(raw) if err != nil { diff --git a/swapkit/tapsdk/confirmation_test.go b/swapkit/tapsdk/confirmation_test.go new file mode 100644 index 000000000..25052a77d --- /dev/null +++ b/swapkit/tapsdk/confirmation_test.go @@ -0,0 +1,109 @@ +package tapsdk + +import ( + "os" + "testing" + + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +// scriptPackage loads the public SDK signing fixture. Only tests know the +// deterministic private key; production always uses the normal LND signer. +func scriptPackage(t *testing.T) *sdk.CustomAnchorTransferPackage { + t.Helper() + raw, err := os.ReadFile("testdata/script.package") + require.NoError(t, err) + var pkg sdk.CustomAnchorTransferPackage + require.NoError(t, pkg.UnmarshalBinary(raw)) + // The fixture has two independent key-path inputs. Complete those + // before exercising the production script signer. + requests, err := pkg.SigningRequests() + require.NoError(t, err) + result := &pkg + for i, request := range requests.KeyPath { + key := bindingKey([]byte{2, 9}[i]) + tweaked := txscript.TweakTaprootPrivKey(*key, + request.TaprootMerkleRoot) + signature, err := schnorr.Sign(tweaked, request.Sighash[:]) + require.NoError(t, err) + result, err = result.ApplyKeyPathSignature(request.ID, + signature.Serialize()) + require.NoError(t, err) + } + packet, err := DecodePSBT(result.AnchorPsbt) + require.NoError(t, err) + for _, request := range requests.KeyPath { + complete, err := psbt.MaybeFinalize( + packet, + int(request.InputIndex), + ) + require.NoError(t, err) + require.True(t, complete) + } + result.AnchorPsbt, err = EncodePSBT(packet) + require.NoError(t, err) + result, err = result.Seal() + require.NoError(t, err) + return result +} + +func TestOutcomeRelocationWithoutPeer(t *testing.T) { + for _, refund := range []bool{false, true} { + r, s, p, chain := bindingOutcome(t, refund) + old := bindingRaw(t, p) + require.NoError( + t, + VerifyOutcome( + t.Context(), + r.wallet(), + chain, + 1, + s, + old, + refund, + refund, + ), + ) + chain.blocks[160] = &wire.MsgBlock{ + Header: wire.BlockHeader{Nonce: 1}, + } + p.BlockHeight = 161 + p.BlockHeader.Nonce = 2 + chain.blocks[161] = bindingBlock(p) + chain.tip = 162 + fresh := bindingRaw(t, p) + require.NoError( + t, + VerifyOutcome( + t.Context(), + r.wallet(), + chain, + 1, + s, + fresh, + refund, + refund, + ), + ) + require.ErrorIs( + t, + VerifyOutcome( + t.Context(), + r.wallet(), + chain, + 1, + s, + old, + refund, + refund, + ), + swapkit.ErrPending, + ) + } +} diff --git a/swapkit/tapsdk/context.go b/swapkit/tapsdk/context.go new file mode 100644 index 000000000..0cffc29f0 --- /dev/null +++ b/swapkit/tapsdk/context.go @@ -0,0 +1,230 @@ +package tapsdk + +import ( + "bytes" + "context" + "math" + + "github.com/lightninglabs/lndclient" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightningnetwork/lnd/keychain" +) + +// DepositContract binds a public static deposit to its OP_TRUE asset output. +// +//nolint:tagliatelle // Preserve existing serialized contract field names. +type DepositContract struct { + Version uint32 `json:"Version"` + // #nosec G117 -- Both keys are public Bitcoin keys. + ClientKey [33]byte `json:"ClientKey"` + ServerKey [33]byte `json:"ServerKey"` + CSV uint32 `json:"CSV"` + Output sdk.CustomAnchorAssetOutputSummary `json:"Output"` +} + +// DepositContext is operation-local policy and proof material. It owns no +// services, lifecycle or persistence; the ordinary deposit/FSM owns the record. +type DepositContext struct { + Deposit swapkit.Deposit + Contract DepositContract + Proof *proof.Proof + Key keychain.KeyLocator +} + +// SwapContext is reconstructed from one ordinary Loop In record for an action. +// Generic proof validation belongs to the SDK; Loop checks negotiated policy. +type SwapContext struct { + Offer swapkit.Offer + Deposit *DepositContext + Fallback *sdk.CustomAnchorTransferPackage +} + +// LoadDeposit decodes the normal deposit record and its existing wallet key. +func LoadDeposit(d swapkit.Deposit, key keychain.KeyLocator) ( + *DepositContext, error) { + + var c DepositContract + if err := swapkit.Decode(d.Contract, &c); err != nil { + return nil, err + } + return &DepositContext{Deposit: d, Contract: c, Key: key}, nil +} + +// CheckKey checks that contract authority belongs to the daemon's normal key. +func CheckKey(ctx context.Context, walletKit lndclient.WalletKitClient, + loc keychain.KeyLocator, expected [33]byte) error { + + if loc.Index > math.MaxInt32 || loc.Family > math.MaxInt32 { + return swapkit.ErrInvalid + } + key, err := walletKit.DeriveKey(ctx, &loc) + if err != nil { + return err + } + if key == nil || key.PubKey == nil || key.KeyLocator != loc || + !bytes.Equal(key.PubKey.SerializeCompressed(), expected[:]) { + + return swapkit.ErrInvalid + } + return nil +} + +// DepositFromOffer binds the admitted deposit and registration to the server +// offer. The caller verifies its wallet key and on-chain proof before acting. +func DepositFromOffer(offer swapkit.Offer) (*DepositContext, error) { + t := offer.Terms + var a swapkit.Admission + if swapkit.Decode(t.Admission, &a) != nil || + a.Registration.Owner != t.Owner || a.RequestID != t.RequestID || + !sameGroupKeys(a.GroupKey[:], t.GroupKey[:]) || + !bytes.Equal(a.Contract, t.Contract) || + len(a.Deposits) != 1 || len(t.DepositOutpoints) != 1 || + a.Deposits[0].Outpoint != t.DepositOutpoints[0] || + a.RefundHeight != t.RefundHeight { + + return nil, swapkit.ErrInvalid + } + d := a.Deposits[0] + d.Contract = t.Contract + d.Amount, d.GroupKey = t.DepositAmount, t.GroupKey + record, err := LoadDeposit(d, keychain.KeyLocator{ + Family: keychain.KeyFamily(a.Registration.KeyFamily), + Index: a.Registration.KeyIndex}) + if err != nil { + return nil, err + } + c := record.Contract + if c.ClientKey != a.Registration.ClientKey || + c.ServerKey != a.Registration.ServerKey || c.CSV != a.Registration.CSV { + + return nil, swapkit.ErrInvalid + } + return record, nil +} + +// InspectDeposit checks Loop's contract and current chain before SDK Build +// verifies the input lineage. It does not authorize a spend by itself. +func InspectDeposit(ctx context.Context, chain Chain, minConfs uint32, + d *DepositContext, unspent bool) error { + + p, err := LastProof(d.Deposit.Proof) + if err != nil { + return err + } + if err := checkAsset(p, d.Deposit.GroupKey, d.Deposit.Amount); err != nil { + return err + } + if err := checkDepositContract(d.Deposit, d.Contract, p); err != nil { + return err + } + if err := checkConfirmation(ctx, chain, minConfs, p, unspent); err != nil { + return err + } + d.Proof = p + return nil +} + +// VerifyDeposit verifies a deposit outside a builder operation, retaining +// current-chain checks on both sides of the SDK proof verification RPC. +func VerifyDeposit(ctx context.Context, wallet *sdk.Wallet, chain Chain, + minConfs uint32, d *DepositContext, unspent bool) error { + + if err := checkProvenance(ctx, wallet, d.Deposit.Proof); err != nil { + return err + } + if err := InspectDeposit(ctx, chain, minConfs, d, unspent); err != nil { + return err + } + verified, err := wallet.Client().VerifyProof(ctx, d.Deposit.Proof) + if err != nil { + return err + } + if err := checkVerifiedSummary(verified, d.Proof); err != nil { + return err + } + return checkConfirmation(ctx, chain, minConfs, d.Proof, unspent) +} + +// NewSwap binds the offered policy and SDK fallback to a validated deposit. +func NewSwap(offer swapkit.Offer, d *DepositContext, unsigned []byte) ( + *SwapContext, error) { + + t := offer.Terms + if d == nil || d.Proof == nil || t.Version != 1 || + len( + t.DepositOutpoints, + ) != 1 || t.DepositAmount == 0 || t.ChangeAmount != 0 || + t.PayoutAmount > t.DepositAmount || + t.AssetFee != t.DepositAmount-t.PayoutAmount || + d.Deposit.Outpoint != t.DepositOutpoints[0] || + !bytes.Equal(d.Deposit.Contract, t.Contract) || + !sameGroupKeys(d.Deposit.GroupKey[:], t.GroupKey[:]) || + d.Deposit.Amount != t.DepositAmount || + uint64(d.Proof.BlockHeight)+uint64(d.Contract.CSV) <= + uint64(t.RefundHeight)+uint64(t.RecoveryDelta) { + + return nil, swapkit.ErrInvalid + } + s := &SwapContext{Offer: offer, Deposit: d} + if len(unsigned) > 0 { + var err error + s.Fallback, err = validateRecoveryPackage(offer, d, unsigned) + if err != nil { + return nil, err + } + } + return s, nil +} +func checkDepositContract(d swapkit.Deposit, c DepositContract, + p *proof.Proof) error { + + if p == nil || c.Version != 1 || c.Output.Amount != d.Amount || + p.Asset.LockTime != 0 || p.Asset.RelativeLockTime != 0 { + + return swapkit.ErrInvalid + } + group, grouped := c.Output.AssetRef.GroupKey() + if !grouped || !sameGroupKeys(group[:], d.GroupKey[:]) || + c.Output.IssuanceID != sdk.AssetID(p.Asset.ID()) || + c.Output.AssetType != sdk.AssetType(p.Asset.Genesis.Type) { + + return swapkit.ErrInvalid + } + assets, merkle, err := isolatedRoots(p) + if err != nil { + return err + } + previous := p.AnchorTx.TxOut[p.OutPoint().Index] + if p.OutPoint().String() != d.Outpoint || + SDKPoint(c.Output.AnchorOutpoint) != p.OutPoint() || + c.Output.TaprootAssetRoot != assets || + c.Output.TaprootMerkleRoot != merkle || + c.Output.AnchorValueSat != previous.Value || + !bytes.Equal(p.Asset.ScriptKey.PubKey.SerializeCompressed(), + c.Output.ScriptKey[:]) { + + return swapkit.ErrInvalid + } + dk, err := swapkit.NewDepositKit(swapkit.DepositKitParams{ + ClientKey: c.ClientKey, ServerKey: c.ServerKey, + CSVExpiry: c.CSV, + }) + if err != nil { + return err + } + spend, err := dk.TimeoutSpend(assets) + if err != nil { + return err + } + if !bytes.Equal(spend.PkScript, previous.PkScript) { + return swapkit.ErrInvalid + } + // Validate the exact asset witness, not just a caller's OP_TRUE label. + _, err = OPTrueSpendInfo(c.Output) + if err != nil { + return err + } + return nil +} diff --git a/swapkit/tapsdk/deposit_cache_test.go b/swapkit/tapsdk/deposit_cache_test.go index 96f270a68..bc5600440 100644 --- a/swapkit/tapsdk/deposit_cache_test.go +++ b/swapkit/tapsdk/deposit_cache_test.go @@ -1,14 +1,123 @@ package tapsdk import ( + "context" "testing" + "github.com/btcsuite/btcd/chaincfg/chainhash" "github.com/btcsuite/btcd/wire" "github.com/lightninglabs/loop/swapkit" sdk "github.com/lightninglabs/tap-sdk" "github.com/stretchr/testify/require" ) +type countedChain struct { + *bindingChain + + heights []uint32 +} + +func (c *countedChain) BlockHash(ctx context.Context, + height uint32) (chainhash.Hash, error) { + + c.heights = append(c.heights, height) + return c.bindingChain.BlockHash(ctx, height) +} + +// TestDepositInventoryRechecksConfirmation verifies that an old, spent deposit +// remains recognizable in normal inventory without a block-history scanner. +// A later action still rejects a reorganized confirmation. +func TestDepositInventoryRechecksConfirmation(t *testing.T) { + for _, reorg := range []bool{false, true} { + name := "current" + if reorg { + name = "reorganized" + } + t.Run(name, func(t *testing.T) { + r, swap, _, chain := bindingOutcome(t, false) + record := swap.Deposit + chain.tip, chain.unspent = 1_000_000, false + counted := &countedChain{bindingChain: chain} + r.chain = counted + if reorg { + chain.blocks[100].Header.Nonce++ + } + err := VerifyDeposit( + t.Context(), + r.wallet(), + counted, + 1, + record, + false, + ) + if reorg { + require.ErrorIs(t, err, swapkit.ErrPending) + } else { + require.NoError(t, err) + require.Equal(t, record.Deposit.Outpoint, + record.Proof.OutPoint().String()) + } + expected := []uint32{100, 100} + if reorg { + expected = expected[:1] + } + require.Equal(t, expected, counted.heights) + }) + } +} + +// countedProofSDK records externally verified lineages in one operation. +type countedProofSDK struct { + *bindingSDK + + proofs [][]byte +} + +func (s *countedProofSDK) VerifyProof(ctx context.Context, + raw []byte) (*sdk.VerifyProofResponse, error) { + + s.proofs = append(s.proofs, raw) + return s.bindingSDK.VerifyProof(ctx, raw) +} + +// TestRefundOperationVerifiesEachProofOnce checks reuse within an operation, +// while a fresh operation after restart must revalidate both lineages. +func TestRefundOperationVerifiesEachProofOnce(t *testing.T) { + r, swap, outcome, _ := originalRefundFixture(t) + client := &countedProofSDK{bindingSDK: &bindingSDK{valid: true}} + r.client = client + evidence := bindingRaw(t, outcome) + + for range 2 { + client.proofs = nil + require.NoError( + t, + VerifyDeposit( + t.Context(), + r.wallet(), + r.chain, + 1, + swap.Deposit, + false, + ), + ) + require.NoError( + t, + VerifyRefundOutcome( + t.Context(), + r.wallet(), + r.chain, + 1, + swap, + evidence, + ), + ) + require.Equal(t, [][]byte{ + swap.Deposit.Deposit.Proof, evidence, + }, client.proofs) + } +} + // TestSDKBuilderOwnsInputVerification covers the real SDK builder call. The // Loop checks on each side must not call verifyProof a second time, and the // post-build check rejects chain changes during the SDK verification RPC. diff --git a/swapkit/tapsdk/fallback.go b/swapkit/tapsdk/fallback.go new file mode 100644 index 000000000..b6b451d2c --- /dev/null +++ b/swapkit/tapsdk/fallback.go @@ -0,0 +1,152 @@ +package tapsdk + +import ( + "bytes" + "reflect" + + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" +) + +// HTLC constructs the existing V3 Bitcoin contract for the offered swap. +func HTLC(offer swapkit.Offer, c DepositContract) (*swapkit.SwapKit, error) { + return swapkit.NewSwapKit(swapkit.SwapKitParams{ + Policy: swapkit.SwapHTLCStaticLoopInV3, + SenderKey: c.ClientKey, ReceiverKey: c.ServerKey, + SenderInternalKey: c.ClientKey, + ReceiverInternalKey: c.ServerKey, + PaymentHash: offer.Hash, + Expiry: offer.Terms.RefundHeight, + }) +} + +// validateRecoveryPackage binds a native SDK transfer to the offered fallback. +func validateRecoveryPackage(offer swapkit.Offer, d *DepositContext, + raw []byte) (*sdk.CustomAnchorTransferPackage, error) { + + pkg, err := DecodePackage(raw) + if err != nil { + return nil, err + } + requests, err := pkg.SigningRequests() + if err != nil || len(requests.MuSig2) != 1 || + requests.MuSig2[0].SighashType != 0 { + + return nil, swapkit.ErrInvalid + } + if len(pkg.Inputs) != 1 || len(pkg.Outputs) != 1 || + len(pkg.PassiveVirtualPsbts) != 0 || + len(pkg.SigningPlans) != 1 || + len(pkg.BackendManagedInputIndices) != 0 { + + return nil, swapkit.ErrInvalid + } + c := d.Contract + in, out := pkg.Inputs[0], pkg.Outputs[0] + if !bytes.Equal(in.ProofSource.Blob, d.Deposit.Proof) || + in.AnchorOutpoint != c.Output.AnchorOutpoint || + in.ScriptKey != c.Output.ScriptKey || + in.Amount != c.Output.Amount || + out.Amount != in.Amount || out.IssuanceID != in.IssuanceID || + !out.AssetRef.Equivalent(c.Output.AssetRef) || + out.AnchorOutputIndex != 0 || out.AnchorValueSat < 330 { + + return nil, swapkit.ErrInvalid + } + packet, err := DecodePSBT(pkg.AnchorPsbt) + if err != nil { + return nil, err + } + tx := packet.UnsignedTx + fee := c.Output.AnchorValueSat - out.AnchorValueSat + if len(tx.TxIn) != 1 || len(tx.TxOut) != 1 || tx.Version != 2 || + tx.LockTime != 0 || tx.TxIn[0].Sequence != 0xfffffffc || + fee <= 0 || out.AnchorValueSat-330 < fee { + + return nil, swapkit.ErrInvalid + } + policy, err := HTLC(offer, c) + if err != nil { + return nil, err + } + spend, err := policy.TimeoutSpend(out.TaprootAssetRoot) + if err != nil { + return nil, err + } + if !bytes.Equal(spend.PkScript, tx.TxOut[0].PkScript) || + spend.TaprootMerkleRoot != out.TaprootMerkleRoot { + + return nil, swapkit.ErrInvalid + } + dk, err := swapkit.NewDepositKit(swapkit.DepositKitParams{ + ClientKey: c.ClientKey, ServerKey: c.ServerKey, + CSVExpiry: c.CSV, + }) + if err != nil { + return nil, err + } + signing := CooperativeSigningPlan( + dk.CooperativeParticipants(), 0, offer.Hash[:], + ) + if !reflect.DeepEqual(pkg.SigningPlans[0], signing) { + return nil, swapkit.ErrInvalid + } + if _, err := OPTrueSpendInfo(out); err != nil { + return nil, err + } + return pkg, nil +} + +// FallbackRequest constructs the unsigned SDK request for one validated offer. +func FallbackRequest(s *SwapContext, fee, maxFee uint64) ( + *sdk.CustomAnchorRequest, error) { + + d, offer := s.Deposit, s.Offer + c := d.Contract + policy, err := HTLC(offer, c) + if err != nil { + return nil, err + } + value := c.Output.AnchorValueSat - int64(fee) + if value < 330+int64(maxFee) { + return nil, swapkit.ErrInvalid + } + output, err := LegacyOPTrueOutput(sdk.CustomAssetOutput{ + ID: "HTLC", AssetRef: c.Output.AssetRef, + Amount: c.Output.Amount, AnchorValueSat: uint64(value), + }, policy.AnchorPlan()) + if err != nil { + return nil, err + } + p := d.Proof + anchor, err := AnchorTemplate(p, output.Anchor.InternalKey, value, nil) + if err != nil { + return nil, err + } + packet, err := DecodePSBT(anchor) + if err != nil { + return nil, err + } + dk, err := swapkit.NewDepositKit(swapkit.DepositKitParams{ + ClientKey: c.ClientKey, ServerKey: c.ServerKey, CSVExpiry: c.CSV, + }) + if err != nil { + return nil, err + } + internal := dk.AnchorPlan().InternalKey + packet.Inputs[0].TaprootInternalKey = internal[1:] + packet.Inputs[0].TaprootMerkleRoot = c.Output.TaprootMerkleRoot[:] + anchor, err = EncodePSBT(packet) + if err != nil { + return nil, err + } + input, err := AssetInput(c.Output, d.Deposit.Proof) + if err != nil { + return nil, err + } + plan := CustomRequest(input, + output, anchor, CooperativeSigningPlan( + dk.CooperativeParticipants(), 0, offer.Hash[:], + )) + return plan, nil +} diff --git a/swapkit/tapsdk/group_test.go b/swapkit/tapsdk/group_test.go index f39f12901..41dcd90e1 100644 --- a/swapkit/tapsdk/group_test.go +++ b/swapkit/tapsdk/group_test.go @@ -70,3 +70,32 @@ func TestVerifiedSummaryAcceptsGroupParity(t *testing.T) { response.DecodedProof.AssetRef = sdk.AssetRefFromGroupKey(bindingPub(12)) require.ErrorIs(t, checkVerifiedSummary(response, p), swapkit.ErrInvalid) } + +func TestDepositAndOfferAcceptGroupParity(t *testing.T) { + _, s, _, _ := bindingOutcome(t, false) + d := s.Deposit + p := d.Proof + contract := d.Contract + group, ok := contract.Output.AssetRef.GroupKey() + require.True(t, ok) + group[0] ^= 1 + contract.Output.AssetRef = sdk.AssetRefFromGroupKey(group) + require.NoError(t, checkDepositContract(d.Deposit, contract, p)) + s.Offer.Terms.GroupKey[0] ^= 1 + _, err := NewSwap(s.Offer, d, nil) + require.NoError(t, err) + + for _, relative := range []bool{false, true} { + changed := *p + changed.Asset = *p.Asset.Copy() + if relative { + changed.Asset.RelativeLockTime = 1 + } else { + changed.Asset.LockTime = 1 + } + require.ErrorIs(t, + checkDepositContract(d.Deposit, contract, &changed), + swapkit.ErrInvalid, + ) + } +} diff --git a/swapkit/tapsdk/native_package_regression_test.go b/swapkit/tapsdk/native_package_regression_test.go index 359322f49..0c9e7c519 100644 --- a/swapkit/tapsdk/native_package_regression_test.go +++ b/swapkit/tapsdk/native_package_regression_test.go @@ -2,13 +2,93 @@ package tapsdk import ( "bytes" + "context" "testing" "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" sdk "github.com/lightninglabs/tap-sdk" "github.com/stretchr/testify/require" ) +type changingProofSDK struct { + sdk.Client + + change func() + calls int +} + +func (s *changingProofSDK) VerifyProof(_ context.Context, + raw []byte) (*sdk.VerifyProofResponse, error) { + + s.calls++ + s.change() + return fixtureVerified(raw, true) +} + +// TestProofFreshnessAfterSDKVerification changes chain state while tapd is +// verifying the proof. Validation before that RPC cannot authorize a stale +// confirmation or an output that was spent before verification completed. +func TestProofFreshnessAfterSDKVerification(t *testing.T) { + for _, test := range []struct { + name string + change func(*bindingChain) + }{ + { + name: testReorg, + change: func(c *bindingChain) { + c.blocks[100].Header.Nonce++ + }, + }, + { + name: "lost confirmation depth", + change: func(c *bindingChain) { + c.tip = 100 + }, + }, + { + name: testSpentOutput, + change: func(c *bindingChain) { + c.unspent = false + }, + }, + } { + t.Run(test.name, func(t *testing.T) { + p := bindingProof(t, bindingGenesis(), + bindingKey(2).PubKey(), bindingKey(3).PubKey(), + nil, bindingGenesis().FirstPrevOut, 100, false) + chain := &bindingChain{ + tip: 101, unspent: true, + blocks: map[uint32]*wire.MsgBlock{ + 100: bindingBlock(p), + }, + } + client := &changingProofSDK{change: func() { + test.change(chain) + }} + node := &proofNode{ + client: client, + chain: chain, + minConfs: 2, + } + verified, err := verifyProof( + t.Context(), + node.wallet(), + node.chain, + node.minConfs, + bindingRaw(t, p), + bindingPub(11), + 1000, + true, + ) + require.ErrorIs(t, err, swapkit.ErrPending) + require.Nil(t, verified) + require.Equal(t, 1, client.calls) + }) + } +} + // nativeSignedFixture completes the public package using the existing LND // session fixture. Both packages retain the same committed transaction. func nativeSignedFixture(t *testing.T) (*sdk.CustomAnchorTransferPackage, @@ -126,3 +206,10 @@ func TestNativeClaimPackageRequiresFinalWitness(t *testing.T) { }) } } + +func (s *changingProofSDK) GetInfo( + context.Context, +) (*sdk.Info, error) { + + return fixtureNodeInfo(), nil +} diff --git a/swapkit/tapsdk/observed_refund_test.go b/swapkit/tapsdk/observed_refund_test.go new file mode 100644 index 000000000..b3e4e4abd --- /dev/null +++ b/swapkit/tapsdk/observed_refund_test.go @@ -0,0 +1,131 @@ +package tapsdk + +import ( + "context" + "errors" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/stretchr/testify/require" +) + +type observedRefundSDK struct { + *observedRecoverySDK + + backend *pathClient +} + +func (c *observedRefundSDK) CommitVirtualPsbtsWithRequest( + ctx context.Context, request *sdk.CommitVirtualPsbtsRequest) ( + *sdk.CommitVirtualPsbtsResponse, error) { + + return c.backend.CommitVirtualPsbtsWithRequest(ctx, request) +} + +// TestObservedCLTVRefundPreservesTransaction reconstructs a valid historical +// non-RBF refund after new refund templates have started opting into RBF. +func TestObservedCLTVRefundPreservesTransaction(t *testing.T) { + f := newPathFixture(t) + p, err := LastProof(f.request.Inputs[0].ProofFile) + require.NoError(t, err) + root, _, err := isolatedRoots(p) + require.NoError(t, err) + spend, err := f.kit.TimeoutSpend(root) + require.NoError(t, err) + require.EqualValues(t, 0xfffffffd, spend.Sequence) + + // Mint the fixture's same asset under the actual HTLC anchor policy. + plan := f.kit.AnchorPlan() + internal, err := btcec.ParsePubKey(plan.InternalKey[:]) + require.NoError(t, err) + branch := txscript.NewTapBranch( + txscript.NewBaseTapLeaf(plan.Leaves[0]), + txscript.NewBaseTapLeaf(plan.Leaves[1]), + ) + sibling := commitment.NewPreimageFromBranch(branch) + p.InclusionProof.InternalKey = internal + p.InclusionProof.CommitmentProof.TapSiblingPreimage = &sibling + p.AnchorTx.TxOut[0].PkScript = spend.PkScript + p.BlockHeader.MerkleRoot = p.AnchorTx.TxHash() + inputRaw, err := proof.EncodeAsProofFile(p) + require.NoError(t, err) + f.chain.blocks[p.BlockHeight] = bindingBlock(p) + point := sdk.Outpoint{Txid: sdk.Hash(p.OutPoint().Hash), + Index: p.OutPoint().Index} + _, optrue, err := LegacyOPTrueDescriptor() + require.NoError(t, err) + prior := sdk.CustomAnchorAssetOutputSummary{ + LogicalOutputID: "observed refund", + AssetRef: f.request.Inputs[0].AssetRef, + IssuanceID: sdk.AssetID(p.Asset.ID()), + Amount: p.Asset.Amount, ScriptKey: f.binding.ScriptKey, + OPTrueSpend: optrue, TaprootAssetRoot: root, + TaprootMerkleRoot: spend.TaprootMerkleRoot, + AnchorValueSat: p.AnchorTx.TxOut[0].Value, + AnchorOutpoint: point, + } + client := &observedRefundSDK{ + observedRecoverySDK: &observedRecoverySDK{ + partialRecoverySDK: &partialRecoverySDK{ + bindingSDK: &bindingSDK{valid: true}, + }, + input: &sdk.ProofFile{RawProofFile: inputRaw}, + point: point, stopErr: errors.New("reached observer log"), + }, + backend: f.client, + } + wallet := sdk.NewWallet(client, sdk.NetworkRegtest) + public := bindingPub(1) + recipient, err := walletOutput(public, 0, 0, + prior.AssetRef, prior.Amount, 900) + require.NoError(t, err) + anchor, err := AnchorTemplate(p, recipient.Anchor.InternalKey, 900, spend) + require.NoError(t, err) + packet, err := DecodePSBT(anchor) + require.NoError(t, err) + packet.UnsignedTx.LockTime = spend.LockTime + 1 + packet.UnsignedTx.TxIn[0].Sequence = wire.MaxTxInSequenceNum - 1 + anchor, err = EncodePSBT(packet) + require.NoError(t, err) + input, err := AssetInput(prior, inputRaw) + require.NoError(t, err) + pkg, err := commit(t.Context(), wallet, f.chain, 1, + CustomRequest(input, recipient, anchor, ScriptSigningPlan(spend, 0))) + require.NoError(t, err) + requests, err := pkg.SigningRequests() + require.NoError(t, err) + require.Len(t, requests.ScriptPath, 1) + signature, err := schnorr.Sign( + bindingKey(1), requests.ScriptPath[0].Sighash[:], + ) + require.NoError(t, err) + final, err := pkg.ApplyScriptPathWitness(requests.ScriptPath[0].ID, + [][]byte{signature.Serialize()}) + require.NoError(t, err) + packet, err = DecodePSBT(final.AnchorPsbt) + require.NoError(t, err) + observed, err := psbt.Extract(packet) + require.NoError(t, err) + + _, err = rebuildObservedSpend(t.Context(), wallet, f.chain, 1, + prior, inputRaw, public, spend, observed) + require.ErrorIs(t, err, client.stopErr) + require.NotNil(t, client.logged) + require.True(t, client.logged.SkipAnchorTxBroadcast) + logged, err := DecodePSBT(client.logged.AnchorPsbt) + require.NoError(t, err) + recovered, err := psbt.Extract(logged) + require.NoError(t, err) + require.Equal(t, observed.TxHash(), recovered.TxHash()) + require.Equal(t, observed.LockTime, recovered.LockTime) + require.Equal(t, observed.Version, recovered.Version) + require.EqualValues(t, 0xfffffffe, recovered.TxIn[0].Sequence) + require.Equal(t, observed.TxIn[0].Witness, recovered.TxIn[0].Witness) +} diff --git a/swapkit/tapsdk/original_refund.go b/swapkit/tapsdk/original_refund.go new file mode 100644 index 000000000..3ed2e141e --- /dev/null +++ b/swapkit/tapsdk/original_refund.go @@ -0,0 +1,110 @@ +package tapsdk + +import ( + "context" + "math" + + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" +) + +// OriginalRefundPolicy selects the original deposit's unilateral CSV leaf. +func OriginalRefundPolicy(d *DepositContext) (DepositContract, + *swapkit.SwapAnchorSpendInfo, error) { + + c := d.Contract + policy, err := swapkit.NewDepositKit(swapkit.DepositKitParams{ + ClientKey: c.ClientKey, ServerKey: c.ServerKey, + CSVExpiry: c.CSV, + }) + if err != nil { + return c, nil, err + } + spend, err := policy.TimeoutSpend(c.Output.TaprootAssetRoot) + return c, spend, err +} + +// verifyOriginalRefund verifies the original deposit's CSV recovery proof. +func verifyOriginalRefund(ctx context.Context, wallet *sdk.Wallet, + chain Chain, minConfs uint32, + s *SwapContext, raw []byte, requireUnspent bool) error { + + d := s.Deposit + base := d.Proof + c, spend, err := OriginalRefundPolicy(d) + if err != nil { + return err + } + err = VerifyWalletSpend( + ctx, wallet, chain, minConfs, raw, c.Output, c.ClientKey, + spend, requireUnspent, uint64(base.BlockHeight)+uint64(c.CSV), + ) + return err +} + +// DiscoverOriginalRefund reconstructs an offline client's CSV recovery proof. +func DiscoverOriginalRefund(ctx context.Context, wallet *sdk.Wallet, + chain Chain, minConfs uint32, + s *SwapContext) ([]byte, error) { + + d := s.Deposit + base := d.Proof + c, spend, err := OriginalRefundPolicy(d) + if err != nil { + return nil, err + } + start := uint64(base.BlockHeight) + uint64(c.CSV) + if start > math.MaxUint32 { + return nil, swapkit.ErrInvalid + } + block, _, err := chain.Spend( + ctx, + base.OutPoint(), + base.AnchorTx.TxOut[base.OutPoint().Index].PkScript, + uint32(start), + ) + if err != nil { + return nil, err + } + tx := spendingTransaction(block, base.OutPoint()) + if len(tx.TxIn) != 1 || len(tx.TxOut) != 1 { + return nil, swapkit.ErrPending + } + if !spendsLeaf(tx, c.Output, spend) { + return nil, swapkit.ErrPending + } + raw, err := rebuildObservedSpend( + ctx, wallet, chain, minConfs, c.Output, d.Deposit.Proof, + c.ClientKey, spend, tx, + ) + if err != nil { + return nil, err + } + return raw, nil +} + +// VerifyRefundOutcome recognizes either refund after it is spent again. +// A later wallet spend cannot restore the server's expired claim authority. +func VerifyRefundOutcome(ctx context.Context, wallet *sdk.Wallet, + chain Chain, minConfs uint32, s *SwapContext, + raw []byte) error { + + p, err := LastProof(raw) + if err != nil { + return err + } + if len(p.AnchorTx.TxIn) == 1 && p.AnchorTx.TxIn[0].PreviousOutPoint == + s.Deposit.Proof.OutPoint() { + + return verifyOriginalRefund( + ctx, + wallet, + chain, + minConfs, + s, + raw, + false, + ) + } + return VerifyOutcome(ctx, wallet, chain, minConfs, s, raw, true, false) +} diff --git a/swapkit/tapsdk/original_refund_test.go b/swapkit/tapsdk/original_refund_test.go new file mode 100644 index 000000000..4065ceda5 --- /dev/null +++ b/swapkit/tapsdk/original_refund_test.go @@ -0,0 +1,170 @@ +package tapsdk + +import ( + "encoding/json" + "testing" + + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/txscript" + "github.com/lightninglabs/loop/swapkit" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/stretchr/testify/require" +) + +func originalRefundFixture(t *testing.T) (*proofNode, *SwapContext, + *proof.Proof, *bindingChain) { + + t.Helper() + r, s, _, chain := bindingOutcome(t, true) + // The server never obtained the client's completed fallback. + s.Fallback = nil + d := s.Deposit + base, err := LastProof(d.Deposit.Proof) + require.NoError(t, err) + _, spend, err := OriginalRefundPolicy(d) + require.NoError(t, err) + key := bindingKey(2) + output := txscript.ComputeTaprootKeyNoScript(key.PubKey()) + output, err = schnorr.ParsePubKey(schnorr.SerializePubKey(output)) + require.NoError(t, err) + p := bindingProof(t, bindingGenesis(), output, key.PubKey(), + nil, base.OutPoint(), 201, false) + p.AnchorTx.TxIn[0].Sequence = spend.Sequence + p.AnchorTx.LockTime = spend.LockTime + p.AnchorTx.TxOut[0].Value = 9000 + fetch := txscript.NewCannedPrevOutputFetcher(spend.PkScript, 10_000) + sig, err := txscript.RawTxInTapscriptSignature(&p.AnchorTx, + txscript.NewTxSigHashes(&p.AnchorTx, fetch), 0, 10_000, + spend.PkScript, txscript.NewBaseTapLeaf(spend.LeafScript), + txscript.SigHashDefault, key) + require.NoError(t, err) + p.AnchorTx.TxIn[0].Witness = [][]byte{ + sig, spend.LeafScript, spend.ControlBlock, + } + p.BlockHeader.MerkleRoot = p.AnchorTx.TxHash() + chain.tip, chain.blocks[201] = 202, bindingBlock(p) + return r, s, p, chain +} + +func TestOriginalCSVRefundWithoutCompletedFallback(t *testing.T) { + r, s, p, chain := originalRefundFixture(t) + raw := bindingRaw(t, p) + require.NoError( + t, + VerifyRefundOutcome(t.Context(), r.wallet(), chain, 1, s, raw), + ) + require.Nil(t, s.Fallback) + chain.blocks[201].Header.Nonce++ + require.ErrorIs( + t, + VerifyRefundOutcome(t.Context(), r.wallet(), chain, 1, s, raw), + swapkit.ErrPending, + ) +} + +func TestOriginalRefundRejectsWrongSpend(t *testing.T) { + for _, name := range []string{testWrongSigner, "wrong prevout", + "wrong leaf", testSpentOutput, "too early"} { + t.Run(name, func(t *testing.T) { + r, s, p, chain := originalRefundFixture(t) + input := p.AnchorTx.TxIn[0] + switch name { + case testWrongSigner: + input.Witness[0][0] ^= 1 + case "wrong prevout": + input.PreviousOutPoint.Index++ + case "wrong leaf": + input.Witness[1][0] ^= 1 + case testSpentOutput: + chain.unspent = false + case "too early": + p.BlockHeight = 199 + chain.blocks[199] = bindingBlock(p) + } + err := verifyOriginalRefund( + t.Context(), + r.wallet(), + r.chain, + 1, + s, + bindingRaw(t, p), + true, + ) + require.Error(t, err) + }) + } +} + +func TestDepositContractRejectsIdentitySubstitution(t *testing.T) { + _, s, _, _ := bindingOutcome(t, false) + d := s.Deposit + for _, mutate := range []func(*DepositContract){ + func(c *DepositContract) { c.Output.IssuanceID[0] ^= 1 }, + func(c *DepositContract) { c.Output.AssetType++ }, + func(c *DepositContract) { c.Output.Amount++ }, + } { + var c DepositContract + // Preserve the existing SDK/contract JSON field names. + //nolint:musttag + require.NoError(t, json.Unmarshal(d.Deposit.Contract, &c)) + mutate(&c) + err := checkDepositContract(d.Deposit, c, d.Proof) + require.ErrorIs(t, err, swapkit.ErrInvalid) + } +} + +func TestServerCanReconcileSpentRefundButClientNeedsSpendability(t *testing.T) { + for _, original := range []bool{false, true} { + name := "HTLC" + if original { + name = "original deposit" + } + t.Run(name, func(t *testing.T) { + var r *proofNode + var s *SwapContext + var p *proof.Proof + var chain *bindingChain + if original { + r, s, p, chain = originalRefundFixture(t) + } else { + r, s, p, chain = bindingOutcome(t, true) + } + raw := bindingRaw(t, p) + chain.unspent = false + err := VerifyRefundOutcome( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + s, + raw, + ) + require.NoError(t, err) + if original { + err = verifyOriginalRefund( + t.Context(), + r.wallet(), + r.chain, + 1, + s, + raw, + true, + ) + } else { + err = VerifyOutcome(t.Context(), r.wallet(), r.chain, r.minConfs, s, raw, true, true) + } + require.ErrorIs(t, err, swapkit.ErrPending) + + chain.blocks[p.BlockHeight].Header.Nonce++ + err = VerifyRefundOutcome( + t.Context(), + r.wallet(), + r.chain, + r.minConfs, + s, + raw, + ) + require.ErrorIs(t, err, swapkit.ErrPending) + }) + } +} diff --git a/swapkit/tapsdk/output_key_test.go b/swapkit/tapsdk/output_key_test.go new file mode 100644 index 000000000..28f6532c5 --- /dev/null +++ b/swapkit/tapsdk/output_key_test.go @@ -0,0 +1,79 @@ +package tapsdk + +import ( + "context" + "testing" + + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +type declaredOutputClient struct { + sdk.Client + + key sdk.ScriptKey +} + +func (c *declaredOutputClient) DeclareScriptKey(_ context.Context, + request *sdk.DeclareScriptKeyRequest) (*sdk.ScriptKey, error) { + + c.key = request.ScriptKey + return &c.key, nil +} + +// TestDeclareOutputPreservesKey checks that declaring the native OP_TRUE output +// retains both compressed-key parity and the wallet locator. In particular, an +// even key must not be first registered with the control block's zero locator: +// tapd retains that first derivation when the same key later receives a refund. +func TestDeclareOutputPreservesKey(t *testing.T) { + for name, scalar := range map[string]byte{testEven: 1, "odd": 6} { + t.Run(name, func(t *testing.T) { + fixture := newCustomAnchorBuilderFixture(t) + kit, err := swapkit.NewSwapKit(swapKitTestParams(t)) + require.NoError(t, err) + key := sdk.KeyDescriptor{ + RawKeyBytes: testKey(t, scalar), + KeyLocator: sdk.KeyLocator{ + Family: 42060, Index: 7, + }, + } + if name == testEven { + require.Equal(t, byte(2), key.RawKeyBytes[0]) + } else { + require.Equal(t, byte(3), key.RawKeyBytes[0]) + } + fixture.request.Outputs[0] = OPTrueOutput( + fixture.request.Outputs[0], + key, + kit.AnchorPlan(), + ) + wallet := sdk.NewWallet( + fixture.client, + sdk.NetworkRegtest, + ) + plan, err := wallet.NewCustomAnchorTxBuilder().Build( + t.Context(), fixture.request, + ) + require.NoError(t, err) + out := plan.Outputs()[0] + pkg := &sdk.CustomAnchorTransferPackage{ + ActiveVirtualPsbts: plan.ActiveVirtualPSBTs(), + } + client := &declaredOutputClient{} + wallet = sdk.NewWallet(client, sdk.NetworkRegtest) + require.NoError( + t, + declareOutput(t.Context(), wallet, pkg, + sdk.CustomAnchorAssetOutputSummary{ + PacketIndex: out.PacketIndex, + VirtualOutputIndex: out.VirtualOutputIndex, + ScriptKey: out.ScriptKey, + }), + ) + require.Equal(t, key, client.key.KeyDesc) + require.Equal(t, out.ScriptKey, client.key.PubKey) + require.Len(t, client.key.TapTweak, 32) + }) + } +} diff --git a/swapkit/tapsdk/partial_recovery_test.go b/swapkit/tapsdk/partial_recovery_test.go new file mode 100644 index 000000000..b2c744c23 --- /dev/null +++ b/swapkit/tapsdk/partial_recovery_test.go @@ -0,0 +1,262 @@ +package tapsdk + +import ( + "context" + "encoding/json" + "errors" + "testing" + + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +type partialRecoveryChain struct { + *bindingChain + + spend func(wire.OutPoint) (*wire.MsgBlock, uint32, error) +} + +func (c *partialRecoveryChain) Spend(_ context.Context, point wire.OutPoint, + _ []byte, _ uint32) (*wire.MsgBlock, uint32, error) { + + return c.spend(point) +} + +type partialRecoverySDK struct { + *bindingSDK + + declared error +} + +func (s *partialRecoverySDK) DeclareScriptKey(context.Context, + *sdk.DeclareScriptKeyRequest) (*sdk.ScriptKey, error) { + + return nil, s.declared +} + +// TestPartialFallbackRecoveryDiscovery checks the server can discover either +// refund path with only the unsigned fallback saved. The marker stops at the +// proof reconstruction boundary; native tests cover the actual tapd archive. +func TestPartialFallbackRecoveryDiscovery(t *testing.T) { + for _, original := range []bool{false, true} { + name := "HTLC refund" + if original { + name = "original deposit refund" + } + t.Run(name, func(t *testing.T) { + node, swap, outcome, chain := bindingOutcome(t, true) + if original { + node, swap, outcome, chain = + originalRefundFixture(t) + } + deposit := swap.Deposit + base, err := LastProof(deposit.Deposit.Proof) + require.NoError(t, err) + + // The persisted public package fixes the anchor even + // though no completed Bitcoin witness was received. + anchor := wire.NewMsgTx(2) + point := base.OutPoint() + anchor.AddTxIn(wire.NewTxIn(&point, nil, nil)) + anchor.AddTxOut(wire.NewTxOut(9000, []byte{0x51})) + packet, err := psbt.NewFromUnsignedTx(anchor) + require.NoError(t, err) + raw, err := EncodePSBT(packet) + require.NoError(t, err) + if original { + swap.Fallback = + &sdk.CustomAnchorTransferPackage{ + Outputs: []sdk.CustomAnchorAssetOutputSummary{ + { + AnchorOutpoint: sdk.Outpoint{ + Txid: sdk.Hash( + anchor.TxHash(), + ), + }, + }, + }, + } + } + swap.Fallback.AnchorPsbt = raw + prior := &swap.Fallback.Outputs[0] + prior.AnchorOutpoint.Txid = sdk.Hash(anchor.TxHash()) + htlcPoint := SDKPoint(prior.AnchorOutpoint) + if !original { + outcome.AnchorTx.TxIn[0].PreviousOutPoint = htlcPoint + } + marker := errors.New("reached proof reconstruction") + node.client = &partialRecoverySDK{ + bindingSDK: &bindingSDK{valid: true}, + declared: marker, + } + var watched []wire.OutPoint + node.chain = &partialRecoveryChain{ + bindingChain: chain, + spend: func(point wire.OutPoint) ( + *wire.MsgBlock, uint32, error) { + + watched = append(watched, point) + if original && point == htlcPoint { + return nil, 0, swapkit.ErrPending + } + return bindingBlock(outcome), + outcome.BlockHeight, nil + }, + } + // Each invocation reuses only the current operation's data. + _, err = DiscoverOutcome( + t.Context(), + node.wallet(), + node.chain, + node.minConfs, + swap, + true, + ) + if original { + require.ErrorIs(t, err, swapkit.ErrPending) + _, err = DiscoverOriginalRefund( + t.Context(), + node.wallet(), + node.chain, + node.minConfs, + swap, + ) + require.Equal(t, []wire.OutPoint{ + htlcPoint, base.OutPoint(), + }, watched) + } else { + require.Equal(t, []wire.OutPoint{ + htlcPoint, + }, watched) + } + require.ErrorIs(t, err, marker) + }) + } +} + +// observedRecoverySDK records the exact tapd logging request, then stops before +// proof reconstruction, which is covered by the real-node tests. +type observedRecoverySDK struct { + *partialRecoverySDK + sdk.CustomAnchorWalletKitClient + + input *sdk.ProofFile + point sdk.Outpoint + logged *sdk.PublishAndLogTransferRequest + stopErr error + + transfers []*sdk.AssetTransfer + transfersErr error + lookups []string +} + +// ListTransfers returns the stubbed transfer log and records each anchor +// filter, like tapd's lookup of already logged publications. +func (s *observedRecoverySDK) ListTransfers(_ context.Context, + request *sdk.ListTransfersRequest) ([]*sdk.AssetTransfer, error) { + + s.lookups = append(s.lookups, request.AnchorTxid) + return s.transfers, s.transfersErr +} + +func (s *observedRecoverySDK) ExportProof(_ context.Context, _ sdk.AssetRef, + _ sdk.PubKey, point *sdk.Outpoint) (*sdk.ProofFile, error) { + + if point != nil && *point == s.point { + return s.input, nil + } + return nil, errors.New("proof not yet logged") +} + +func (*observedRecoverySDK) CustomAnchorCapabilities(context.Context) ( + *sdk.CustomAnchorCapabilities, error) { + + capabilities := sdk.DefaultTapdCustomAnchorCapabilities() + return &capabilities, nil +} + +func (s *observedRecoverySDK) PublishAndLogTransferWithRequest( + _ context.Context, request *sdk.PublishAndLogTransferRequest) ( + *sdk.AssetPacket, error) { + + s.logged = request + return nil, s.stopErr +} + +// TestObservedSignedFallbackDoesNotRebroadcast exercises the discovery path +// used by InspectRefund when a server restarts after its peer's refund mined. +// Even a complete signed fallback must use observer logging for its lineage. +func TestObservedSignedFallbackDoesNotRebroadcast(t *testing.T) { + node, swap, outcome, chain := bindingOutcome(t, true) + pkg := signingPackage(t) + pkg.Publish.SkipAnchorTxBroadcast = false + pkg.Publish.ExternalBroadcast = false + pkg, err := pkg.Seal() + require.NoError(t, err) + signed, err := signTestPackage( + t.Context(), + signingWallet(t, 2), + signingWallet(t, 3), + pkg, + ) + require.NoError(t, err) + fallback, err := pkg.WithFinalAnchorPSBT( + finishSigningFixture(t, signed), + ) + require.NoError(t, err) + swap.Fallback = fallback + + // Reuse the existing package's fully signed anchor. The chain stub + // reports the agreed timeout leaf spending that anchor's asset output. + prior := fallback.Outputs[0] + var contract DepositContract + // Preserve the existing SDK/contract JSON field names. + //nolint:musttag + require.NoError(t, json.Unmarshal(swap.Offer.Terms.Contract, &contract)) + policy, err := HTLC(swap.Offer, contract) + require.NoError(t, err) + spend, err := policy.TimeoutSpend(prior.TaprootAssetRoot) + require.NoError(t, err) + point := SDKPoint(prior.AnchorOutpoint) + outcome.AnchorTx.TxIn[0].PreviousOutPoint = point + outcome.AnchorTx.TxIn[0].Witness = [][]byte{ + make([]byte, 64), spend.LeafScript, spend.ControlBlock, + } + node.chain = &partialRecoveryChain{ + bindingChain: chain, + spend: func(actual wire.OutPoint) (*wire.MsgBlock, uint32, error) { + require.Equal(t, point, actual) + return bindingBlock(outcome), outcome.BlockHeight, nil + }, + } + + inputRaw := fallback.Inputs[0].ProofSource.Blob + inputProof, err := LastProof(inputRaw) + require.NoError(t, err) + client := &observedRecoverySDK{ + partialRecoverySDK: &partialRecoverySDK{ + bindingSDK: &bindingSDK{valid: true}, + }, + input: &sdk.ProofFile{RawProofFile: inputRaw}, + point: sdk.Outpoint{Txid: sdk.Hash(inputProof.OutPoint().Hash), + Index: inputProof.OutPoint().Index}, + stopErr: errors.New("reached observer log"), + } + node.client = client + _, err = DiscoverOutcome( + t.Context(), + node.wallet(), + node.chain, + node.minConfs, + swap, + true, + ) + require.ErrorIs(t, err, client.stopErr) + require.NotNil(t, client.logged) + require.True(t, client.logged.SkipAnchorTxBroadcast) + // Logging flags belong to this observation, not the persisted package. + require.False(t, fallback.Publish.SkipAnchorTxBroadcast) +} diff --git a/swapkit/tapsdk/proof_archive_test.go b/swapkit/tapsdk/proof_archive_test.go new file mode 100644 index 000000000..5a09f8405 --- /dev/null +++ b/swapkit/tapsdk/proof_archive_test.go @@ -0,0 +1,94 @@ +package tapsdk + +import ( + "context" + "errors" + "testing" + + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +type archiveSDK struct { + sdk.Client + + file *sdk.ProofFile + exportErr error + importErr error + imports int + ref sdk.AssetRef + key sdk.PubKey + point sdk.Outpoint +} + +func (a *archiveSDK) ExportProof(_ context.Context, ref sdk.AssetRef, + key sdk.PubKey, point *sdk.Outpoint) (*sdk.ProofFile, error) { + + a.ref, a.key, a.point = ref, key, *point + return a.file, a.exportErr +} + +func (a *archiveSDK) UnpackProofFile(context.Context, []byte) ( + [][]byte, error) { + + a.imports++ + return nil, a.importErr +} + +func TestProofArchiveRetryUsesExactOutput(t *testing.T) { + p := bindingProof(t, bindingGenesis(), bindingKey(2).PubKey(), + bindingKey(3).PubKey(), nil, bindingGenesis().FirstPrevOut, + 100, false) + raw := bindingRaw(t, p) + client := &archiveSDK{file: &sdk.ProofFile{RawProofFile: raw}} + wallet := sdk.NewWallet(client, sdk.NetworkRegtest) + for range 2 { + require.NoError(t, importProof(t.Context(), wallet, raw)) + } + require.Zero(t, client.imports) + require.Equal(t, sdk.AssetRefFromAssetID(sdk.AssetID(p.Asset.ID())), + client.ref) + require.Equal(t, sdk.Outpoint{Txid: sdk.Hash(p.OutPoint().Hash), + Index: p.OutPoint().Index}, client.point) + require.Equal(t, bindingPub(2), [33]byte(client.key)) + + // A returned proof for another output must not authorize a skipped + // import, even when the backend reused the same asset script key. + p.AnchorTx.TxIn[0].PreviousOutPoint.Index++ + client.file = &sdk.ProofFile{RawProofFile: bindingRaw(t, p)} + require.ErrorIs( + t, + importProof(t.Context(), wallet, raw), + swapkit.ErrInvalid, + ) + require.Zero(t, client.imports) + + // A missing archive entry still requires a successful import; an + // ambiguous import response is retried through the archive next time. + lost := errors.New("lost import response") + client.exportErr, client.importErr = errors.New("not found"), lost + require.ErrorIs(t, importProof(t.Context(), wallet, raw), lost) + require.Equal(t, 1, client.imports) + client.exportErr = nil + client.file = &sdk.ProofFile{RawProofFile: raw} + require.NoError(t, importProof(t.Context(), wallet, raw)) + require.Equal(t, 1, client.imports) +} + +func TestConfirmedNativeSourceArchiveHandoff(t *testing.T) { + fixture := newCustomAnchorBuilderFixture(t) + raw := fixture.request.Inputs[0].ProofFile + path := sdk.AssetProofPath{ConfirmedBaseProof: raw} + blob, err := path.MarshalBinary() + require.NoError(t, err) + decoded, err := confirmedInputProof(sdk.CustomAnchorProofSourceSummary{ + Kind: sdk.CustomAnchorProofSourceCompactPath, Blob: blob, + }) + require.NoError(t, err) + require.Equal(t, raw, decoded) + decoded[0] ^= 1 + require.NotEqual(t, raw, decoded) + _, err = confirmedInputProof(sdk.CustomAnchorProofSourceSummary{}) + require.ErrorIs(t, err, swapkit.ErrInvalid) +} diff --git a/swapkit/tapsdk/proofs.go b/swapkit/tapsdk/proofs.go index 6522d3307..cf0008931 100644 --- a/swapkit/tapsdk/proofs.go +++ b/swapkit/tapsdk/proofs.go @@ -14,6 +14,7 @@ import ( sdk "github.com/lightninglabs/tap-sdk" "github.com/lightninglabs/taproot-assets/commitment" "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/tappsbt" ) // LastProof decodes the final transition in a native asset proof file. @@ -85,6 +86,42 @@ func commitmentRoots( return sdk.Hash(assets), sdk.Hash(root), nil } +// verifyProof checks Loop policy and SDK lineage between current-chain checks. +func verifyProof(ctx context.Context, wallet *sdk.Wallet, + chain Chain, minConfs uint32, raw []byte, + group [33]byte, amount uint64, unspent bool) (*proof.Proof, error) { + + if err := CheckNodeVersion(ctx, wallet); err != nil { + return nil, err + } + if err := checkProvenance(ctx, wallet, raw); err != nil { + return nil, err + } + p, err := inspectProof( + ctx, + chain, + minConfs, + raw, + group, + amount, + unspent, + ) + if err != nil { + return nil, err + } + verified, err := wallet.Client().VerifyProof(ctx, raw) + if err != nil { + return nil, err + } + if err := checkVerifiedSummary(verified, p); err != nil { + return nil, err + } + if err := checkConfirmation(ctx, chain, minConfs, p, unspent); err != nil { + return nil, err + } + return p, nil +} + // checkConfirmation requires current-chain inclusion and optional spendability. func checkConfirmation(ctx context.Context, chain Chain, minConfs uint32, p *proof.Proof, @@ -186,6 +223,185 @@ func BindFinalPackage(approved *sdk.CustomAnchorTransferPackage, return approved.WithFinalAnchorPSBT(proposed.AnchorPsbt) } +// LogAndExport publishes or records an observed transfer through tapd and +// returns its exact output proof once the confirmation is current. tapd logs +// every publication request as a new transfer, so a retry must not log again. +// An archived exact proof returns its own confirmation result, and an anchor +// that tapd already logged returns ErrPending. The lookup and the publication +// are not atomic; the caller serializes invocations for one package. +func LogAndExport(ctx context.Context, wallet *sdk.Wallet, + chain Chain, minConfs uint32, + pkg *sdk.CustomAnchorTransferPackage, observed bool) ([]byte, error) { + + if err := CheckNodeVersion(ctx, wallet); err != nil { + return nil, err + } + if err := CheckSigningPolicy(pkg); err != nil { + return nil, err + } + if len(pkg.Inputs) != 1 || len(pkg.Outputs) != 1 || + len(pkg.ProofUpdates) != 1 { + + return nil, swapkit.ErrInvalid + } + out := pkg.Outputs[0] + // The second result reports that tapd archived the exact output proof, + // which it only does for a transfer it has already logged. + export := func() ([]byte, bool, error) { + file, err := wallet.ExportProofFile(ctx, + sdk.AssetRefFromAssetID(out.IssuanceID), out.ScriptKey, + &out.AnchorOutpoint) + if err != nil { + return nil, false, err + } + if file == nil { + return nil, false, swapkit.ErrInvalid + } + p, err := LastProof(file.RawProofFile) + if err != nil { + return nil, false, err + } + if sdk.AssetID(p.Asset.ID()) != out.IssuanceID || + p.OutPoint() != SDKPoint(out.AnchorOutpoint) || + !bytes.Equal( + p.Asset.ScriptKey.PubKey.SerializeCompressed(), + out.ScriptKey[:], + ) { + + return nil, false, swapkit.ErrInvalid + } + // The caller verifies the proof with its contract exactly once. + // Here a current confirmation distinguishes archive lag from success. + err = checkConfirmation(ctx, chain, minConfs, p, false) + if err != nil { + return nil, true, err + } + return file.RawProofFile, true, nil + } + raw, archived, err := export() + if err == nil { + return raw, nil + } + // Only the confirmation of the archived proof is outstanding. Report it + // instead of logging the same transfer again. + if archived { + return nil, err + } + // tapd archives the proof only after the anchor confirms, so an earlier + // invocation may already have logged this transfer. + logged, err := anchorLogged(ctx, wallet, out.AnchorOutpoint) + if err != nil { + return nil, err + } + if logged { + return nil, swapkit.ErrPending + } + if _, err := OPTrueSpendInfo(out); err == nil { + if err := declareOutput(ctx, wallet, pkg, out); err != nil { + return nil, err + } + } + rawInput, err := confirmedInputProof(pkg.Inputs[0].ProofSource) + if err != nil { + return nil, err + } + err = importProof(ctx, wallet, rawInput) + if err != nil { + return nil, err + } + if observed { + pkg = pkg.Clone() + pkg.Publish.SkipAnchorTxBroadcast = true + pkg.Publish.ExternalBroadcast = true + pkg, err = pkg.Seal() + if err != nil { + return nil, err + } + } + _, err = wallet.PublishCustomAnchorTransfer(ctx, pkg, pkg.AnchorPsbt) + if err != nil { + // A lost reply can follow a durable tapd publication. The next + // invocation finds the logged anchor before retrying the log. + return nil, err + } + if raw, _, err := export(); err == nil { + return raw, nil + } + return nil, swapkit.ErrPending +} + +// anchorLogged reports whether tapd's transfer log already contains the anchor +// transaction. Every returned record is matched again, so a backend that +// ignores the filter cannot suppress a first publication. +func anchorLogged(ctx context.Context, wallet *sdk.Wallet, + anchor sdk.Outpoint) (bool, error) { + + txid := SDKPoint(anchor).Hash + transfers, err := wallet.Client().ListTransfers(ctx, + &sdk.ListTransfersRequest{AnchorTxid: txid.String()}) + if err != nil { + return false, err + } + for _, transfer := range transfers { + if transfer == nil { + continue + } + logged, err := chainhash.NewHashFromStr(transfer.AnchorTxid) + if err == nil && *logged == txid { + return true, nil + } + } + return false, nil +} + +// declareOutput retains the native packet's complete key descriptor. A control +// block alone loses the original key parity and locator, which can replace a +// wallet-owned key's first stored derivation with the unrelated zero locator. +func declareOutput(ctx context.Context, wallet *sdk.Wallet, + pkg *sdk.CustomAnchorTransferPackage, + out sdk.CustomAnchorAssetOutputSummary) error { + + if out.PacketIndex >= uint32(len(pkg.ActiveVirtualPsbts)) { + return swapkit.ErrInvalid + } + packet, err := tappsbt.NewFromRawBytes(bytes.NewReader( + pkg.ActiveVirtualPsbts[out.PacketIndex]), false) + if err != nil { + return err + } + if out.VirtualOutputIndex >= uint32(len(packet.Outputs)) { + return swapkit.ErrInvalid + } + key := packet.Outputs[out.VirtualOutputIndex].ScriptKey + if key.TweakedScriptKey == nil || key.RawKey.PubKey == nil || + !bytes.Equal( + key.PubKey.SerializeCompressed(), + out.ScriptKey[:], + ) { + + return swapkit.ErrInvalid + } + raw, err := sdk.ParsePubKey(key.RawKey.PubKey.SerializeCompressed()) + if err != nil { + return err + } + _, err = wallet.Client(). + DeclareScriptKey(ctx, &sdk.DeclareScriptKeyRequest{ + ScriptKey: sdk.ScriptKey{ + PubKey: out.ScriptKey, + TapTweak: key.Tweak, + KeyDesc: sdk.KeyDescriptor{RawKeyBytes: raw, + KeyLocator: sdk.KeyLocator{ + Family: uint32( + key.RawKey.Family, + ), + Index: key.RawKey.Index, + }}, + }, + }) + return err +} + // importProof restores lineage missing from tapd's exact-output proof archive. func importProof(ctx context.Context, wallet *sdk.Wallet, raw []byte) error { p, err := LastProof(raw) @@ -305,3 +521,24 @@ func inspectAsset(raw []byte, group [33]byte, amount uint64) (*proof.Proof, } return p, nil } + +// confirmedInputProof preserves native proof sources without treating a compact +// path encoding as a proof-file encoding. Unconfirmed steps need the explicit +// ConfirmPackageInputs handoff before publication. +func confirmedInputProof(source sdk.CustomAnchorProofSourceSummary) ([]byte, error) { + switch source.Kind { + case sdk.CustomAnchorProofSourceConfirmedFile: + return bytes.Clone(source.Blob), nil + case sdk.CustomAnchorProofSourceCompactPath: + var path sdk.AssetProofPath + if err := path.UnmarshalBinary(source.Blob); err != nil { + return nil, err + } + if len(path.Steps) != 0 { + return nil, swapkit.ErrPending + } + return bytes.Clone(path.ConfirmedBaseProof), nil + default: + return nil, swapkit.ErrInvalid + } +} diff --git a/swapkit/tapsdk/publish_retry_test.go b/swapkit/tapsdk/publish_retry_test.go new file mode 100644 index 000000000..d8003c37b --- /dev/null +++ b/swapkit/tapsdk/publish_retry_test.go @@ -0,0 +1,189 @@ +package tapsdk + +import ( + "context" + "errors" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/stretchr/testify/require" +) + +// publishRetryFixture returns a finalized package and a wallet stub whose +// proof archive holds only the package's input. +func publishRetryFixture(t *testing.T) (*sdk.CustomAnchorTransferPackage, + *observedRecoverySDK) { + + t.Helper() + pkg := signingPackage(t) + pkg.Publish.SkipAnchorTxBroadcast = false + pkg.Publish.ExternalBroadcast = false + pkg, err := pkg.Seal() + require.NoError(t, err) + signed, err := signTestPackage( + t.Context(), signingWallet(t, 2), signingWallet(t, 3), pkg, + ) + require.NoError(t, err) + final, err := pkg.WithFinalAnchorPSBT(finishSigningFixture(t, signed)) + require.NoError(t, err) + + inputRaw := final.Inputs[0].ProofSource.Blob + input, err := LastProof(inputRaw) + require.NoError(t, err) + return final, &observedRecoverySDK{ + partialRecoverySDK: &partialRecoverySDK{ + bindingSDK: &bindingSDK{valid: true}, + }, + input: &sdk.ProofFile{RawProofFile: inputRaw}, + point: sdk.Outpoint{ + Txid: sdk.Hash(input.OutPoint().Hash), + Index: input.OutPoint().Index, + }, + stopErr: errors.New("reached transfer log"), + } +} + +// TestLogAndExportDoesNotRelogAnchor checks that an anchor tapd already logged +// is never logged again while its exact output proof is not archived yet. +func TestLogAndExportDoesNotRelogAnchor(t *testing.T) { + pkg, client := publishRetryFixture(t) + wallet := sdk.NewWallet(client, sdk.NetworkRegtest) + chain := &bindingChain{tip: 200} + txid := SDKPoint(pkg.Outputs[0].AnchorOutpoint).Hash.String() + + // The first invocation finds no logged anchor and publishes. + _, err := LogAndExport(t.Context(), wallet, chain, 1, pkg, false) + require.ErrorIs(t, err, client.stopErr) + require.NotNil(t, client.logged) + require.Equal(t, []string{txid}, client.lookups) + + // A backend that ignores the anchor filter cannot suppress it. + client.logged = nil + client.transfers = []*sdk.AssetTransfer{ + nil, {AnchorTxid: chainhash.Hash{1}.String()}, + } + _, err = LogAndExport(t.Context(), wallet, chain, 1, pkg, false) + require.ErrorIs(t, err, client.stopErr) + require.NotNil(t, client.logged) + + // Once tapd lists the anchor, a publisher or observer retry waits for + // the archive instead of logging the transfer again. + client.logged = nil + client.transfers = append(client.transfers, &sdk.AssetTransfer{ + AnchorTxid: txid, + }) + for _, observed := range []bool{false, true} { + _, err = LogAndExport( + t.Context(), wallet, chain, 1, pkg, observed, + ) + require.ErrorIs(t, err, swapkit.ErrPending) + require.Nil(t, client.logged) + } + + // A failed lookup is reported and never read as an unlogged anchor. + client.transfersErr = errors.New("transfer log unavailable") + _, err = LogAndExport(t.Context(), wallet, chain, 1, pkg, false) + require.ErrorIs(t, err, client.transfersErr) + require.Nil(t, client.logged) +} + +// archivedOutputSDK also archives the exact output proof of a package. +type archivedOutputSDK struct { + *observedRecoverySDK + + output sdk.Outpoint + file *sdk.ProofFile +} + +// ExportProof returns the archived output proof for its exact locator. +func (s *archivedOutputSDK) ExportProof(ctx context.Context, ref sdk.AssetRef, + key sdk.PubKey, point *sdk.Outpoint) (*sdk.ProofFile, error) { + + if point != nil && *point == s.output { + return s.file, nil + } + return s.observedRecoverySDK.ExportProof(ctx, ref, key, point) +} + +// failingHeightChain reports a chain backend failure for the best height. +type failingHeightChain struct { + *bindingChain + + err error +} + +// Height returns the injected backend failure. +func (c *failingHeightChain) Height(context.Context) (uint32, error) { + return 0, c.err +} + +// archivedOutputProof derives the package's exact output proof at a height. +func archivedOutputProof(t *testing.T, pkg *sdk.CustomAnchorTransferPackage, + height uint32) *proof.Proof { + + t.Helper() + out := pkg.Outputs[0] + p, err := LastProof(pkg.Inputs[0].ProofSource.Blob) + require.NoError(t, err) + packet, err := DecodePSBT(pkg.AnchorPsbt) + require.NoError(t, err) + tx, err := psbt.Extract(packet) + require.NoError(t, err) + scriptKey, err := btcec.ParsePubKey(out.ScriptKey[:]) + require.NoError(t, err) + + p.Asset.ScriptKey = asset.NewScriptKey(scriptKey) + p.AnchorTx = *tx + p.InclusionProof.OutputIndex = out.AnchorOutpoint.Index + p.BlockHeight = height + p.TxMerkleProof = proof.TxMerkleProof{} + p.BlockHeader.MerkleRoot = tx.TxHash() + require.Equal(t, SDKPoint(out.AnchorOutpoint), p.OutPoint()) + require.Equal(t, out.IssuanceID, sdk.AssetID(p.Asset.ID())) + return p +} + +// TestLogAndExportArchivedProofAwaitsConfirmation checks that an archived +// exact output proof reports its own confirmation result. Neither an +// outstanding confirmation nor a chain backend failure logs the transfer again. +func TestLogAndExportArchivedProofAwaitsConfirmation(t *testing.T) { + pkg, recovery := publishRetryFixture(t) + p := archivedOutputProof(t, pkg, 200) + raw := bindingRaw(t, p) + client := &archivedOutputSDK{ + observedRecoverySDK: recovery, + output: pkg.Outputs[0].AnchorOutpoint, + file: &sdk.ProofFile{RawProofFile: raw}, + } + wallet := sdk.NewWallet(client, sdk.NetworkRegtest) + chain := &bindingChain{tip: 200, blocks: map[uint32]*wire.MsgBlock{ + 200: bindingBlock(p), + }} + + // One of three required confirmations is outstanding. + _, err := LogAndExport(t.Context(), wallet, chain, 3, pkg, false) + require.ErrorIs(t, err, swapkit.ErrPending) + + // A chain backend failure is reported, not answered with a new log. + backend := errors.New("chain backend unavailable") + _, err = LogAndExport(t.Context(), wallet, &failingHeightChain{ + bindingChain: chain, err: backend, + }, 1, pkg, false) + require.ErrorIs(t, err, backend) + + // The same archived proof is returned once it is confirmed deeply. + chain.tip = 202 + exported, err := LogAndExport(t.Context(), wallet, chain, 3, pkg, false) + require.NoError(t, err) + require.Equal(t, raw, exported) + + require.Nil(t, recovery.logged) + require.Empty(t, recovery.lookups) +} diff --git a/swapkit/tapsdk/recovery.go b/swapkit/tapsdk/recovery.go new file mode 100644 index 000000000..6747d5966 --- /dev/null +++ b/swapkit/tapsdk/recovery.go @@ -0,0 +1,305 @@ +package tapsdk + +import ( + "context" + "crypto/sha256" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/txscript" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" +) + +func walletOutput(public [33]byte, family int32, index uint32, + ref sdk.AssetRef, amount uint64, value int64) ( + sdk.CustomAssetOutput, error) { + + pub, err := btcec.ParsePubKey(public[:]) + if err != nil { + return sdk.CustomAssetOutput{}, err + } + tweaked := txscript.ComputeTaprootKeyNoScript(pub) + even, err := schnorr.ParsePubKey(schnorr.SerializePubKey(tweaked)) + if err != nil { + return sdk.CustomAssetOutput{}, err + } + scriptKey, err := sdk.ParsePubKey(even.SerializeCompressed()) + if err != nil { + return sdk.CustomAssetOutput{}, err + } + loc := sdk.KeyLocator{Family: uint32(family), Index: index} + return sdk.CustomAssetOutput{ + ID: "recipient", AssetRef: ref, Amount: amount, + AnchorValueSat: uint64(value), + Script: sdk.CustomAssetScriptPlan{ + Mode: sdk.CustomAssetScriptExternal, + External: &sdk.CustomAssetExternalScriptPlan{ + ScriptKey: sdk.ScriptKey{PubKey: scriptKey, + KeyDesc: sdk.KeyDescriptor{ + RawKeyBytes: public, + KeyLocator: loc, + }}, + }, + }, + Anchor: sdk.CustomAnchorOutputPlan{ + InternalKey: sdk.InternalKey{ + PubKey: public, KeyLocator: loc, + }, + }, + }, nil +} + +// DiscoverOutcome reconstructs an offline peer's proof from its Bitcoin spend. +// It verifies the agreed leaf and observed witness before observer logging. +func DiscoverOutcome(ctx context.Context, wallet *sdk.Wallet, + chain Chain, minConfs uint32, s *SwapContext, + refund bool) ([]byte, error) { + + if s.Fallback == nil { + return nil, swapkit.ErrPending + } + d := s.Deposit + c := d.Contract + out := s.Fallback.Outputs[0] + point := SDKPoint(out.AnchorOutpoint) + // The server may only have its public partial after a lost reply. + // The committed unsigned anchor still fixes the output to watch. + anchor, err := DecodePSBT(s.Fallback.AnchorPsbt) + if err != nil { + return nil, err + } + block, _, err := chain.Spend( + ctx, + point, + anchor.UnsignedTx.TxOut[point.Index].PkScript, + s.Deposit.Proof.BlockHeight, + ) + if err != nil { + return nil, err + } + found := spendingTransaction(block, point) + if len(found.TxIn) != 1 || len(found.TxOut) != 1 { + return nil, swapkit.ErrInvalid + } + policy, err := HTLC(s.Offer, c) + if err != nil { + return nil, err + } + public := c.ServerKey + spend, err := policy.SuccessSpend(out.TaprootAssetRoot) + if refund { + public = c.ClientKey + spend, err = policy.TimeoutSpend(out.TaprootAssetRoot) + } + if err != nil { + return nil, err + } + if !spendsLeaf(found, out, spend) { + return nil, swapkit.ErrPending + } + fallbackProof, err := FallbackProof( + ctx, + wallet, + chain, + minConfs, + s, + true, + ) + if err != nil { + return nil, err + } + raw, err := rebuildObservedSpend( + ctx, wallet, chain, minConfs, out, fallbackProof, public, + spend, found, + ) + if err != nil { + return nil, err + } + return raw, nil +} + +// VerifyOutcome binds a proof to the agreed claim or timeout Bitcoin path. +func VerifyOutcome(ctx context.Context, wallet *sdk.Wallet, + chain Chain, minConfs uint32, s *SwapContext, + raw []byte, refund, requireUnspent bool) error { + + d := s.Deposit + c := d.Contract + if s.Fallback == nil { + return swapkit.ErrPending + } + prior := s.Fallback.Outputs[0] + if !prior.AssetRef.Equivalent( + sdk.AssetRefFromGroupKey(s.Offer.Terms.GroupKey), + ) || + prior.Amount != s.Offer.Terms.DepositAmount { + + return swapkit.ErrInvalid + } + pub := c.ServerKey + if refund { + pub = c.ClientKey + } + policy, err := HTLC(s.Offer, c) + if err != nil { + return err + } + spend, err := policy.SuccessSpend(prior.TaprootAssetRoot) + if refund { + spend, err = policy.TimeoutSpend(prior.TaprootAssetRoot) + } + if err != nil { + return err + } + err = VerifyWalletSpend( + ctx, + wallet, + chain, + minConfs, + raw, + prior, + pub, + spend, + requireUnspent, + 0, + ) + return err +} + +// DiscoverPreimage reads only the fixed fallback's current on-chain spend. +func DiscoverPreimage(ctx context.Context, chain Chain, + s *SwapContext) (swapkit.PreimageResult, error) { + + if s.Fallback == nil { + return swapkit.PreimageResult{}, nil + } + point := SDKPoint(s.Fallback.Outputs[0].AnchorOutpoint) + anchor, err := DecodePSBT(s.Fallback.AnchorPsbt) + if err != nil { + return swapkit.PreimageResult{}, err + } + block, _, err := chain.Spend( + ctx, + point, + anchor.UnsignedTx.TxOut[point.Index].PkScript, + s.Deposit.Proof.BlockHeight, + ) + if err == swapkit.ErrPending { + return swapkit.PreimageResult{}, nil + } + if err != nil { + return swapkit.PreimageResult{}, err + } + for _, input := range spendingTransaction(block, point).TxIn { + if input.PreviousOutPoint != point { + continue + } + for _, element := range input.Witness { + if len(element) != 32 || + sha256.Sum256(element) != s.Offer.Hash { + + continue + } + var preimage [32]byte + copy(preimage[:], element) + return swapkit.PreimageResult{ + Preimage: preimage, + Found: true, + }, nil + } + } + return swapkit.PreimageResult{}, nil +} + +// FallbackProof locates the fixed fallback and logs its confirmed witness. +// SDK Build verifies the returned lineage when constructing its successor; +// validation-only callers verify the complete outcome proof instead. +func FallbackProof(ctx context.Context, wallet *sdk.Wallet, + chain Chain, minConfs uint32, + s *SwapContext, observed bool) ([]byte, error) { + + if err := CheckNodeVersion(ctx, wallet); err != nil { + return nil, err + } + if s.Fallback == nil { + return nil, swapkit.ErrPending + } + contract := s.Deposit.Contract + spendInfo, err := OPTrueSpendInfo(contract.Output) + if err != nil { + return nil, err + } + if err := declareOPTrue(ctx, wallet, contract.Output.ScriptKey, + spendInfo.WitnessStack()); err != nil { + return nil, err + } + pkg := s.Fallback + packet, err := DecodePSBT(pkg.AnchorPsbt) + if err != nil { + return nil, err + } + if !packet.IsComplete() { + observed = true + if len(packet.UnsignedTx.TxIn) != 1 || + len(packet.Inputs) != 1 || + packet.Inputs[0].WitnessUtxo == nil { + + return nil, swapkit.ErrInvalid + } + point := packet.UnsignedTx.TxIn[0].PreviousOutPoint + block, _, err := chain.Spend( + ctx, point, packet.Inputs[0].WitnessUtxo.PkScript, + s.Deposit.Proof.BlockHeight, + ) + if err != nil { + return nil, err + } + tx := spendingTransaction(block, point) + if tx == nil || tx.TxHash() != packet.UnsignedTx.TxHash() || + len(tx.TxIn[0].Witness) != 1 { + + return nil, swapkit.ErrPending + } + requests, err := pkg.SigningRequests() + if err != nil || len(requests.MuSig2) != 1 { + return nil, swapkit.ErrInvalid + } + signed, err := pkg.ApplyKeyPathSignature( + requests.MuSig2[0].ID, tx.TxIn[0].Witness[0], + ) + if err != nil { + return nil, err + } + packet, err = DecodePSBT(signed.AnchorPsbt) + if err != nil { + return nil, err + } + if err := psbt.MaybeFinalizeAll(packet); err != nil { + return nil, err + } + final, err := EncodePSBT(packet) + if err != nil { + return nil, err + } + s.Fallback, err = pkg.WithFinalAnchorPSBT(final) + if err != nil { + return nil, err + } + } + raw, err := LogAndExport( + ctx, + wallet, + chain, + minConfs, + s.Fallback, + observed, + ) + if err != nil { + return nil, err + } + // The next SDK Build verifies this input lineage once. A validation-only + // caller verifies its complete outcome proof, including this lineage. + return raw, nil +} diff --git a/swapkit/tapsdk/spend.go b/swapkit/tapsdk/spend.go new file mode 100644 index 000000000..1720f1fdb --- /dev/null +++ b/swapkit/tapsdk/spend.go @@ -0,0 +1,66 @@ +package tapsdk + +import ( + "context" + + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightningnetwork/lnd/keychain" +) + +// RecoveryRequest constructs an SDK refund or claim to the normal wallet key. +func RecoveryRequest( + ctx context.Context, + wallet *sdk.Wallet, + out sdk.CustomAnchorAssetOutputSummary, + inputProof []byte, + public [33]byte, + key keychain.KeyLocator, + spend *swapkit.SwapAnchorSpendInfo, + fee uint64, +) ( + *sdk.CustomAnchorRequest, error) { + + if err := CheckNodeVersion(ctx, wallet); err != nil { + return nil, err + } + if out.AnchorValueSat < 330 || + fee > uint64(out.AnchorValueSat-330) { + + return nil, swapkit.ErrInvalid + } + value := out.AnchorValueSat - int64(fee) + if fee == 0 { + return nil, swapkit.ErrInvalid + } + recipient, err := walletOutput(public, int32(key.Family), key.Index, + out.AssetRef, out.Amount, value) + if err != nil { + return nil, err + } + // Declare the locator so normal wallet operations can spend the + // recovered asset after proof import. + _, err = wallet.Client(). + DeclareScriptKey(ctx, &sdk.DeclareScriptKeyRequest{ + ScriptKey: recipient.Script.External.ScriptKey, + }) + if err != nil { + return nil, err + } + p, err := LastProof(inputProof) + if err != nil { + return nil, err + } + anchor, err := AnchorTemplate( + p, recipient.Anchor.InternalKey, value, spend, + ) + if err != nil { + return nil, err + } + input, err := AssetInput(out, inputProof) + if err != nil { + return nil, err + } + return CustomRequest(input, recipient, anchor, + ScriptSigningPlan(spend, 0)), nil +} diff --git a/swapkit/tapsdk/spend_test.go b/swapkit/tapsdk/spend_test.go index 6c2d679ad..3d0e98896 100644 --- a/swapkit/tapsdk/spend_test.go +++ b/swapkit/tapsdk/spend_test.go @@ -2,9 +2,19 @@ package tapsdk import ( "context" + "encoding/json" + "errors" + "testing" + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/txscript" "github.com/btcsuite/btcd/wire" "github.com/lightninglabs/lndclient" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightningnetwork/lnd/keychain" + "github.com/stretchr/testify/require" ) type scriptWallet struct { @@ -26,3 +36,134 @@ func (w *scriptWallet) SignOutputRawKeyLocator(context.Context, *wire.MsgTx, } return [][]byte{w.signature}, nil } + +// TestScriptSpendRecovery checks retry after a lost signer reply and reuse of +// the completed transaction after the owning FSM saves it. +func TestScriptSpendRecovery(t *testing.T) { + for _, lostReply := range []bool{false, true} { + name := "completed package" + if lostReply { + name = "lost signer reply" + } + t.Run(name, func(t *testing.T) { + tx := scriptPackage(t) + requests, err := tx.SigningRequests() + require.NoError(t, err) + require.Len(t, requests.ScriptPath, 1) + request := requests.ScriptPath[0] + signature, err := schnorr.Sign( + bindingKey(2), request.Sighash[:], + ) + require.NoError(t, err) + lost := errors.New("simulated lost signer reply") + wallet := &scriptWallet{ + signature: signature.Serialize(), + } + if lostReply { + wallet.failure = lost + } + signed, err := FinalizeScriptSpend( + t.Context(), + wallet, + keychain.KeyLocator{}, + tx, + nil, + ) + if lostReply { + require.ErrorIs(t, err, lost) + require.Nil(t, signed) + signed, err = FinalizeScriptSpend( + t.Context(), + wallet, + keychain.KeyLocator{}, + tx, + nil, + ) + } + require.NoError(t, err) + final := signed.AnchorPsbt + require.NotEmpty(t, final) + stored, err := signed.MarshalBinary() + require.NoError(t, err) + restored, err := DecodeFinalPackage(stored) + require.NoError(t, err) + require.Equal(t, final, restored.AnchorPsbt) + require.Equal(t, signed.CommittedPackageDigest, + restored.CommittedPackageDigest) + }) + } +} + +type declaringRecoveryWallet struct{ sdk.Client } + +func (declaringRecoveryWallet) DeclareScriptKey(context.Context, + *sdk.DeclareScriptKeyRequest) (*sdk.ScriptKey, error) { + + return nil, nil +} + +// TestRecoveryPlanIgnoresChangedFeeConfiguration verifies the transaction that +// is rebuilt after restart stays identical when operator fee limits change. +func TestRecoveryPlanIgnoresChangedFeeConfiguration(t *testing.T) { + node, swap, _, _ := bindingOutcome(t, true) + var contract DepositContract + // Preserve the existing SDK/contract JSON field names. + //nolint:musttag + require.NoError(t, json.Unmarshal(swap.Offer.Terms.Contract, &contract)) + output := swap.Fallback.Outputs[0] + output.OPTrueSpend = contract.Output.OPTrueSpend + policy, err := HTLC(swap.Offer, contract) + require.NoError(t, err) + anchor := AnchorPlan(policy.AnchorPlan()) + require.Len(t, anchor.Tapscript.TapLeaves, 2) + branch := txscript.NewTapBranch( + txscript.NewBaseTapLeaf(anchor.Tapscript.TapLeaves[0].Script), + txscript.NewBaseTapLeaf(anchor.Tapscript.TapLeaves[1].Script), + ) + sibling := commitment.NewPreimageFromBranch(branch) + internal, err := btcec.ParsePubKey(anchor.InternalKey.PubKey[:]) + require.NoError(t, err) + script, err := btcec.ParsePubKey(contract.Output.ScriptKey[:]) + require.NoError(t, err) + previous := bindingProof(t, bindingGenesis(), script, internal, + &sibling, SDKPoint(contract.Output.AnchorOutpoint), 140, false) + previous.AnchorTx.TxOut[0].Value = output.AnchorValueSat + previous.BlockHeader.MerkleRoot = previous.AnchorTx.TxHash() + output.TaprootAssetRoot, _, err = isolatedRoots(previous) + require.NoError(t, err) + spend, err := policy.TimeoutSpend(output.TaprootAssetRoot) + require.NoError(t, err) + output.ScriptKey = contract.Output.ScriptKey + output.IssuanceID = sdk.AssetID(previous.Asset.ID()) + output.AnchorOutpoint = sdk.Outpoint{ + Txid: sdk.Hash(previous.OutPoint().Hash), + Index: previous.OutPoint().Index, + } + output.Amount = previous.Asset.Amount + output.AssetRef = contract.Output.AssetRef + proof := bindingRaw(t, previous) + fee := uint64(contract.Output.AnchorValueSat - output.AnchorValueSat) + node.client = declaringRecoveryWallet{} + before, err := RecoveryRequest( + t.Context(), + node.wallet(), + output, + proof, + contract.ClientKey, + keychain.KeyLocator{}, + spend, + fee, + ) + require.NoError(t, err) + // Recovery only accepts the agreed fee. No daemon fee configuration + // crosses this API when the same unsigned transfer is rebuilt. + after, err := RecoveryRequest(t.Context(), node.wallet(), output, proof, + contract.ClientKey, keychain.KeyLocator{}, spend, fee) + require.NoError(t, err) + require.Equal(t, before, after) + require.EqualValues(t, 8000, after.Outputs[0].AnchorValueSat) +} + +func (declaringRecoveryWallet) GetInfo(context.Context) (*sdk.Info, error) { + return fixtureNodeInfo(), nil +} diff --git a/swapkit/tapsdk/wallet_spend.go b/swapkit/tapsdk/wallet_spend.go new file mode 100644 index 000000000..9f47dc634 --- /dev/null +++ b/swapkit/tapsdk/wallet_spend.go @@ -0,0 +1,173 @@ +package tapsdk + +import ( + "bytes" + "context" + + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" +) + +// rebuildObservedSpend reconstructs an SDK transfer from a mined witness. +// It neither signs a wallet transaction nor broadcasts the observed spend. +func rebuildObservedSpend( + ctx context.Context, + wallet *sdk.Wallet, + chain Chain, + minConfs uint32, + prior sdk.CustomAnchorAssetOutputSummary, + inputProof []byte, + public [33]byte, + spend *swapkit.SwapAnchorSpendInfo, + observed *wire.MsgTx, +) ( + []byte, error) { + + if len(observed.TxIn) != 1 || len(observed.TxOut) != 1 || + !spendsLeaf(observed, prior, spend) { + + return nil, swapkit.ErrInvalid + } + p, err := LastProof(inputProof) + if err != nil { + return nil, err + } + value := observed.TxOut[0].Value + recipient, err := walletOutput(public, 0, 0, + prior.AssetRef, prior.Amount, value) + if err != nil { + return nil, err + } + anchor, err := AnchorTemplate(p, recipient.Anchor.InternalKey, + value, spend) + if err != nil { + return nil, err + } + // Recovery reproduces the mined transaction, including older non-RBF + // refunds. New templates use the current default sequence instead. + packet, err := DecodePSBT(anchor) + if err != nil { + return nil, err + } + packet.UnsignedTx.Version = observed.Version + packet.UnsignedTx.LockTime = observed.LockTime + packet.UnsignedTx.TxIn[0].Sequence = observed.TxIn[0].Sequence + anchor, err = EncodePSBT(packet) + if err != nil { + return nil, err + } + input, err := AssetInput(prior, inputProof) + if err != nil { + return nil, err + } + request := CustomRequest(input, + recipient, anchor, ScriptSigningPlan(spend, 0)) + pkg, err := commit(ctx, wallet, chain, minConfs, request) + if err != nil { + return nil, err + } + packet, err = DecodePSBT(pkg.AnchorPsbt) + if err != nil { + return nil, err + } + if packet.UnsignedTx.TxHash() != observed.TxHash() { + return nil, swapkit.ErrInvalid + } + requests, err := pkg.SigningRequests() + if err != nil || len(requests.ScriptPath) != 1 { + return nil, swapkit.ErrInvalid + } + witness := observed.TxIn[0].Witness + final, err := pkg.ApplyScriptPathWitness(requests.ScriptPath[0].ID, + witness[:len(witness)-2]) + if err != nil { + return nil, err + } + final, err = pkg.WithFinalAnchorPSBT(final.AnchorPsbt) + if err != nil { + return nil, err + } + return LogAndExport(ctx, wallet, chain, minConfs, final, true) +} + +// VerifyWalletSpend checks issuance, wallet recipient and Bitcoin leaf. +func VerifyWalletSpend( + ctx context.Context, + wallet *sdk.Wallet, + chain Chain, + minConfs uint32, + raw []byte, + prior sdk.CustomAnchorAssetOutputSummary, + public [33]byte, + spend *swapkit.SwapAnchorSpendInfo, + unspent bool, + minHeight uint64, +) error { + + group, ok := prior.AssetRef.GroupKey() + if !ok { + return swapkit.ErrInvalid + } + p, err := verifyProof( + ctx, wallet, chain, minConfs, raw, group, prior.Amount, unspent, + ) + if err != nil { + return err + } + if sdk.AssetID(p.Asset.ID()) != prior.IssuanceID || + uint64(p.BlockHeight) < minHeight { + + return swapkit.ErrInvalid + } + expected, err := walletOutput(public, 0, 0, + prior.AssetRef, prior.Amount, 330) + if err != nil { + return err + } + if !bytes.Equal(p.Asset.ScriptKey.PubKey.SerializeCompressed(), + expected.Script.External.ScriptKey.PubKey[:]) || + !bytes.Equal(p.InclusionProof.InternalKey.SerializeCompressed(), + public[:]) { + + return swapkit.ErrInvalid + } + block, err := chain.Block(ctx, p.BlockHeight) + if err != nil { + return err + } + for _, tx := range block.Transactions { + if tx.TxHash() != p.AnchorTx.TxHash() { + continue + } + if !spendsLeaf(tx, prior, spend) { + return swapkit.ErrInvalid + } + fetch := txscript.NewCannedPrevOutputFetcher( + spend.PkScript, prior.AnchorValueSat, + ) + hashes := txscript.NewTxSigHashes(tx, fetch) + engine, err := txscript.NewEngine(spend.PkScript, tx, 0, + txscript.StandardVerifyFlags, nil, hashes, + prior.AnchorValueSat, fetch) + if err != nil { + return err + } + return engine.Execute() + } + return swapkit.ErrInvalid +} + +func spendsLeaf(tx *wire.MsgTx, prior sdk.CustomAnchorAssetOutputSummary, + spend *swapkit.SwapAnchorSpendInfo) bool { + + if len(tx.TxIn) != 1 || tx.TxIn[0].PreviousOutPoint != + SDKPoint(prior.AnchorOutpoint) { + + return false + } + w := tx.TxIn[0].Witness + return len(w) >= 3 && bytes.Equal(w[len(w)-2], spend.LeafScript) && + bytes.Equal(w[len(w)-1], spend.ControlBlock) +} From d620bd25aca7c640553f573e01fe1781e0444b22 Mon Sep 17 00:00:00 2001 From: Slyghtning Date: Wed, 11 Nov 2026 15:26:50 +0100 Subject: [PATCH 9/9] tapsdk: Harden recovery, fallback and witness declaration Bind a recovery fallback package to the authenticated deposit before it is co-signed. The MuSig2 sighash covers the committed PSBT's own previous output, so a peer that changed only the signed input value or script obtained a valid signature that spent nothing real. Compare that prevout with the deposit output, reject a committed asset that carries its own lock time, and require normal broadcast. Verify a caller-provided asset witness commits to its input script key before declaring it to tapd, so a peer cannot bind a wallet script key to an unrelated internal key. Recognize a BIP-341 annex when matching the agreed leaf, reject an annex spend from reconstruction rather than mis-slicing its witness, report a reorg observed during outcome verification as retryable, and guard the observed-spend discovery helpers against a chain that returns a block without the watched spend. --- docs/release-notes/release-notes-next.md | 5 + swapkit/tapsdk/README.md | 19 +- swapkit/tapsdk/fallback.go | 46 ++++ swapkit/tapsdk/hardening_annex_test.go | 85 +++++++ .../hardening_fallback_asset_lock_test.go | 88 +++++++ swapkit/tapsdk/hardening_fallback_test.go | 217 ++++++++++++++++++ .../tapsdk/hardening_prepare_inputs_test.go | 82 +++++++ swapkit/tapsdk/hardening_recovery_test.go | 71 ++++++ swapkit/tapsdk/hardening_reorg_test.go | 77 +++++++ swapkit/tapsdk/original_refund.go | 10 +- swapkit/tapsdk/proofs.go | 15 ++ swapkit/tapsdk/recovery.go | 11 +- swapkit/tapsdk/wallet_spend.go | 33 ++- 13 files changed, 753 insertions(+), 6 deletions(-) create mode 100644 swapkit/tapsdk/hardening_annex_test.go create mode 100644 swapkit/tapsdk/hardening_fallback_asset_lock_test.go create mode 100644 swapkit/tapsdk/hardening_fallback_test.go create mode 100644 swapkit/tapsdk/hardening_prepare_inputs_test.go create mode 100644 swapkit/tapsdk/hardening_recovery_test.go create mode 100644 swapkit/tapsdk/hardening_reorg_test.go diff --git a/docs/release-notes/release-notes-next.md b/docs/release-notes/release-notes-next.md index c95916444..20872ce41 100644 --- a/docs/release-notes/release-notes-next.md +++ b/docs/release-notes/release-notes-next.md @@ -21,6 +21,11 @@ already using, and a failed lock no longer resets deposits that a withdrawal or a channel open has taken. +* Harden the shared `swapkit` adapter against hostile peer input: bind a + recovery fallback to the authenticated deposit before co-signing, verify a + caller-provided asset witness before declaring it, recognize annex spends, + and report a reorg during outcome verification as retryable. + #### Maintenance #### Contributors (Alphabetical Order) diff --git a/swapkit/tapsdk/README.md b/swapkit/tapsdk/README.md index fbb7f4c8b..1a5ef8e87 100644 --- a/swapkit/tapsdk/README.md +++ b/swapkit/tapsdk/README.md @@ -66,9 +66,12 @@ Use the following order for a confirmed-input transaction: complete batch of active and passive bindings and their union commitment. Both enforce bounded genesis provenance and the live tapd v0.8.8 floor. 3. `PrepareInputs` restores exact confirmed proof lineage and declares public - asset witnesses. Call the native `wallet.NewCustomAnchorTxBuilder().Build`. - Native SDK Build verifies lineage and constructs allocations and commitments; - do not repeat generic proof verification before Build. + asset witnesses. A caller-provided witness is verified to commit to its input + script key before it is declared, so a peer cannot bind a wallet script key + to an unrelated internal key. Call the native + `wallet.NewCustomAnchorTxBuilder().Build`. Native SDK Build verifies lineage + and constructs allocations and commitments; do not repeat generic proof + verification before Build. 4. Call `ApprovePlan` with the independently retained Bitcoin template, concrete `OutputBinding` allocations and absolute fee cap. It checks every issuance, allocation, asset key derivation, Bitcoin contract and complete transaction @@ -168,6 +171,16 @@ metadata. Recovery of an observed refund preserves its mined version, locktime and sequence, including older non-RBF refunds. A digest does not itself cover final witnesses: those are independently validated by the native SDK. +`NewSwap` validates a peer's fallback package against the authenticated deposit +before it is ever co-signed. It binds the committed PSBT's signed previous +output to the deposit output, rejects a committed asset that carries its own +lock time, and requires normal publication (no skip-broadcast). The observed +refund and claim discovery helpers tolerate a `Chain` that returns a block +without the watched spend, recognize the agreed leaf when the spend carries a +BIP-341 annex, and reject an annex spend from reconstruction rather than +mis-slicing its witness. A reorg observed while verifying an outcome is +reported as retryable, not invalid. + ## Validation Run `go test ./swapkit/... ./internal/assetproof ./internal/assetpolicy` with the diff --git a/swapkit/tapsdk/fallback.go b/swapkit/tapsdk/fallback.go index b6b451d2c..8639f76d3 100644 --- a/swapkit/tapsdk/fallback.go +++ b/swapkit/tapsdk/fallback.go @@ -6,6 +6,7 @@ import ( "github.com/lightninglabs/loop/swapkit" sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/tappsbt" ) // HTLC constructs the existing V3 Bitcoin contract for the offered swap. @@ -53,6 +54,12 @@ func validateRecoveryPackage(offer swapkit.Offer, d *DepositContext, return nil, swapkit.ErrInvalid } + // The peer owns the package it hands us, including its publication + // metadata. A fallback must be broadcast normally, so reject a package + // that would be logged without reaching the network. + if pkg.Publish.SkipAnchorTxBroadcast || pkg.Publish.ExternalBroadcast { + return nil, swapkit.ErrInvalid + } packet, err := DecodePSBT(pkg.AnchorPsbt) if err != nil { return nil, err @@ -65,6 +72,45 @@ func validateRecoveryPackage(offer swapkit.Offer, d *DepositContext, return nil, swapkit.ErrInvalid } + // The MuSig2 sighash is taken over the committed PSBT's own previous + // output. A peer that only changes the signed input value or script + // obtains a complete signature that is invalid for the real deposit, so + // bind the signed prevout to the authenticated deposit output here. + committed, err := DecodePSBT(pkg.CommittedAnchorPsbt) + if err != nil { + return nil, err + } + prevout := d.Proof.AnchorTx.TxOut[d.Proof.OutPoint().Index] + if len(committed.UnsignedTx.TxIn) != 1 || len(committed.Inputs) != 1 || + committed.UnsignedTx.TxIn[0].PreviousOutPoint != + d.Proof.OutPoint() || + committed.Inputs[0].WitnessUtxo == nil || + committed.Inputs[0].WitnessUtxo.Value != prevout.Value || + !bytes.Equal(committed.Inputs[0].WitnessUtxo.PkScript, + prevout.PkScript) { + + return nil, swapkit.ErrInvalid + } + // The Bitcoin transaction can be valid while the committed asset carries + // its own timelock that tapd's VM rejects at every height below it. The + // kit never agreed to such an asset, so reject it before signing. + if len(pkg.ActiveVirtualPsbts) != 1 { + return nil, swapkit.ErrInvalid + } + vPkt, err := tappsbt.Decode(pkg.ActiveVirtualPsbts[0]) + if err != nil { + return nil, err + } + if len(vPkt.Outputs) != 1 { + return nil, swapkit.ErrInvalid + } + vOut := vPkt.Outputs[0] + if vOut.LockTime != 0 || vOut.RelativeLockTime != 0 || + vOut.Asset == nil || vOut.Asset.LockTime != 0 || + vOut.Asset.RelativeLockTime != 0 { + + return nil, swapkit.ErrInvalid + } policy, err := HTLC(offer, c) if err != nil { return nil, err diff --git a/swapkit/tapsdk/hardening_annex_test.go b/swapkit/tapsdk/hardening_annex_test.go new file mode 100644 index 000000000..ac7c72d32 --- /dev/null +++ b/swapkit/tapsdk/hardening_annex_test.go @@ -0,0 +1,85 @@ +package tapsdk + +import ( + "testing" + + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/txscript" + "github.com/lightninglabs/loop/swapkit" + "github.com/stretchr/testify/require" +) + +// Shared subtest names for the claim and refund directions. +const ( + hardeningClaimCase = "claim" + hardeningRefundCase = "refund" +) + +// TestVerifyOutcomeRecognizesAnnexSpend checks that a consensus-valid claim or +// refund through the agreed leaf is still recognized when its witness also +// carries a BIP-341 annex. spendsLeaf strips the annex before reading the leaf +// script and control block from the last two witness elements. +func TestVerifyOutcomeRecognizesAnnexSpend(t *testing.T) { + for _, refund := range []bool{false, true} { + name := hardeningClaimCase + if refund { + name = hardeningRefundCase + } + t.Run(name, func(t *testing.T) { + checkAnnexSpend(t, refund) + }) + } +} + +func checkAnnexSpend(t *testing.T, refund bool) { + t.Helper() + r, s, p, chain := bindingOutcome(t, refund) + prior := s.Fallback.Outputs[0] + policy, err := HTLC(s.Offer, s.Deposit.Contract) + require.NoError(t, err) + path, err := policy.SuccessSpend(prior.TaprootAssetRoot) + signer := bindingKey(3) + if refund { + path, err = policy.TimeoutSpend(prior.TaprootAssetRoot) + signer = bindingKey(2) + } + require.NoError(t, err) + + // Sign the same transaction again, committing to an annex. + tx := &p.AnchorTx + annex := []byte{txscript.TaprootAnnexTag, 0x01} + fetch := txscript.NewCannedPrevOutputFetcher( + path.PkScript, prior.AnchorValueSat, + ) + hashes := txscript.NewTxSigHashes(tx, fetch) + digest, err := txscript.CalcTapscriptSignaturehash( + hashes, txscript.SigHashDefault, tx, 0, fetch, + txscript.NewBaseTapLeaf(path.LeafScript), + txscript.WithAnnex(annex), + ) + require.NoError(t, err) + sig, err := schnorr.Sign(signer, digest) + require.NoError(t, err) + old := tx.TxIn[0].Witness + witness := [][]byte{sig.Serialize(), path.LeafScript, + path.ControlBlock, annex} + if !refund { + // The success witness starts with the preimage. + witness = append([][]byte{old[0]}, witness...) + } + tx.TxIn[0].Witness = witness + require.Equal(t, p.BlockHeader.MerkleRoot, tx.TxHash()) + + // The spend satisfies the agreed leaf under consensus rules. + engine, err := txscript.NewEngine(path.PkScript, tx, 0, + txscript.StandardVerifyFlags, nil, + txscript.NewTxSigHashes(tx, fetch), + prior.AnchorValueSat, fetch) + require.NoError(t, err) + require.NoError(t, engine.Execute()) + + err = VerifyOutcome(t.Context(), r.wallet(), chain, 1, s, + bindingRaw(t, p), refund, refund) + require.NoError(t, err, "refund=%v", refund) + require.NotErrorIs(t, err, swapkit.ErrInvalid) +} diff --git a/swapkit/tapsdk/hardening_fallback_asset_lock_test.go b/swapkit/tapsdk/hardening_fallback_asset_lock_test.go new file mode 100644 index 000000000..72c530d21 --- /dev/null +++ b/swapkit/tapsdk/hardening_fallback_asset_lock_test.go @@ -0,0 +1,88 @@ +package tapsdk + +import ( + "bytes" + "testing" + + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/tappsbt" + "github.com/lightninglabs/taproot-assets/tapsend" + "github.com/stretchr/testify/require" +) + +// TestFallbackRejectsAssetTimeLock checks that the fallback validator inspects +// the committed virtual output. A peer can give the HTLC asset an asset-level +// lock time far beyond the agreed refund height; the Bitcoin transaction and +// every summary still match the offer, but tapd would reject the asset +// transition at any confirmation height before the lock. The validator must +// reject the package rather than co-sign an unusable fallback. +func TestFallbackRejectsAssetTimeLock(t *testing.T) { + f := newFallbackFixture(t) + + const lock = 5_000_000 + require.Greater(t, uint32(lock), f.offer.Terms.RefundHeight) + + forged := f.pkg.Clone() + packet, err := tappsbt.Decode(forged.ActiveVirtualPsbts[0]) + require.NoError(t, err) + require.Len(t, packet.Outputs, 1) + output := packet.Outputs[0] + output.LockTime = lock + output.Asset.LockTime = lock + + // Recommit exactly as an author's backend would, without bubbling the + // asset lock into the Bitcoin transaction. + anchor, err := DecodePSBT(forged.CommittedAnchorPsbt) + require.NoError(t, err) + all := []*tappsbt.VPacket{packet} + commitments, err := tapsend.CreateOutputCommitments( + all, tapsend.WithNoSTXOProofs(), + ) + require.NoError(t, err) + require.NoError(t, tapsend.UpdateTaprootOutputKeys( + anchor, packet, commitments, + )) + anchor.UnsignedTx.LockTime = 0 + anchor.UnsignedTx.TxIn[0].Sequence = 0xfffffffc + output.ProofSuffix, err = tapsend.CreateProofSuffix( + anchor.UnsignedTx, anchor.Outputs, packet, commitments, 0, all, + proof.WithVersion(output.ProofSuffix.Version), + ) + require.NoError(t, err) + forged.ActiveVirtualPsbts[0], err = tappsbt.Encode(packet) + require.NoError(t, err) + raw, err := EncodePSBT(anchor) + require.NoError(t, err) + forged.CommittedAnchorPsbt = raw + forged.AnchorPsbt = bytes.Clone(raw) + + _, merkleRoot, assetRoot, err := tapsend.AnchorOutputScript( + output.AnchorOutputInternalKey, + output.AnchorOutputTapscriptSibling, commitments[0], + ) + require.NoError(t, err) + txid := anchor.UnsignedTx.TxHash() + forged.Outputs[0].TaprootAssetRoot = sdk.Hash(assetRoot) + forged.Outputs[0].TaprootMerkleRoot = sdk.Hash(merkleRoot) + forged.Outputs[0].AnchorOutpoint.Txid = sdk.Hash(txid) + forged.ProofUpdates[0].AnchorOutpoint.Txid = sdk.Hash(txid) + var blob bytes.Buffer + require.NoError(t, output.ProofSuffix.Encode(&blob)) + forged.ProofUpdates[0].ProofBlob = blob.Bytes() + forged, err = forged.Seal() + require.NoError(t, err) + encoded, err := forged.MarshalBinary() + require.NoError(t, err) + + // The committed HTLC asset carries a lock time the kit never agreed to. + locked, err := proof.Decode( + forged.ProofUpdates[0].ProofBlob, + ) + require.NoError(t, err) + require.EqualValues(t, lock, locked.Asset.LockTime) + + _, err = NewSwap(f.offer, f.deposit, encoded) + require.ErrorIs(t, err, swapkit.ErrInvalid) +} diff --git a/swapkit/tapsdk/hardening_fallback_test.go b/swapkit/tapsdk/hardening_fallback_test.go new file mode 100644 index 000000000..36cf1ab5e --- /dev/null +++ b/swapkit/tapsdk/hardening_fallback_test.go @@ -0,0 +1,217 @@ +package tapsdk + +import ( + "bytes" + "crypto/sha256" + "encoding/json" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcutil/psbt" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/lightninglabs/taproot-assets/commitment" + "github.com/lightningnetwork/lnd/keychain" + "github.com/stretchr/testify/require" +) + +// fallbackFixture is an honest Loop In deposit, offer and native fallback +// package built with the kit's own FallbackRequest and the real SDK builder. +type fallbackFixture struct { + offer swapkit.Offer + deposit *DepositContext + pkg *sdk.CustomAnchorTransferPackage + prevout *wire.TxOut +} + +// newFallbackFixture builds the deposit with client scalar two and server +// scalar three, matching the keys of the package's LND session fixtures. +func newFallbackFixture(t *testing.T) *fallbackFixture { + t.Helper() + clientKey, serverKey := bindingPub(2), bindingPub(3) + dk, err := swapkit.NewDepositKit(swapkit.DepositKitParams{ + ClientKey: clientKey, ServerKey: serverKey, CSVExpiry: 100, + }) + require.NoError(t, err) + key, _, err := LegacyOPTrueDescriptor() + require.NoError(t, err) + scriptKey, err := btcec.ParsePubKey(key.PubKey[:]) + require.NoError(t, err) + plan := dk.AnchorPlan() + internal, err := btcec.ParsePubKey(plan.InternalKey[:]) + require.NoError(t, err) + sibling, err := commitment.NewPreimageFromLeaf( + txscript.NewBaseTapLeaf(plan.Leaves[0]), + ) + require.NoError(t, err) + deposit := bindingProof(t, bindingGenesis(), scriptKey, internal, + sibling, bindingGenesis().FirstPrevOut, 100, false) + assets, merkle, err := isolatedRoots(deposit) + require.NoError(t, err) + + c := DepositContract{Version: 1, ClientKey: clientKey, + ServerKey: serverKey, CSV: 100, + Output: sdk.CustomAnchorAssetOutputSummary{ + LogicalOutputID: "deposit", + ScriptKey: key.PubKey, + ScriptMode: sdk.CustomAssetScriptExternal, + AssetRef: sdk.AssetRefFromGroupKey(bindingPub(11)), + IssuanceID: sdk.AssetID(deposit.Asset.ID()), + AssetType: sdk.AssetType( + deposit.Asset.Genesis.Type, + ), + Amount: 1000, AnchorValueSat: 10_000, + TaprootAssetRoot: assets, TaprootMerkleRoot: merkle, + AnchorOutpoint: sdk.Outpoint{Txid: sdk.Hash( + deposit.AnchorTx.TxHash())}, + }} + // Preserve the existing SDK/contract JSON field names. + //nolint:musttag + contract, err := json.Marshal(c) + require.NoError(t, err) + preimage := [32]byte{99} + offer := swapkit.Offer{Hash: sha256.Sum256(preimage[:]), + Terms: swapkit.Terms{Version: 1, GroupKey: bindingPub(11), + DepositOutpoints: []string{deposit.OutPoint().String()}, + DepositAmount: 1000, PayoutAmount: 900, AssetFee: 100, + RefundHeight: 150, RecoveryDelta: 10, Contract: contract}} + d, err := LoadDeposit(swapkit.Deposit{ + Outpoint: deposit.OutPoint().String(), + Proof: bindingRaw(t, deposit), Contract: contract, + GroupKey: bindingPub(11), Amount: 1000, + }, keychain.KeyLocator{}) + require.NoError(t, err) + chain := &bindingChain{tip: 161, unspent: true, + blocks: map[uint32]*wire.MsgBlock{100: bindingBlock(deposit)}} + require.NoError(t, InspectDeposit(t.Context(), chain, 1, d, true)) + + // The honest author builds and commits the fallback natively. + s, err := NewSwap(offer, d, nil) + require.NoError(t, err) + request, err := FallbackRequest(s, 1_000, 1_000) + require.NoError(t, err) + wallet := sdk.NewWallet(&pathClient{t: t}, sdk.NetworkRegtest) + built, err := wallet.NewCustomAnchorTxBuilder().Build( + t.Context(), request, + ) + require.NoError(t, err) + pkg, err := built.Commit(t.Context(), sdk.CustomAnchorCommitOptions{}) + require.NoError(t, err) + + // The honest package is accepted, so the fixture is representative. + raw, err := pkg.MarshalBinary() + require.NoError(t, err) + _, err = NewSwap(offer, d, raw) + require.NoError(t, err) + + point := deposit.OutPoint() + return &fallbackFixture{offer: offer, deposit: d, pkg: pkg, + prevout: deposit.AnchorTx.TxOut[point.Index]} +} + +// executeAgainst runs the finalized anchor against one previous output. +func executeAgainst(t *testing.T, pkg *sdk.CustomAnchorTransferPackage, + prevout *wire.TxOut) error { + + t.Helper() + packet, err := DecodePSBT(pkg.AnchorPsbt) + require.NoError(t, err) + tx, err := psbt.Extract(packet) + require.NoError(t, err) + fetch := txscript.NewCannedPrevOutputFetcher( + prevout.PkScript, prevout.Value, + ) + engine, err := txscript.NewEngine(prevout.PkScript, tx, 0, + txscript.StandardVerifyFlags, nil, + txscript.NewTxSigHashes(tx, fetch), prevout.Value, fetch) + if err != nil { + return err + } + return engine.Execute() +} + +// finishFallback signs with both real LND session managers and finalizes +// through the SDK, exactly as an honest validator would after approval. +func finishFallback(t *testing.T, + pkg *sdk.CustomAnchorTransferPackage) *sdk.CustomAnchorTransferPackage { + + t.Helper() + signed, err := signTestPackage(t.Context(), signingWallet(t, 2), + signingWallet(t, 3), pkg) + require.NoError(t, err) + packet, err := DecodePSBT(signed.AnchorPsbt) + require.NoError(t, err) + require.NoError(t, psbt.MaybeFinalizeAll(packet)) + raw, err := EncodePSBT(packet) + require.NoError(t, err) + final, err := pkg.WithFinalAnchorPSBT(raw) + require.NoError(t, err) + return final +} + +// TestFallbackHonestBaselineExecutes shows that the honest fallback is signed +// into a transaction that is valid for the authenticated deposit output. +func TestFallbackHonestBaselineExecutes(t *testing.T) { + f := newFallbackFixture(t) + raw, err := f.pkg.MarshalBinary() + require.NoError(t, err) + s, err := NewSwap(f.offer, f.deposit, raw) + require.NoError(t, err) + final := finishFallback(t, s.Fallback) + require.NoError(t, executeAgainst(t, final, f.prevout)) +} + +// TestFallbackRejectsForgedPrevout checks that the fallback validator binds +// the committed package's signed previous output to the authenticated deposit. +// A peer that changes only the PSBT's claimed input value keeps the unsigned +// transaction, every summary and the honest txid, so only this prevout +// comparison distinguishes it. The forged package must be rejected before it +// is ever co-signed. +func TestFallbackRejectsForgedPrevout(t *testing.T) { + f := newFallbackFixture(t) + + forged := f.pkg.Clone() + packet, err := DecodePSBT(forged.CommittedAnchorPsbt) + require.NoError(t, err) + packet.Inputs[0].WitnessUtxo = wire.NewTxOut( + f.prevout.Value+5_000, bytes.Clone(f.prevout.PkScript), + ) + anchor, err := EncodePSBT(packet) + require.NoError(t, err) + forged.CommittedAnchorPsbt = anchor + forged.AnchorPsbt = bytes.Clone(anchor) + forged.Funding.ActualFeeSat += 5_000 + forged, err = forged.Seal() + require.NoError(t, err) + raw, err := forged.MarshalBinary() + require.NoError(t, err) + + // The unsigned transaction and txid are exactly the honest ones, so the + // only tell is the committed previous output the signature covers. + honest, err := DecodePSBT(f.pkg.CommittedAnchorPsbt) + require.NoError(t, err) + require.Equal(t, honest.UnsignedTx.TxHash(), packet.UnsignedTx.TxHash()) + + _, err = NewSwap(f.offer, f.deposit, raw) + require.ErrorIs(t, err, swapkit.ErrInvalid) +} + +// TestFallbackRejectsSkipBroadcast checks that the validator rejects a package +// whose sealed publication metadata would log the fallback without broadcasting +// it. The honest package never sets this flag. +func TestFallbackRejectsSkipBroadcast(t *testing.T) { + f := newFallbackFixture(t) + require.False(t, f.pkg.Publish.SkipAnchorTxBroadcast) + + forged := f.pkg.Clone() + forged.Publish.SkipAnchorTxBroadcast = true + forged, err := forged.Seal() + require.NoError(t, err) + raw, err := forged.MarshalBinary() + require.NoError(t, err) + + _, err = NewSwap(f.offer, f.deposit, raw) + require.ErrorIs(t, err, swapkit.ErrInvalid) +} diff --git a/swapkit/tapsdk/hardening_prepare_inputs_test.go b/swapkit/tapsdk/hardening_prepare_inputs_test.go new file mode 100644 index 000000000..2ad9ab94d --- /dev/null +++ b/swapkit/tapsdk/hardening_prepare_inputs_test.go @@ -0,0 +1,82 @@ +package tapsdk + +import ( + "bytes" + "context" + "testing" + + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/btcec/v2/schnorr" + "github.com/btcsuite/btcd/txscript" + sdk "github.com/lightninglabs/tap-sdk" + "github.com/stretchr/testify/require" +) + +// declaringClient records what PrepareInputs registers with tapd. The +// proof archive already holds the input proof, so no import is attempted. +type declaringClient struct { + sdk.Client + + raw []byte + declared []sdk.ScriptKey +} + +func (c *declaringClient) GetInfo(context.Context) (*sdk.Info, error) { + return fixtureNodeInfo(), nil +} + +func (c *declaringClient) DeclareScriptKey(_ context.Context, + request *sdk.DeclareScriptKeyRequest) (*sdk.ScriptKey, error) { + + c.declared = append(c.declared, request.ScriptKey) + return &request.ScriptKey, nil +} + +func (c *declaringClient) ExportProof(context.Context, sdk.AssetRef, + sdk.PubKey, *sdk.Outpoint) (*sdk.ProofFile, error) { + + return &sdk.ProofFile{RawProofFile: bytes.Clone(c.raw)}, nil +} + +// TestPrepareInputsRejectsUnboundDescriptor checks that PrepareInputs verifies +// a caller-provided asset witness before registering it in tapd's script key +// registry. A control block that names an unrelated internal key does not +// commit to the input's script key, so declaring it would bind the script key +// to a wallet key the owner never approved. The honest witness still registers. +func TestPrepareInputsRejectsUnboundDescriptor(t *testing.T) { + f := newPathFixture(t) + + // The honest stack registers the exact key derivation. + honest := &declaringClient{raw: f.request.Inputs[0].ProofFile} + require.NoError(t, PrepareInputs(t.Context(), + sdk.NewWallet(honest, sdk.NetworkRegtest), f.request)) + require.Len(t, honest.declared, 1) + require.True(t, descriptorDerives(t, honest.declared[0])) + + // The peer keeps the agreed proof and only replaces the witness with a + // control block for its own internal key and no Merkle path. + attacker := bindingKey(7).PubKey() + control := append([]byte{byte(txscript.BaseLeafVersion)}, + schnorr.SerializePubKey(attacker)...) + request := f.request.Clone() + request.Inputs[0].Witness.Stack = [][]byte{ + {txscript.OP_TRUE}, control, + } + + // PrepareInputs rejects the witness before registering anything. + client := &declaringClient{raw: request.Inputs[0].ProofFile} + err := PrepareInputs(t.Context(), + sdk.NewWallet(client, sdk.NetworkRegtest), request) + require.Error(t, err) + require.Empty(t, client.declared) +} + +// descriptorDerives reports whether the declared raw key and tweak +// produce the declared asset script key. +func descriptorDerives(t *testing.T, key sdk.ScriptKey) bool { + t.Helper() + raw, err := btcec.ParsePubKey(key.KeyDesc.RawKeyBytes[:]) + require.NoError(t, err) + output := txscript.ComputeTaprootOutputKey(raw, key.TapTweak) + return bytes.Equal(schnorr.SerializePubKey(output), key.PubKey[1:]) +} diff --git a/swapkit/tapsdk/hardening_recovery_test.go b/swapkit/tapsdk/hardening_recovery_test.go new file mode 100644 index 000000000..600724e03 --- /dev/null +++ b/swapkit/tapsdk/hardening_recovery_test.go @@ -0,0 +1,71 @@ +package tapsdk + +import ( + "testing" + + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/btcsuite/btcd/txscript" + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + "github.com/stretchr/testify/require" +) + +// TestDiscoverOriginalRefundSurvivesStaleBlock checks that a Chain which +// returns a block without the watched spend yields a retryable error instead +// of dereferencing a nil transaction. +func TestDiscoverOriginalRefundSurvivesStaleBlock(t *testing.T) { + node, swap, _, chain := originalRefundFixture(t) + foreign := wire.NewMsgTx(2) + foreign.AddTxIn(wire.NewTxIn( + &wire.OutPoint{Hash: chainhash.Hash{0xaa}}, nil, nil, + )) + foreign.AddTxOut(wire.NewTxOut(1, []byte{txscript.OP_TRUE})) + pc := &partialRecoveryChain{ + bindingChain: chain, + spend: func(wire.OutPoint) (*wire.MsgBlock, uint32, error) { + return &wire.MsgBlock{ + Transactions: []*wire.MsgTx{foreign}, + }, 201, nil + }, + } + _, err := DiscoverOriginalRefund( + t.Context(), node.wallet(), pc, node.minConfs, swap, + ) + require.ErrorIs(t, err, swapkit.ErrPending) +} + +// TestDiscoverOriginalRefundRejectsAnnexSpend checks that an observed refund +// carrying a BIP-341 annex is identified as the agreed leaf but not +// reconstructed through a mis-sliced witness. +func TestDiscoverOriginalRefundRejectsAnnexSpend(t *testing.T) { + node, swap, refund, chain := originalRefundFixture(t) + annexed := refund.AnchorTx.Copy() + annexed.TxIn[0].Witness = append(annexed.TxIn[0].Witness, + []byte{txscript.TaprootAnnexTag}) + pc := &partialRecoveryChain{ + bindingChain: chain, + spend: func(wire.OutPoint) (*wire.MsgBlock, uint32, error) { + return &wire.MsgBlock{ + Header: refund.BlockHeader, + Transactions: []*wire.MsgTx{annexed}, + }, refund.BlockHeight, nil + }, + } + // spendsLeaf strips the annex and matches the agreed leaf, so the refund + // reaches reconstruction, which rejects the annex rather than mis-slice. + require.True(t, spendsLeaf(annexed, swap.Deposit.Contract.Output, + mustOriginalSpend(t, swap))) + _, err := DiscoverOriginalRefund( + t.Context(), node.wallet(), pc, node.minConfs, swap, + ) + require.ErrorIs(t, err, swapkit.ErrInvalid) +} + +func mustOriginalSpend(t *testing.T, + swap *SwapContext) *swapkit.SwapAnchorSpendInfo { + + t.Helper() + _, spend, err := OriginalRefundPolicy(swap.Deposit) + require.NoError(t, err) + return spend +} diff --git a/swapkit/tapsdk/hardening_reorg_test.go b/swapkit/tapsdk/hardening_reorg_test.go new file mode 100644 index 000000000..c8436f18b --- /dev/null +++ b/swapkit/tapsdk/hardening_reorg_test.go @@ -0,0 +1,77 @@ +package tapsdk + +import ( + "context" + "testing" + + "github.com/btcsuite/btcd/wire" + "github.com/lightninglabs/loop/swapkit" + "github.com/stretchr/testify/require" +) + +// reorgRaceChain keeps reporting the confirmed block hash, and serves the +// block that replaced it at the same height only to full block lookups. This +// models a reorg that lands after the last confirmation check. +type reorgRaceChain struct { + *bindingChain + + height uint32 + replaced *wire.MsgBlock +} + +func (c *reorgRaceChain) Block(ctx context.Context, + height uint32) (*wire.MsgBlock, error) { + + if height == c.height { + return c.replaced, nil + } + return c.bindingChain.Block(ctx, height) +} + +// TestVerifyOutcomeReorgIsRetryable checks that a reorg between the last +// confirmation check and the full block lookup of VerifyWalletSpend is +// reported as pending, like a reorg seen before any check, and not as a +// permanently invalid outcome. +func TestVerifyOutcomeReorgIsRetryable(t *testing.T) { + for _, refund := range []bool{false, true} { + name := hardeningClaimCase + if refund { + name = hardeningRefundCase + } + t.Run(name, func(t *testing.T) { + checkReorgRace(t, refund) + }) + } +} + +func checkReorgRace(t *testing.T, refund bool) { + t.Helper() + r, s, p, chain := bindingOutcome(t, refund) + raw := bindingRaw(t, p) + + // The untouched chain accepts the outcome. + require.NoError(t, VerifyOutcome(t.Context(), r.wallet(), chain, + 1, s, raw, refund, refund)) + + // A reorg observed before any check is classified as pending. + original := chain.blocks[160] + chain.blocks[160] = &wire.MsgBlock{ + Header: wire.BlockHeader{Nonce: 7}, + } + err := VerifyOutcome(t.Context(), r.wallet(), chain, 1, s, raw, + refund, refund) + require.ErrorIs(t, err, swapkit.ErrPending) + chain.blocks[160] = original + + // The same reorg observed only by the full block lookup, after + // both confirmation checks passed, must stay pending as well. + raced := &reorgRaceChain{bindingChain: chain, height: 160, + replaced: &wire.MsgBlock{ + Header: wire.BlockHeader{Nonce: 7}, + }} + err = VerifyOutcome(t.Context(), r.wallet(), raced, 1, s, raw, + refund, refund) + require.Error(t, err) + require.ErrorIs(t, err, swapkit.ErrPending, + "reorg race classified as: %v", err) +} diff --git a/swapkit/tapsdk/original_refund.go b/swapkit/tapsdk/original_refund.go index 3ed2e141e..09925638d 100644 --- a/swapkit/tapsdk/original_refund.go +++ b/swapkit/tapsdk/original_refund.go @@ -67,9 +67,17 @@ func DiscoverOriginalRefund(ctx context.Context, wallet *sdk.Wallet, return nil, err } tx := spendingTransaction(block, base.OutPoint()) - if len(tx.TxIn) != 1 || len(tx.TxOut) != 1 { + if tx == nil { + // A faithful Chain returns a block that spends the point, but a + // stale or inconsistent response must not panic the recovery. return nil, swapkit.ErrPending } + // A confirmed spend with extra inputs or outputs cannot be rebuilt into + // a single-input recovery proof and never will be, so it is terminal. + // DiscoverOutcome classifies the same shape identically. + if len(tx.TxIn) != 1 || len(tx.TxOut) != 1 { + return nil, swapkit.ErrInvalid + } if !spendsLeaf(tx, c.Output, spend) { return nil, swapkit.ErrPending } diff --git a/swapkit/tapsdk/proofs.go b/swapkit/tapsdk/proofs.go index cf0008931..97430345f 100644 --- a/swapkit/tapsdk/proofs.go +++ b/swapkit/tapsdk/proofs.go @@ -459,6 +459,21 @@ func declareOPTrue(ctx context.Context, wallet *sdk.Wallet, if err != nil { return err } + // A caller-provided witness is peer input. Declaring it binds the asset + // script key to this internal key and tweak in tapd's wallet, so verify + // that the leaf and control block actually commit to the script key + // before registering it. This accepts both the legacy NUMS tree and an + // SDK supplied-key tree; it rejects a witness whose control block names + // an unrelated internal key. + spend := &sdk.CustomAssetOPTrueSpendInfo{ + LeafScript: bytes.Clone(witness[0]), + LeafVersion: uint8(control.LeafVersion), + ControlBlock: bytes.Clone(witness[1]), + InternalKey: internal, + } + if err := spend.Validate(scriptKey); err != nil { + return err + } _, err = wallet.Client(). DeclareScriptKey(ctx, &sdk.DeclareScriptKeyRequest{ ScriptKey: sdk.ScriptKey{PubKey: scriptKey, diff --git a/swapkit/tapsdk/recovery.go b/swapkit/tapsdk/recovery.go index 6747d5966..a132bc8d9 100644 --- a/swapkit/tapsdk/recovery.go +++ b/swapkit/tapsdk/recovery.go @@ -80,6 +80,11 @@ func DiscoverOutcome(ctx context.Context, wallet *sdk.Wallet, return nil, err } found := spendingTransaction(block, point) + if found == nil { + // A faithful Chain returns a block that spends the point, but a + // stale or inconsistent response must not panic the recovery. + return nil, swapkit.ErrPending + } if len(found.TxIn) != 1 || len(found.TxOut) != 1 { return nil, swapkit.ErrInvalid } @@ -192,7 +197,11 @@ func DiscoverPreimage(ctx context.Context, chain Chain, if err != nil { return swapkit.PreimageResult{}, err } - for _, input := range spendingTransaction(block, point).TxIn { + found := spendingTransaction(block, point) + if found == nil { + return swapkit.PreimageResult{}, nil + } + for _, input := range found.TxIn { if input.PreviousOutPoint != point { continue } diff --git a/swapkit/tapsdk/wallet_spend.go b/swapkit/tapsdk/wallet_spend.go index 9f47dc634..93aff111f 100644 --- a/swapkit/tapsdk/wallet_spend.go +++ b/swapkit/tapsdk/wallet_spend.go @@ -30,6 +30,16 @@ func rebuildObservedSpend( return nil, swapkit.ErrInvalid } + // Reconstruction replays the mined script-path stack minus its leaf and + // control block. A BIP-341 annex would shift those two elements, so the + // reconstructed witness would carry the wrong stack. An observed annex + // spend is rare and not reconstructable here, so reject it up front + // rather than mis-slice it. + if len(observed.TxIn[0].Witness) != + len(witnessWithoutAnnex(observed.TxIn[0].Witness)) { + + return nil, swapkit.ErrInvalid + } p, err := LastProof(inputProof) if err != nil { return nil, err @@ -137,6 +147,14 @@ func VerifyWalletSpend( if err != nil { return err } + // verifyProof confirmed the proof against the chain, but a reorg between + // that check and this re-read would replace the block at this height. + // Without the agreed transaction the loop below falls through to + // ErrInvalid; report the reorg as retryable instead, matching every other + // stale-evidence path. + if block.BlockHash() != p.BlockHeader.BlockHash() { + return swapkit.ErrPending + } for _, tx := range block.Transactions { if tx.TxHash() != p.AnchorTx.TxHash() { continue @@ -167,7 +185,20 @@ func spendsLeaf(tx *wire.MsgTx, prior sdk.CustomAnchorAssetOutputSummary, return false } - w := tx.TxIn[0].Witness + w := witnessWithoutAnnex(tx.TxIn[0].Witness) return len(w) >= 3 && bytes.Equal(w[len(w)-2], spend.LeafScript) && bytes.Equal(w[len(w)-1], spend.ControlBlock) } + +// witnessWithoutAnnex drops a BIP-341 annex. A taproot witness carries an annex +// when its final element begins with the annex tag and at least one other +// element precedes it. The annex is not part of the script-path stack, so the +// agreed leaf and control block are the last two elements once it is removed. +func witnessWithoutAnnex(w [][]byte) [][]byte { + if len(w) >= 2 && len(w[len(w)-1]) > 0 && + w[len(w)-1][0] == txscript.TaprootAnnexTag { + + return w[:len(w)-1] + } + return w +}