From 1b9a1edc3eafbcad297a826746a1d7ad358df59d Mon Sep 17 00:00:00 2001 From: Ravi Hegde Date: Sat, 8 Nov 2025 12:31:45 +0530 Subject: [PATCH] feat: transfer builder added Ticket: COIN-6381 --- modules/sdk-coin-canton/src/canton.ts | 19 +- modules/sdk-coin-canton/src/lib/iface.ts | 16 ++ modules/sdk-coin-canton/src/lib/index.ts | 1 + .../src/lib/transaction/transaction.ts | 38 +++- .../src/lib/transferBuilder.ts | 166 +++++++++++++++++- modules/sdk-coin-canton/test/resources.ts | 17 ++ .../oneStepEnablementBuilder.ts | 1 + .../unit/builder/transfer/transferBuilder.ts | 64 +++++++ 8 files changed, 314 insertions(+), 8 deletions(-) create mode 100644 modules/sdk-coin-canton/test/unit/builder/transfer/transferBuilder.ts diff --git a/modules/sdk-coin-canton/src/canton.ts b/modules/sdk-coin-canton/src/canton.ts index 22c9ecbc1d..4a10fe55a6 100644 --- a/modules/sdk-coin-canton/src/canton.ts +++ b/modules/sdk-coin-canton/src/canton.ts @@ -98,14 +98,14 @@ export class Canton extends BaseCoin { /** @inheritDoc */ async verifyTransaction(params: VerifyTransactionOptions): Promise { const coinConfig = coins.get(this.getChain()); - // extract `txParams` when verifying other transaction types - const { txPrebuild: txPrebuild } = params; + const { txPrebuild: txPrebuild, txParams } = params; const rawTx = txPrebuild.txHex; if (!rawTx) { throw new Error('missing required tx prebuild property txHex'); } const txBuilder = new TransactionBuilderFactory(coinConfig).from(rawTx); const transaction = txBuilder.transaction; + const explainedTx = transaction.explainTransaction(); switch (transaction.type) { case TransactionType.WalletInitialization: case TransactionType.TransferAccept: @@ -113,6 +113,21 @@ export class Canton extends BaseCoin { case TransactionType.TransferAcknowledge: // There is no input for these type of transactions, so always return true. return true; + case TransactionType.Send: + if (txParams.recipients !== undefined) { + const filteredRecipients = txParams.recipients?.map((recipient) => { + const { address, amount } = recipient; + return { address, amount }; + }); + const filteredOutputs = explainedTx.outputs?.map((output) => { + const { address, amount } = output; + return { address, amount }; + }); + if (JSON.stringify(filteredRecipients) !== JSON.stringify(filteredOutputs)) { + throw new Error('Tx outputs do not match with expected txParams recipients'); + } + } + return true; default: { throw new Error(`unknown transaction type, ${transaction.type}`); } diff --git a/modules/sdk-coin-canton/src/lib/iface.ts b/modules/sdk-coin-canton/src/lib/iface.ts index 5483694ec6..a8ad9bb71c 100644 --- a/modules/sdk-coin-canton/src/lib/iface.ts +++ b/modules/sdk-coin-canton/src/lib/iface.ts @@ -35,11 +35,17 @@ export interface WalletInitTxData { preparedParty: PreparedParty; } +export interface UTXOInfo { + contractId: string; + value: string; +} + export interface CantonPrepareCommandResponse { preparedTransaction?: string; preparedTransactionHash: string; hashingSchemeVersion: string; hashingDetails?: string | null; + utxoInfo?: UTXOInfo[]; } export interface PreparedParty { @@ -133,3 +139,13 @@ export interface TransferAcknowledge { expiryEpoch: number; updateId: string; } + +export interface CantonTransferRequest { + commandId: string; + senderPartyId: string; + receiverPartyId: string; + amount: number; + expiryEpoch: number; + sendViaOneStep: boolean; + memoId?: string; +} diff --git a/modules/sdk-coin-canton/src/lib/index.ts b/modules/sdk-coin-canton/src/lib/index.ts index d02de4c9e3..a19edc0f74 100644 --- a/modules/sdk-coin-canton/src/lib/index.ts +++ b/modules/sdk-coin-canton/src/lib/index.ts @@ -6,6 +6,7 @@ export { OneStepPreApprovalBuilder } from './oneStepPreApprovalBuilder'; export { Transaction } from './transaction/transaction'; export { TransferAcceptanceBuilder } from './transferAcceptanceBuilder'; export { TransferAcknowledgeBuilder } from './transferAcknowledgeBuilder'; +export { TransferBuilder } from './transferBuilder'; export { TransactionBuilder } from './transactionBuilder'; export { TransactionBuilderFactory } from './transactionBuilderFactory'; export { TransferRejectionBuilder } from './transferRejectionBuilder'; diff --git a/modules/sdk-coin-canton/src/lib/transaction/transaction.ts b/modules/sdk-coin-canton/src/lib/transaction/transaction.ts index a65551f5cd..384cbc889b 100644 --- a/modules/sdk-coin-canton/src/lib/transaction/transaction.ts +++ b/modules/sdk-coin-canton/src/lib/transaction/transaction.ts @@ -1,6 +1,7 @@ import { BaseKey, BaseTransaction, + Entry, InvalidTransactionError, ITransactionRecipient, TransactionType, @@ -177,6 +178,7 @@ export class Transaction extends BaseTransaction { if (this.type !== TransactionType.TransferAcknowledge) { if (decoded.prepareCommandResponse) { this.prepareCommand = decoded.prepareCommandResponse; + this.loadInputsAndOutputs(); } if (decoded.partySignatures && decoded.partySignatures.signatures.length > 0) { this.signerFingerprint = decoded.partySignatures.signatures[0].party.split('::')[1]; @@ -192,6 +194,30 @@ export class Transaction extends BaseTransaction { } } + /** + * Loads the input & output fields for the transaction + * + */ + loadInputsAndOutputs(): void { + const outputs: Entry[] = []; + const inputs: Entry[] = []; + const txData = this.toJson(); + const input: Entry = { + address: txData.sender, + value: txData.amount, + coin: this._coinConfig.name, + }; + const output: Entry = { + address: txData.receiver, + value: txData.amount, + coin: this._coinConfig.name, + }; + inputs.push(input); + outputs.push(output); + this._inputs = inputs; + this._outputs = outputs; + } + explainTransaction(): TransactionExplanation { const displayOrder = [ 'id', @@ -205,7 +231,9 @@ export class Transaction extends BaseTransaction { 'type', ]; const inputs: ITransactionRecipient[] = []; + const outputs: ITransactionRecipient[] = []; let inputAmount = '0'; + let outputAmount = '0'; switch (this.type) { case TransactionType.TransferAccept: case TransactionType.TransferReject: { @@ -214,12 +242,18 @@ export class Transaction extends BaseTransaction { inputAmount = txData.amount; break; } + case TransactionType.Send: { + const txData = this.toJson(); + outputs.push({ address: txData.sender, amount: txData.amount }); + outputAmount = txData.amount; + break; + } } return { id: this.id, displayOrder, - outputs: [], - outputAmount: '0', + outputs: outputs, + outputAmount: outputAmount, inputs: inputs, inputAmount: inputAmount, changeOutputs: [], diff --git a/modules/sdk-coin-canton/src/lib/transferBuilder.ts b/modules/sdk-coin-canton/src/lib/transferBuilder.ts index b79ab750ac..744875f697 100644 --- a/modules/sdk-coin-canton/src/lib/transferBuilder.ts +++ b/modules/sdk-coin-canton/src/lib/transferBuilder.ts @@ -1,23 +1,181 @@ -import { PublicKey, TransactionType } from '@bitgo/sdk-core'; +import { InvalidTransactionError, PublicKey, TransactionType } from '@bitgo/sdk-core'; import { BaseCoin as CoinConfig } from '@bitgo/statics'; import { TransactionBuilder } from './transactionBuilder'; -import { CantonPrepareCommandResponse } from './iface'; +import { Transaction } from './transaction/transaction'; +import { CantonPrepareCommandResponse, CantonTransferRequest } from './iface'; +import utils from './utils'; export class TransferBuilder extends TransactionBuilder { + private _commandId: string; + private _senderId: string; + private _receiverId: string; + private _amount: number; + private _sendOneStep = false; + private _expiryEpoch: number; + private _memoId: string; constructor(_coinConfig: Readonly) { super(_coinConfig); } - protected get transactionType(): TransactionType { + initBuilder(tx: Transaction): void { + super.initBuilder(tx); + this.setTransactionType(); + } + + get transactionType(): TransactionType { return TransactionType.Send; } + setTransactionType(): void { + this.transaction.transactionType = TransactionType.Send; + } + setTransaction(transaction: CantonPrepareCommandResponse): void { this.transaction.prepareCommand = transaction; } /** @inheritDoc */ addSignature(publicKey: PublicKey, signature: Buffer): void { - throw new Error('Not implemented'); + if (!this.transaction) { + throw new InvalidTransactionError('transaction is empty!'); + } + this._signatures.push({ publicKey, signature }); + const pubKeyBase64 = utils.getBase64FromHex(publicKey.pub); + this.transaction.signerFingerprint = utils.getAddressFromPublicKey(pubKeyBase64); + this.transaction.signatures = signature.toString('base64'); + } + + /** + * Sets the unique id for the transfer + * Also sets the _id of the transaction + * + * @param id - A uuid + * @returns The current builder instance for chaining. + * @throws Error if id is empty. + */ + commandId(id: string): this { + if (!id || !id.trim()) { + throw new Error('commandId must be a non-empty string'); + } + this._commandId = id.trim(); + // also set the transaction _id + this.transaction.id = id.trim(); + return this; + } + + /** + * Sets the sender party id for the transfer + * @param id - sender address (party id) + * @returns The current builder instance for chaining. + * @throws Error if id is empty. + */ + senderId(id: string): this { + if (!id || !id.trim()) { + throw new Error('senderId must be a non-empty string'); + } + this._senderId = id.trim(); + return this; + } + + /** + * Sets the receiver party id for the transfer + * @param id - receiver address (party id) + * @returns The current builder instance for chaining. + * @throws Error if id is empty. + */ + receiverId(id: string): this { + if (!id || !id.trim()) { + throw new Error('receiverId must be a non-empty string'); + } + this._receiverId = id.trim(); + return this; + } + + /** + * Sets the transfer amount + * @param amount - transfer amount + * @returns The current builder instance for chaining. + * @throws Error if amount not present or negative + */ + amount(amount: number): this { + if (!amount || amount < 0) { + throw new Error('amount must be a positive number'); + } + this._amount = amount; + return this; + } + + /** + * Sets the 1-step enablement flag to send via 1-step, works only if recipient + * enabled the 1-step, defaults to `false` + * @param flag boolean value + * @returns The current builder for chaining + */ + sendOneStep(flag: boolean): this { + this._sendOneStep = flag; + return this; + } + + /** + * Sets the transfer expiry + * @param epoch - the expiry for 2-step transfer, defaults to 90 days and + * not applicable if sending via 1-step + * @returns The current builder for chaining + * @throws Error if the expiry value is invalid + */ + expiryEpoch(epoch: number): this { + if (!epoch || epoch < 0) { + throw new Error('epoch must be a positive number'); + } + this._expiryEpoch = epoch; + return this; + } + + /** + * Sets the optional memoId if present + * @param id - memoId of the recipient + * @returns The current builder for chaining + * @throws Error if the memoId value is invalid + */ + memoId(id: string): this { + if (!id || !id.trim()) { + throw new Error('memoId must be a non-empty string'); + } + this._memoId = id.trim(); + return this; + } + + /** + * Get the canton transfer request object + * @returns CantonTransferRequest + * @throws Error if any required params are missing + */ + toRequestObject(): CantonTransferRequest { + this.validate(); + const data: CantonTransferRequest = { + commandId: this._commandId, + senderPartyId: this._senderId, + receiverPartyId: this._receiverId, + amount: this._amount, + expiryEpoch: this._expiryEpoch, + sendViaOneStep: this._sendOneStep, + }; + if (this._memoId) { + data.memoId = this._memoId; + } + return data; + } + + /** + * Method to validate the required fields + * @throws Error if required fields are not set + * @private + */ + private validate(): void { + if (!this._commandId) throw new Error('commandId is missing'); + if (!this._senderId) throw new Error('senderId is missing'); + if (!this._receiverId) throw new Error('receiverId is missing'); + if (!this._amount) throw new Error('amount is missing'); + if (!this._expiryEpoch) throw new Error('expiryEpoch is missing'); } } diff --git a/modules/sdk-coin-canton/test/resources.ts b/modules/sdk-coin-canton/test/resources.ts index ad38802111..5a884eee29 100644 --- a/modules/sdk-coin-canton/test/resources.ts +++ b/modules/sdk-coin-canton/test/resources.ts @@ -127,3 +127,20 @@ export const TransferRejectionPrepareResponse = { export const TransferRejectRawTransaction = '{"prepareCommandResponse":{"preparedTransaction":"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","preparedTransactionHash":"QFxX1WBdq7lZbSc45iKA3J/oOF9mrVLc3DeKphAjb14=","hashingSchemeVersion":"HASHING_SCHEME_VERSION_V2","hashingDetails":null},"txType":"TransferReject","preparedTransaction":"","partySignatures":{"signatures":[]},"deduplicationPeriod":{"Empty":{}},"submissionId":"12eab71f-951f-4ee2-8fb4-495b04a680e4","hashingSchemeVersion":"HASHING_SCHEME_VERSION_V2","minLedgerTime":{"time":{"Empty":{}}}}'; + +export const TrasferPrepareResponse = { + preparedTransaction: + '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', + preparedTransactionHash: 'y12u05viQ8euhNh9c21KK8lbn/7wM4aeG5U4ouanTWY=', + hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2', + hashingDetails: null, +}; + +export const TransferObj = { + commandId: '9d4fbb39-9bf0-4864-a209-66c53b429828', + senderPartyId: 'ravi-test-party-1::122092e7d33ac10c0f3d55976342f37555df05da5b742956d56a62ae2367769079d2', + receiverPartyId: '1220a::1220ade60300cf7d0b18ffaa2ffe4f492ad1ad601cfc162b20f77ec99d16c2c2f158', + amount: 15, + sendOneStep: false, + expiryEpoch: 1770289758686, +}; diff --git a/modules/sdk-coin-canton/test/unit/builder/oneStepEnablement/oneStepEnablementBuilder.ts b/modules/sdk-coin-canton/test/unit/builder/oneStepEnablement/oneStepEnablementBuilder.ts index f3875f58ab..6ef3c3f056 100644 --- a/modules/sdk-coin-canton/test/unit/builder/oneStepEnablement/oneStepEnablementBuilder.ts +++ b/modules/sdk-coin-canton/test/unit/builder/oneStepEnablement/oneStepEnablementBuilder.ts @@ -17,6 +17,7 @@ describe('Wallet Pre-approval Enablement Builder', () => { const txBuilder = new OneStepPreApprovalBuilder(coins.get('tcanton')); const oneStepEnablementTx = new Transaction(coins.get('tcanton')); txBuilder.initBuilder(oneStepEnablementTx); + txBuilder.setTransaction(OneStepPreApprovalPrepareResponse); const { commandId, partyId } = OneStepEnablement; txBuilder.commandId(commandId).receiverPartyId(partyId); const requestObj: CantonOneStepEnablementRequest = txBuilder.toRequestObject(); diff --git a/modules/sdk-coin-canton/test/unit/builder/transfer/transferBuilder.ts b/modules/sdk-coin-canton/test/unit/builder/transfer/transferBuilder.ts new file mode 100644 index 0000000000..e966709b36 --- /dev/null +++ b/modules/sdk-coin-canton/test/unit/builder/transfer/transferBuilder.ts @@ -0,0 +1,64 @@ +import assert from 'assert'; +import should from 'should'; + +import { coins } from '@bitgo/statics'; + +import { TransferBuilder, Transaction } from '../../../../src'; +import { CantonTransferRequest } from '../../../../src/lib/iface'; + +import { TransferObj, TrasferPrepareResponse } from '../../../resources'; + +describe('Transfer Builder', () => { + it('should get the transfer request object', function () { + const txBuilder = new TransferBuilder(coins.get('tcanton')); + const transferTx = new Transaction(coins.get('tcanton')); + txBuilder.initBuilder(transferTx); + txBuilder.setTransaction(TrasferPrepareResponse); + const { commandId, senderPartyId, receiverPartyId, amount, sendOneStep, expiryEpoch } = TransferObj; + txBuilder + .commandId(commandId) + .senderId(senderPartyId) + .receiverId(receiverPartyId) + .amount(amount) + .sendOneStep(sendOneStep) + .expiryEpoch(expiryEpoch); + const requestObj: CantonTransferRequest = txBuilder.toRequestObject(); + should.exist(requestObj); + assert.equal(requestObj.commandId, commandId); + assert.equal(requestObj.senderPartyId, senderPartyId); + assert.equal(requestObj.receiverPartyId, receiverPartyId); + assert.equal(requestObj.amount, amount); + assert.equal(requestObj.expiryEpoch, expiryEpoch); + }); + + it('should validate raw transaction', function () { + const txBuilder = new TransferBuilder(coins.get('tcanton')); + const transferTx = new Transaction(coins.get('tcanton')); + txBuilder.initBuilder(transferTx); + txBuilder.setTransaction(TrasferPrepareResponse); + txBuilder.validateRawTransaction(TrasferPrepareResponse.preparedTransaction); + }); + + it('should validate the transaction', function () { + const txBuilder = new TransferBuilder(coins.get('tcanton')); + const transferTx = new Transaction(coins.get('tcanton')); + transferTx.prepareCommand = TrasferPrepareResponse; + txBuilder.initBuilder(transferTx); + txBuilder.setTransaction(TrasferPrepareResponse); + txBuilder.validateTransaction(transferTx); + }); + + it('should throw error in validating raw transaction', function () { + const txBuilder = new TransferBuilder(coins.get('tcanton')); + const transferAcceptanceTx = new Transaction(coins.get('tcanton')); + txBuilder.initBuilder(transferAcceptanceTx); + const invalidPrepareResponse = TrasferPrepareResponse; + invalidPrepareResponse.preparedTransactionHash = 'y12u05viQ8euhNh9c21KK8lbn/7wM4aeG5U4ouanTWZ='; + txBuilder.setTransaction(invalidPrepareResponse); + try { + txBuilder.validateRawTransaction(invalidPrepareResponse.preparedTransaction); + } catch (e) { + assert.equal(e.message, 'invalid raw transaction, hash not matching'); + } + }); +});