From 2ac6eafed928a33f9fbcf364955b894efaf69a95 Mon Sep 17 00:00:00 2001 From: Aditya Tiwari Date: Wed, 18 Nov 2026 16:00:34 +0530 Subject: [PATCH] fix(sdk-coin-canton): verify split transactions as a batch On EdDSA MPCv2 wallets a Canton UTXO split failed client-side, before any signing round, in two stages. 1. wallet.signAndSendTxRequest passes no txParams, so resolveEffectiveTxParams (sdk-core) rebuilds recipients from the persisted intent. It read recipient.address.address, which is undefined when the client stores the address as a plain string (the retail split does), and Canton verifyTransaction then crashed with "Cannot read properties of undefined (reading 'split')". Accept both the { address } object and a plain string, and copy numberOfSplits from the intent into the effective txParams (like executorPartyId) so a coin verifier can validate the split count. Adds numberOfSplits to TransactionParams and PopulatedIntent. 2. IMS builds a split as one root WalletUserProxy_BatchTransfer whose children are numberOfSplits TransferFactory_Transfer self-transfers. verifyTransaction only parsed the first transfer and compared it with the intent amount (the full value of the selected unspents), so it failed with "Tx outputs do not match with expected txParams recipients". Only the first transfer was ever inspected, so further transfers in a batch were unverified too. When txParams.numberOfSplits > 1, verify the whole batch: parseBatchTransfers returns every transfer and throws unless the transaction has a single BatchTransfer root whose children are all TransferFactory_Transfer. Each transfer must go from the wallet's own address to itself, carry the expected token, and the transfer count must equal numberOfSplits. The total must be within less than numberOfSplits atomic units of the intent amount to allow for rounding dust. numberOfSplits of 0 or 1 keep the existing recipient-matching path. A recipient without an address now fails with a clear error instead of the TypeError. Tests use captured staging/test txRequests for a native split, a token split and a multi-input token split, plus tampering cases (a transfer rewritten to a foreign party, wrong count, amount, wallet or token). Ticket: CHALO-2192 Co-Authored-By: Claude --- modules/sdk-coin-canton/src/canton.ts | 59 ++++ modules/sdk-coin-canton/src/lib/iface.ts | 9 + modules/sdk-coin-canton/src/lib/utils.ts | 69 ++++ modules/sdk-coin-canton/test/splitFixtures.ts | 100 ++++++ .../test/unit/splitVerification.ts | 306 ++++++++++++++++++ .../sdk-core/src/bitgo/baseCoin/iBaseCoin.ts | 2 + .../sdk-core/src/bitgo/utils/tss/baseTypes.ts | 2 + .../src/bitgo/utils/tss/recipientUtils.ts | 16 +- .../unit/bitgo/utils/tss/recipientUtils.ts | 39 +++ 9 files changed, 601 insertions(+), 1 deletion(-) create mode 100644 modules/sdk-coin-canton/test/splitFixtures.ts create mode 100644 modules/sdk-coin-canton/test/unit/splitVerification.ts diff --git a/modules/sdk-coin-canton/src/canton.ts b/modules/sdk-coin-canton/src/canton.ts index df08b33e82..ecb509c0da 100644 --- a/modules/sdk-coin-canton/src/canton.ts +++ b/modules/sdk-coin-canton/src/canton.ts @@ -28,6 +28,7 @@ import { VerifyTransactionOptions, } from '@bitgo/sdk-core'; import { auditEddsaPrivateKey } from '@bitgo/sdk-lib-mpc'; +import BigNumber from 'bignumber.js'; import { BaseCoin as StaticsBaseCoin, coins } from '@bitgo/statics'; import { TransactionBuilderFactory } from './lib'; import { KeyPair as CantonKeyPair } from './lib/keyPair'; @@ -221,9 +222,15 @@ export class Canton extends BaseCoin { } return true; case TransactionType.Send: + if (txParams.numberOfSplits !== undefined && txParams.numberOfSplits > 1) { + return this.verifySplitTransaction(transaction, txParams, params.wallet); + } if (txParams.recipients !== undefined) { const filteredRecipients = txParams.recipients?.map((recipient) => { const { address, amount, tokenName } = recipient; + if (!address) { + throw new Error('Recipient address is required to verify a Canton transfer'); + } const [addressPart, memoId] = address.split('?memoId='); return { address: addressPart, @@ -251,6 +258,58 @@ export class Canton extends BaseCoin { } } } + /** + * A split (fanout) moves value from the wallet to itself: one batch of `numberOfSplits` self-transfers. + * The intent carries the full amount of the selected unspents, so the transaction is verified as a whole + * rather than against its first transfer. + */ + private verifySplitTransaction( + transaction: BaseTransaction, + txParams: TransactionParams, + wallet: VerifyTransactionOptions['wallet'] + ): boolean { + const numberOfSplits = txParams.numberOfSplits as number; + const rawPrepared = (transaction as Transaction).prepareCommand?.preparedTransaction; + if (!rawPrepared) { + throw new Error('Split verifyTransaction: missing preparedTransaction protobuf'); + } + if (txParams.recipients?.length !== 1) { + throw new Error('Split verifyTransaction: expected exactly one recipient'); + } + const { address, amount, tokenName } = txParams.recipients[0]; + if (!address) { + throw new Error('Recipient address is required to verify a Canton split'); + } + const [expectedParty] = address.split('?memoId='); + const walletRootAddress = wallet?.coinSpecific?.()?.rootAddress; + if (walletRootAddress && walletRootAddress.split('?memoId=')[0] !== expectedParty) { + throw new Error(`Split recipient '${expectedParty}' is not the wallet's own address`); + } + // A token coin instance resolves its token from the coin itself; native Canton Coin has none. + const expectedToken = tokenName ?? (coins.get(this.getChain()).isToken ? this.getChain() : undefined); + + const transfers = utils.parseBatchTransfers(rawPrepared); + if (transfers.length !== numberOfSplits) { + throw new Error(`Split transaction has ${transfers.length} transfers, expected ${numberOfSplits}`); + } + let total = new BigNumber(0); + for (const transfer of transfers) { + if (transfer.sender !== expectedParty || transfer.receiver !== expectedParty) { + throw new Error('Split transaction transfers funds to a party other than the wallet itself'); + } + if (transfer.token !== expectedToken) { + throw new Error(`Split transaction token '${transfer.token}' does not match expected '${expectedToken}'`); + } + total = total.plus(transfer.amount); + } + // Equal-value outputs may leave less than one atomic unit per split of rounding dust in the change holding. + const unsplit = new BigNumber(amount).minus(total); + if (unsplit.isNegative() || unsplit.gte(numberOfSplits)) { + throw new Error(`Split transaction total ${total.toFixed()} does not match expected amount ${amount}`); + } + return true; + } + private verifyBroadridgeStandingDelegationTransaction( transaction: BaseTransaction, executorPartyId: string diff --git a/modules/sdk-coin-canton/src/lib/iface.ts b/modules/sdk-coin-canton/src/lib/iface.ts index c3acbc4454..be5b35b9ab 100644 --- a/modules/sdk-coin-canton/src/lib/iface.ts +++ b/modules/sdk-coin-canton/src/lib/iface.ts @@ -55,6 +55,15 @@ export interface PreparedTxnParsedInfo { broadridgeSettlementAuthorizationData?: BroadridgeSettlementAuthorizationData; } +export interface PreparedTransferInfo { + sender: string; + receiver: string; + /** Amount in the lowest unit of the asset. */ + amount: string; + /** Token name; absent for native Canton Coin. */ + token?: string; +} + export interface BroadridgeSettlementIdentity { executor?: string; executors?: string[]; diff --git a/modules/sdk-coin-canton/src/lib/utils.ts b/modules/sdk-coin-canton/src/lib/utils.ts index 843e33a269..1d63e77144 100644 --- a/modules/sdk-coin-canton/src/lib/utils.ts +++ b/modules/sdk-coin-canton/src/lib/utils.ts @@ -13,6 +13,7 @@ import { BroadridgeSettlementAuthorizationData, CantonCommandInfo, PreparedTransaction as IPreparedTransaction, + PreparedTransferInfo, PreparedTxnParsedInfo, } from './iface'; import { @@ -681,6 +682,74 @@ export class Utils implements BaseUtils { return parsedData; } + /** + * Returns every transfer of a split (fanout) transaction, which is a single root WalletUserProxy_BatchTransfer + * whose children are all TransferFactory_Transfer exercises. Throws on any other shape so a caller never + * verifies a partial view of what the transaction moves. + */ + parseBatchTransfers(rawData: string): PreparedTransferInfo[] { + const decoded = this.decodePreparedTransaction(rawData); + const nodes = decoded.transaction?.nodes ?? []; + const roots = decoded.transaction?.roots ?? []; + const getField = (fields: RecordField[], label: string) => fields.find((f) => f.label === label)?.value?.sum; + const getExercise = (nodeId: string) => { + const versioned = nodes.find((n) => n.nodeId === nodeId)?.versionedNode; + if (!versioned || versioned.oneofKind !== 'v1') return undefined; + const nodeType = versioned.v1.nodeType; + return nodeType.oneofKind === 'exercise' ? nodeType.exercise : undefined; + }; + + if (roots.length !== 1) { + throw new Error(`invalid split transaction: expected a single root node, got ${roots.length}`); + } + const batch = getExercise(roots[0]); + if (batch?.choiceId !== 'WalletUserProxy_BatchTransfer') { + throw new Error('invalid split transaction: root node is not a batch transfer'); + } + + return batch.children.map((childId) => { + const child = getExercise(childId); + if (child?.choiceId !== 'TransferFactory_Transfer') { + throw new Error('invalid split transaction: batch contains a node that is not a transfer'); + } + const argument = child.chosenValue?.sum; + const transferSum = + argument?.oneofKind === 'record' ? getField(argument.record?.fields ?? [], 'transfer') : undefined; + if (transferSum?.oneofKind !== 'record') { + throw new Error('invalid split transaction: transfer record is missing'); + } + const transfer = transferSum.record?.fields ?? []; + const senderSum = getField(transfer, 'sender'); + const receiverSum = getField(transfer, 'receiver'); + const amountSum = getField(transfer, 'amount'); + const instrumentSum = getField(transfer, 'instrumentId'); + if ( + senderSum?.oneofKind !== 'party' || + receiverSum?.oneofKind !== 'party' || + amountSum?.oneofKind !== 'numeric' || + instrumentSum?.oneofKind !== 'record' + ) { + throw new Error('invalid split transaction: transfer is missing sender, receiver, amount or instrument'); + } + const instrument = instrumentSum.record?.fields ?? []; + const adminSum = getField(instrument, 'admin'); + const idSum = getField(instrument, 'id'); + const info: PreparedTransferInfo = { + sender: senderSum.party, + receiver: receiverSum.party, + amount: this.convertAmountToLowestUnit(new BigNumber(amountSum.numeric)), + }; + if ( + adminSum?.oneofKind === 'party' && + idSum?.oneofKind === 'text' && + !this.isNativeInstrument(adminSum.party, idSum.text) + ) { + info.token = this.findTokenNameByContractAddress(`${adminSum.party}:${idSum.text}`); + } + return info; + }); + } + /** Parses `"Pkg:Module:Entity"` into parts. */ parseCantonTemplateId(value: string): { pkg: string; moduleName: string; entityName: string } | undefined { if (typeof value !== 'string') return undefined; diff --git a/modules/sdk-coin-canton/test/splitFixtures.ts b/modules/sdk-coin-canton/test/splitFixtures.ts new file mode 100644 index 0000000000..2dda012efc --- /dev/null +++ b/modules/sdk-coin-canton/test/splitFixtures.ts @@ -0,0 +1,100 @@ +// Captured from a staging Canton token split (tcanton:tc1, numberOfSplits=2, one 0.5 UTXO -> two 0.25 holdings). +// serializedTxHex is slimmed to the fields Canton's parser reads; the on-ledger payload is a WalletUserProxy_BatchTransfer. +export const CantonSplitTxRequest = { + txRequestId: '00000000-0000-0000-0000-000000000000', + walletId: '000000000000000000000000000000aa', + apiVersion: 'full', + intent: { + intentType: 'payment', + recipients: [ + { + address: '1220f::1220fc3e354c3c7119d4746c2381e5d1bea0d44c3055eb4f0603f1a5f33a106e2f9f', + amount: { + value: '5000000000', + symbol: 'tcanton:tc1', + }, + }, + ], + unspents: [ + '008ecce55cd4f8d5380e09edf05b70dd4de2cc13348ba94aeefbfafd65d50def02ca1212206e8ff441eee5599aeeda950e8560c312c79f817e78b29e746e018c403906798b', + ], + numberOfSplits: 2, + }, + transactions: [ + { + unsignedTx: { + serializedTxHex: + '{"prepareCommandResponse": {"preparedTransaction": "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", "preparedTransactionHash": "0CwozABgkzcbH26lwq3/mblVXBHDfeoBaN9m9x4Lq6M=", "hashingSchemeVersion": "HASHING_SCHEME_VERSION_V2"}, "txType": "Send", "submissionId": "4a83d0ea-4669-4354-a84d-50f0f3088286"}', + signableHex: 'd02c28cc006093371b1f6ea5c2adff99b9555c11c37dea0168df66f71e0baba3', + derivationPath: 'm/0', + }, + }, + ], +}; + +// Captured from a test-env native tcanton split (numberOfSplits=2, one 1.0 Canton Coin UTXO -> two 0.5 holdings). +export const CantonNativeSplitTxRequest = { + txRequestId: '00000000-0000-0000-0000-000000000001', + walletId: '000000000000000000000000000000bb', + apiVersion: 'full', + intent: { + intentType: 'payment', + recipients: [ + { + address: '12208::12208009960043f9db4aedbed5fb1a19161d2b8644d4a08470aad6ebea3e4c2af05b', + amount: { + value: '10000000000', + symbol: 'tcanton', + }, + }, + ], + unspents: [ + '000b68fa879367f8c691d26540c0b9f63ecb126a2d393ea6f9645bd0acab585cd0ca121220552fc6156735096234dbd457f83404984f051b5c312c4ca670edabeb90ae231e', + ], + numberOfSplits: 2, + }, + transactions: [ + { + unsignedTx: { + serializedTxHex: + '{"prepareCommandResponse": {"preparedTransaction": "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", "preparedTransactionHash": "XLil/EHFBQGTb+xDpwotGqlUGBAZkxDy3hz1qSvOvn0=", "hashingSchemeVersion": "HASHING_SCHEME_VERSION_V2"}, "txType": "Send", "submissionId": "51027169-7166-4005-a389-7427d59aad33"}', + signableHex: '5cb8a5fc41c50501936fec43a70a2d1aa9541810199310f2de1cf5a92bcebe7d', + derivationPath: 'm/0', + }, + }, + ], +}; + +// Captured from a test-env USDCx split: two input UTXOs (8.0 total) split four ways (numberOfSplits=4). +export const CantonUsdcxMultiInputSplitTxRequest = { + txRequestId: '00000000-0000-0000-0000-000000000002', + walletId: '000000000000000000000000000000cc', + apiVersion: 'full', + intent: { + intentType: 'payment', + recipients: [ + { + address: '12208::12208009960043f9db4aedbed5fb1a19161d2b8644d4a08470aad6ebea3e4c2af05b', + amount: { + value: '8000000000', + symbol: 'tcanton:usdcx', + }, + }, + ], + unspents: [ + '0023bb2a066896a44b6e81808f8e032908251aab67d7f575dacbdb2c8ba7791ac8ca121220cc84026e081189e059c75cce86c6d7d4266b0b7ecaef309f8d715dec09a417d2', + '00eb15f90f3c2b0d800f9e085e4ae9a0e09c4ea5246abf46839b60b477af7781a7ca121220200c214b8f5a7c6579dd2dce1b8f2136eac89a932406173b7573ce8136bf905d', + ], + numberOfSplits: 4, + }, + transactions: [ + { + unsignedTx: { + serializedTxHex: + '{"prepareCommandResponse": {"preparedTransaction": "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", "preparedTransactionHash": "P1Nq7isIuhFKIozp8su2Ii4piszYxBkRNS5HsnfgzKU=", "hashingSchemeVersion": "HASHING_SCHEME_VERSION_V2"}, "txType": "Send", "submissionId": "af60d791-8908-4a59-a53f-ee54f7c13d91"}', + signableHex: '3f536aee2b08ba114a228ce9f2cbb6222e298accd8c41911352e47b277e0cca5', + derivationPath: 'm/0', + }, + }, + ], +}; diff --git a/modules/sdk-coin-canton/test/unit/splitVerification.ts b/modules/sdk-coin-canton/test/unit/splitVerification.ts new file mode 100644 index 0000000000..c4873a2867 --- /dev/null +++ b/modules/sdk-coin-canton/test/unit/splitVerification.ts @@ -0,0 +1,306 @@ +import 'should'; +import { BitGoAPI } from '@bitgo/sdk-api'; +import { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test'; +import { IWallet, resolveEffectiveTxParams, TransactionParams, TxRequest } from '@bitgo/sdk-core'; +import { tokens } from '@bitgo/statics'; + +import { Canton, CantonToken, Tcanton } from '../../src'; +import utils from '../../src/lib/utils'; +import { PreparedTransaction } from '../../resources/proto/preparedTransaction'; +import { + CantonNativeSplitTxRequest, + CantonSplitTxRequest, + CantonUsdcxMultiInputSplitTxRequest, +} from '../splitFixtures'; + +const TOKEN_COIN = 'tcanton:tc1'; + +describe('Canton split (fanout) txRequest verification at signing time', function () { + let bitgo: TestBitGoAPI; + let nativeCoin: Tcanton; + let tokenCoin: CantonToken; + + const txRequest = CantonSplitTxRequest as unknown as TxRequest; + const unsignedTx = CantonSplitTxRequest.transactions[0].unsignedTx; + const intentRecipient = CantonSplitTxRequest.intent.recipients[0]; + const wallet = { + coinSpecific: () => ({ rootAddress: intentRecipient.address }), + multisigType: () => 'tss', + } as unknown as IWallet; + + before(function () { + bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' }); + bitgo.safeRegister('canton', Canton.createInstance); + bitgo.safeRegister('tcanton', Tcanton.createInstance); + const tokenConfig = tokens.testnet.canton.tokens.find((t) => t.type === TOKEN_COIN); + if (!tokenConfig) { + throw new Error(`${TOKEN_COIN} not found in statics`); + } + bitgo.safeRegister(TOKEN_COIN, CantonToken.createTokenConstructor(tokenConfig)); + bitgo.initializeTestVars(); + nativeCoin = bitgo.coin('tcanton') as Tcanton; + tokenCoin = bitgo.coin(TOKEN_COIN) as CantonToken; + }); + + // Same two calls EddsaMPCv2Utils.signRequestBase makes, with the txParams that + // wallet.signAndSendTxRequest passes (none). + async function verifyLikeSignRequestBase(coin: Tcanton | CantonToken, callerTxParams?: TransactionParams) { + const txParams = resolveEffectiveTxParams(txRequest, callerTxParams, coin.getChain()); + return coin.verifyTransaction({ + txPrebuild: { txHex: unsignedTx.serializedTxHex }, + txParams, + wallet, + walletType: 'tss', + }); + } + + describe('what the fixture looks like to the SDK', function () { + it('parses a two-way split as a single 2.5B output while the intent amount is the full 5B', async function () { + const explained = await tokenCoin.explainTransaction({ txHex: unsignedTx.serializedTxHex }); + explained.outputs.length.should.equal(1); + explained.outputs[0].amount.should.equal('2500000000'); + intentRecipient.amount.value.should.equal('5000000000'); + CantonSplitTxRequest.intent.numberOfSplits.should.equal(2); + }); + + it('stores the intent recipient address as a plain string', function () { + (typeof intentRecipient.address).should.equal('string'); + }); + }); + + describe('signAndSendTxRequest path (no txParams from the caller)', function () { + // Regression: resolveEffectiveTxParams used to read recipient.address.address (undefined for a string address), + // then Canton verifyTransaction crashed calling address.split('?memoId=') on it. + it('token coin: verifies a split txRequest built by wallet-platform', async function () { + const result = await verifyLikeSignRequestBase(tokenCoin); + result.should.equal(true); + }); + + it('native coin: verifies a split txRequest built by wallet-platform', async function () { + const result = await verifyLikeSignRequestBase(nativeCoin); + result.should.equal(true); + }); + }); + + describe('rejects splits that do not match the intent', function () { + const baseTxParams = (overrides: Partial = {}): TransactionParams => + ({ + type: 'payment', + numberOfSplits: 2, + recipients: [{ address: intentRecipient.address, amount: intentRecipient.amount.value, tokenName: TOKEN_COIN }], + ...overrides, + } as TransactionParams); + + const verify = (txParams: TransactionParams, txHex = unsignedTx.serializedTxHex, w: IWallet = wallet) => + tokenCoin.verifyTransaction({ txPrebuild: { txHex }, txParams, wallet: w, walletType: 'tss' }); + + // Rewrites the receiver of the last transfer in the batch and re-encodes the prepared transaction. + function withForeignReceiverOnLastTransfer(txHex: string, foreignParty: string): string { + const outer = JSON.parse(Buffer.from(txHex, 'base64').toString()); + const decoded = PreparedTransaction.fromBinary( + Buffer.from(outer.prepareCommandResponse.preparedTransaction, 'base64') + ); + const transferNodeFields = (decoded.transaction?.nodes ?? []).flatMap((node) => { + const versioned = node.versionedNode; + if (versioned.oneofKind !== 'v1' || versioned.v1.nodeType.oneofKind !== 'exercise') return []; + const exercise = versioned.v1.nodeType.exercise; + const argument = exercise.chosenValue?.sum; + if (exercise.choiceId !== 'TransferFactory_Transfer' || argument?.oneofKind !== 'record') return []; + const transfer = argument.record?.fields.find((f) => f.label === 'transfer')?.value?.sum; + return transfer?.oneofKind === 'record' ? [transfer.record?.fields ?? []] : []; + }); + const lastTransfer = transferNodeFields[transferNodeFields.length - 1]; + const receiver = lastTransfer.find((f) => f.label === 'receiver')?.value; + if (!receiver) throw new Error('fixture has no receiver to tamper with'); + receiver.sum = { oneofKind: 'party', party: foreignParty }; + outer.prepareCommandResponse.preparedTransaction = Buffer.from(PreparedTransaction.toBinary(decoded)).toString( + 'base64' + ); + return Buffer.from(JSON.stringify(outer)).toString('base64'); + } + + it('accepts the untouched fixture (control for the tampering cases)', async function () { + (await verify(baseTxParams())).should.equal(true); + }); + + it('rejects a batch where one transfer goes to another party', async function () { + const foreignParty = `attacker::${'1'.repeat(68)}`; + const tampered = withForeignReceiverOnLastTransfer(unsignedTx.serializedTxHex, foreignParty); + await verify(baseTxParams(), tampered).should.be.rejectedWith(/other than the wallet itself/); + }); + + it('rejects when the number of transfers differs from numberOfSplits', async function () { + await verify(baseTxParams({ numberOfSplits: 3 })).should.be.rejectedWith(/has 2 transfers, expected 3/); + }); + + it('rejects when the transfers move more than the intent amount', async function () { + const recipients = [{ address: intentRecipient.address, amount: '4000000000', tokenName: TOKEN_COIN }]; + await verify(baseTxParams({ recipients })).should.be.rejectedWith(/does not match expected amount/); + }); + + it('rejects when the recipient is not the wallet own address', async function () { + const otherWallet = { + coinSpecific: () => ({ rootAddress: `other::${'2'.repeat(68)}` }), + multisigType: () => 'tss', + } as unknown as IWallet; + await verify(baseTxParams(), unsignedTx.serializedTxHex, otherWallet).should.be.rejectedWith( + /not the wallet's own address/ + ); + }); + + it('rejects when the transfers are not of the expected token', async function () { + const recipients = [ + { address: intentRecipient.address, amount: intentRecipient.amount.value, tokenName: 'tcanton:other' }, + ]; + await verify(baseTxParams({ recipients })).should.be.rejectedWith(/does not match expected/); + }); + + [0, 1, undefined].forEach((numberOfSplits) => { + it(`keeps the original recipient-matching path when numberOfSplits is ${numberOfSplits}`, async function () { + // A batch of two 2.5B transfers must NOT pass as a plain send of 5B: only a real split (>1) is verified as a batch. + await verify(baseTxParams({ numberOfSplits })).should.be.rejectedWith( + /Tx outputs do not match with expected txParams recipients/ + ); + }); + }); + + it('rejects a recipient without an address with a clear error instead of a TypeError', async function () { + const recipients = [ + { address: undefined, amount: '1', tokenName: TOKEN_COIN }, + ] as unknown as TransactionParams['recipients']; + await verify(baseTxParams({ recipients, numberOfSplits: undefined })).should.be.rejectedWith( + /Recipient address is required/ + ); + }); + }); + + describe('second failure behind the TypeError', function () { + // Regression: failed with "Tx outputs do not match with expected txParams recipients" because the SDK + // only read the first transfer of the BatchTransfer (2.5B) while the intent amount is the full 5B. + it('verifies when the recipient address is already resolved correctly', async function () { + const txParams = { + type: 'payment', + numberOfSplits: CantonSplitTxRequest.intent.numberOfSplits, + recipients: [{ address: intentRecipient.address, amount: intentRecipient.amount.value, tokenName: TOKEN_COIN }], + } as TransactionParams; + const result = await tokenCoin.verifyTransaction({ + txPrebuild: { txHex: unsignedTx.serializedTxHex }, + txParams, + wallet, + walletType: 'tss', + }); + result.should.equal(true); + }); + }); + + describe('native Canton Coin split (test-env capture)', function () { + const nativeRequest = CantonNativeSplitTxRequest as unknown as TxRequest; + const nativeTx = CantonNativeSplitTxRequest.transactions[0].unsignedTx; + const nativeRecipient = CantonNativeSplitTxRequest.intent.recipients[0]; + const nativeWallet = { + coinSpecific: () => ({ rootAddress: nativeRecipient.address }), + multisigType: () => 'tss', + } as unknown as IWallet; + + const verifyNative = (txParams: TransactionParams, w: IWallet = nativeWallet) => + nativeCoin.verifyTransaction({ + txPrebuild: { txHex: nativeTx.serializedTxHex }, + txParams, + wallet: w, + walletType: 'tss', + }); + + it('verifies the txRequest on the signAndSendTxRequest path (intent only)', async function () { + const txParams = resolveEffectiveTxParams(nativeRequest, undefined, nativeCoin.getChain()); + txParams.numberOfSplits?.should.equal(2); + (await verifyNative(txParams)).should.equal(true); + }); + + it('parses both transfers of the batch as self-transfers of half the UTXO', function () { + const transfers = utils.parseBatchTransfers( + JSON.parse(Buffer.from(nativeTx.serializedTxHex, 'base64').toString()).prepareCommandResponse + .preparedTransaction + ); + transfers.should.have.length(2); + transfers.forEach((transfer) => { + transfer.sender.should.equal(nativeRecipient.address); + transfer.receiver.should.equal(nativeRecipient.address); + transfer.amount.should.equal('5000000000'); + (transfer.token === undefined).should.equal(true); + }); + }); + + it('rejects a native split verified as a token split', async function () { + const txParams = resolveEffectiveTxParams(nativeRequest, undefined, nativeCoin.getChain()); + const tokenRecipients = [ + { ...txParams.recipients?.[0], tokenName: TOKEN_COIN }, + ] as TransactionParams['recipients']; + await verifyNative({ ...txParams, recipients: tokenRecipients }).should.be.rejectedWith( + /does not match expected/ + ); + }); + + it('rejects when the intent amount exceeds what the batch moves by a full split', async function () { + const txParams = resolveEffectiveTxParams(nativeRequest, undefined, nativeCoin.getChain()); + const recipients = [{ ...txParams.recipients?.[0], amount: '10000000002' }] as TransactionParams['recipients']; + await verifyNative({ ...txParams, recipients }).should.be.rejectedWith(/does not match expected amount/); + }); + }); + + describe('USDCx split of multiple input UTXOs into four (test-env capture)', function () { + const usdcxRequest = CantonUsdcxMultiInputSplitTxRequest as unknown as TxRequest; + const usdcxTx = CantonUsdcxMultiInputSplitTxRequest.transactions[0].unsignedTx; + const usdcxRecipient = CantonUsdcxMultiInputSplitTxRequest.intent.recipients[0]; + const usdcxWallet = { + coinSpecific: () => ({ rootAddress: usdcxRecipient.address }), + multisigType: () => 'tss', + } as unknown as IWallet; + let usdcxCoin: CantonToken; + + before(function () { + const tokenConfig = tokens.testnet.canton.tokens.find((t) => t.type === 'tcanton:usdcx'); + if (!tokenConfig) { + throw new Error('tcanton:usdcx not found in statics'); + } + bitgo.safeRegister('tcanton:usdcx', CantonToken.createTokenConstructor(tokenConfig)); + usdcxCoin = bitgo.coin('tcanton:usdcx') as CantonToken; + }); + + const verifyUsdcx = (txParams: TransactionParams) => + usdcxCoin.verifyTransaction({ + txPrebuild: { txHex: usdcxTx.serializedTxHex }, + txParams, + wallet: usdcxWallet, + walletType: 'tss', + }); + + it('has several input unspents and a split count larger than the input count', function () { + CantonUsdcxMultiInputSplitTxRequest.intent.unspents.length.should.equal(2); + CantonUsdcxMultiInputSplitTxRequest.intent.numberOfSplits.should.equal(4); + }); + + it('verifies the txRequest on the signAndSendTxRequest path (intent only)', async function () { + const txParams = resolveEffectiveTxParams(usdcxRequest, undefined, usdcxCoin.getChain()); + txParams.numberOfSplits?.should.equal(4); + (await verifyUsdcx(txParams)).should.equal(true); + }); + + it('parses four equal self-transfers that add up to the full input value', function () { + const transfers = utils.parseBatchTransfers( + JSON.parse(Buffer.from(usdcxTx.serializedTxHex, 'base64').toString()).prepareCommandResponse.preparedTransaction + ); + transfers.should.have.length(4); + transfers.forEach((transfer) => { + transfer.sender.should.equal(usdcxRecipient.address); + transfer.receiver.should.equal(usdcxRecipient.address); + transfer.amount.should.equal('2000000000'); + transfer.token?.should.equal('tcanton:usdcx'); + }); + }); + + it('rejects when the split count does not match the number of transfers', async function () { + const txParams = resolveEffectiveTxParams(usdcxRequest, undefined, usdcxCoin.getChain()); + await verifyUsdcx({ ...txParams, numberOfSplits: 5 }).should.be.rejectedWith(/has 4 transfers, expected 5/); + }); + }); +}); diff --git a/modules/sdk-core/src/bitgo/baseCoin/iBaseCoin.ts b/modules/sdk-core/src/bitgo/baseCoin/iBaseCoin.ts index cb4ec7f61c..5d18c248ad 100644 --- a/modules/sdk-core/src/bitgo/baseCoin/iBaseCoin.ts +++ b/modules/sdk-core/src/bitgo/baseCoin/iBaseCoin.ts @@ -292,6 +292,8 @@ export interface TransactionParams { wrapParams?: { tokenName: string; amount: string }; /** External settlement executor party ID for Canton standing delegation intents. */ executorPartyId?: string; + /** Canton split (fanout): number of equal-value holdings the selected unspents are split into. */ + numberOfSplits?: number; } export interface AddressVerificationData { diff --git a/modules/sdk-core/src/bitgo/utils/tss/baseTypes.ts b/modules/sdk-core/src/bitgo/utils/tss/baseTypes.ts index b51ab61b47..1bdca39d15 100644 --- a/modules/sdk-core/src/bitgo/utils/tss/baseTypes.ts +++ b/modules/sdk-core/src/bitgo/utils/tss/baseTypes.ts @@ -488,6 +488,8 @@ export interface PopulatedIntentForTypedDataSigning extends PopulatedIntentBase export interface PopulatedIntent extends PopulatedIntentBase, DefiIntentFields { stakingRequestId?: string; recipients?: IntentRecipient[]; + /** Canton split (fanout): number of equal-value holdings the unspents are split into. */ + numberOfSplits?: number; nonce?: string; token?: string; enableTokens?: TokenEnablement[]; diff --git a/modules/sdk-core/src/bitgo/utils/tss/recipientUtils.ts b/modules/sdk-core/src/bitgo/utils/tss/recipientUtils.ts index a0cef012ac..a08a1d94b1 100644 --- a/modules/sdk-core/src/bitgo/utils/tss/recipientUtils.ts +++ b/modules/sdk-core/src/bitgo/utils/tss/recipientUtils.ts @@ -105,6 +105,14 @@ export const NO_RECIPIENT_TX_TYPES = new Set([ 'authorize', ]); +/** + * The SDK persists intent recipient addresses as `{ address }`, but txRequests created by other clients + * (e.g. the retail UI's Canton split) store a plain string. Accept both. + */ +function getIntentRecipientAddress(address: string | { address: string } | undefined): string { + return (typeof address === 'string' ? address : address?.address) as string; +} + /** * Resolves the effective txParams for TSS signing recipient verification. * @@ -145,7 +153,7 @@ export function resolveEffectiveTxParams( intentRecipient.tokenData?.tokenName || (chainName !== undefined && symbol && symbol !== chainName ? symbol : undefined); return { - address: intentRecipient.address.address, + address: getIntentRecipientAddress(intentRecipient.address), amount: intentRecipient.amount.value, data: intentRecipient.data, ...(tokenName && { tokenName }), @@ -172,6 +180,12 @@ export function resolveEffectiveTxParams( effectiveTxParams.executorPartyId = (txRequest.intent as PopulatedIntent).executorPartyId; } + // Canton split (fanout) is verified against the intent's split count, which the prebuilt transaction alone cannot prove. + const intentNumberOfSplits = (txRequest.intent as PopulatedIntent)?.numberOfSplits; + if (effectiveTxParams.numberOfSplits === undefined && typeof intentNumberOfSplits === 'number') { + effectiveTxParams.numberOfSplits = intentNumberOfSplits; + } + // Propagate stakingRequestId from intent into effectiveTxParams so verifyTssTransaction // overrides can bypass the no-recipient guard without needing access to txRequest directly. const intentStakingRequestId = (txRequest.intent as PopulatedIntent)?.stakingRequestId; diff --git a/modules/sdk-core/test/unit/bitgo/utils/tss/recipientUtils.ts b/modules/sdk-core/test/unit/bitgo/utils/tss/recipientUtils.ts index dfae7cfa03..8dd1a87547 100644 --- a/modules/sdk-core/test/unit/bitgo/utils/tss/recipientUtils.ts +++ b/modules/sdk-core/test/unit/bitgo/utils/tss/recipientUtils.ts @@ -109,6 +109,45 @@ describe('recipientUtils', function () { assert.strictEqual(result.recipients?.[0].amount, '500'); }); + it('falls back to intent.recipients when the intent stores the address as a plain string', function () { + const txRequest = makeTxRequest({ + intent: { + intentType: 'payment', + recipients: [{ address: '0xabc', amount: { value: '500', symbol: 'eth' } }], + } as any, + }); + const result = resolveEffectiveTxParams(txRequest, {}); + assert.strictEqual(result.recipients?.[0].address, '0xabc'); + }); + + describe('split count propagation (Canton fanout)', function () { + const splitIntent = { + intentType: 'payment', + numberOfSplits: 2, + recipients: [{ address: '0xabc', amount: { value: '500', symbol: 'eth' } }], + } as any; + + it('derives numberOfSplits from the intent when txParams is undefined (signAndSendTxRequest path)', function () { + const result = resolveEffectiveTxParams(makeTxRequest({ intent: splitIntent }), undefined); + assert.strictEqual(result.numberOfSplits, 2); + }); + + it('does not overwrite numberOfSplits supplied by the caller', function () { + const result = resolveEffectiveTxParams(makeTxRequest({ intent: splitIntent }), { numberOfSplits: 5 }); + assert.strictEqual(result.numberOfSplits, 5); + }); + + it('leaves numberOfSplits undefined when the intent has none or a non-numeric one', function () { + const noSplits = { intentType: 'payment', recipients: splitIntent.recipients } as any; + assert.strictEqual(resolveEffectiveTxParams(makeTxRequest({ intent: noSplits }), {}).numberOfSplits, undefined); + const stringSplits = { ...splitIntent, numberOfSplits: '2' }; + assert.strictEqual( + resolveEffectiveTxParams(makeTxRequest({ intent: stringSplits }), {}).numberOfSplits, + undefined + ); + }); + }); + it('resolves txType from intent.intentType when txParams.type is absent', function () { const txRequest = makeTxRequest({ intent: { intentType: 'consolidate' } as any }); const result = resolveEffectiveTxParams(txRequest, {});