From 98aec6cf3407417d6730fc06fd6fef5600b73e0a Mon Sep 17 00:00:00 2001 From: Ravi Hegde Date: Wed, 4 Feb 2026 11:53:14 +0530 Subject: [PATCH] feat: added canton offer withdrawn builder Ticket: COIN-7486 --- modules/sdk-coin-canton/src/canton.ts | 1 + modules/sdk-coin-canton/src/lib/iface.ts | 4 + modules/sdk-coin-canton/src/lib/index.ts | 1 + .../src/lib/transactionBuilderFactory.ts | 8 + .../src/lib/transferOfferWithdrawnBuilder.ts | 139 ++++++++++++++++++ modules/sdk-coin-canton/src/lib/utils.ts | 52 +++++++ modules/sdk-coin-canton/test/resources.ts | 28 ++++ .../transferOfferWithdrawnBuilder.ts | 70 +++++++++ .../sdk-core/src/account-lib/baseCoin/enum.ts | 2 + 9 files changed, 305 insertions(+) create mode 100644 modules/sdk-coin-canton/src/lib/transferOfferWithdrawnBuilder.ts create mode 100644 modules/sdk-coin-canton/test/unit/builder/transferOfferWithdrawn/transferOfferWithdrawnBuilder.ts diff --git a/modules/sdk-coin-canton/src/canton.ts b/modules/sdk-coin-canton/src/canton.ts index 421fe60aeb..995145914b 100644 --- a/modules/sdk-coin-canton/src/canton.ts +++ b/modules/sdk-coin-canton/src/canton.ts @@ -113,6 +113,7 @@ export class Canton extends BaseCoin { case TransactionType.TransferReject: case TransactionType.TransferAcknowledge: case TransactionType.OneStepPreApproval: + case TransactionType.TransferOfferWithdrawn: // There is no input for these type of transactions, so always return true. return true; case TransactionType.Send: diff --git a/modules/sdk-coin-canton/src/lib/iface.ts b/modules/sdk-coin-canton/src/lib/iface.ts index dd17138555..afa129393e 100644 --- a/modules/sdk-coin-canton/src/lib/iface.ts +++ b/modules/sdk-coin-canton/src/lib/iface.ts @@ -138,6 +138,10 @@ export interface CantonTransferAcceptRejectRequest extends CantonPrepareCommandR contractId: string; } +export interface CantonTransferOfferWithdrawnRequest extends CantonTransferAcceptRejectRequest { + tokenName?: string; +} + export interface TransferAcknowledge { contractId: string; senderPartyId: string; diff --git a/modules/sdk-coin-canton/src/lib/index.ts b/modules/sdk-coin-canton/src/lib/index.ts index a19edc0f74..1d6d1c468d 100644 --- a/modules/sdk-coin-canton/src/lib/index.ts +++ b/modules/sdk-coin-canton/src/lib/index.ts @@ -9,6 +9,7 @@ export { TransferAcknowledgeBuilder } from './transferAcknowledgeBuilder'; export { TransferBuilder } from './transferBuilder'; export { TransactionBuilder } from './transactionBuilder'; export { TransactionBuilderFactory } from './transactionBuilderFactory'; +export { TransferOfferWithdrawnBuilder } from './transferOfferWithdrawnBuilder'; export { TransferRejectionBuilder } from './transferRejectionBuilder'; export { WalletInitBuilder } from './walletInitBuilder'; export { WalletInitTransaction } from './walletInitialization/walletInitTransaction'; diff --git a/modules/sdk-coin-canton/src/lib/transactionBuilderFactory.ts b/modules/sdk-coin-canton/src/lib/transactionBuilderFactory.ts index c3799296c9..9e438616a0 100644 --- a/modules/sdk-coin-canton/src/lib/transactionBuilderFactory.ts +++ b/modules/sdk-coin-canton/src/lib/transactionBuilderFactory.ts @@ -10,6 +10,7 @@ import { TransferAcceptanceBuilder } from './transferAcceptanceBuilder'; import { TransferAcknowledgeBuilder } from './transferAcknowledgeBuilder'; import { TransactionBuilder } from './transactionBuilder'; import { TransferBuilder } from './transferBuilder'; +import { TransferOfferWithdrawnBuilder } from './transferOfferWithdrawnBuilder'; import { TransferRejectionBuilder } from './transferRejectionBuilder'; import { Transaction } from './transaction/transaction'; import { WalletInitBuilder } from './walletInitBuilder'; @@ -41,6 +42,9 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory { case TransactionType.TransferAcknowledge: { return this.getTransferAcknowledgeBuilder(tx); } + case TransactionType.TransferOfferWithdrawn: { + return this.getTransferOfferWithdrawnBuilder(); + } case TransactionType.TransferReject: { return this.getTransferRejectBuilder(tx); } @@ -63,6 +67,10 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory { return TransactionBuilderFactory.initializeBuilder(tx, new TransferAcknowledgeBuilder(this._coinConfig)); } + getTransferOfferWithdrawnBuilder(tx?: Transaction): TransferOfferWithdrawnBuilder { + return TransactionBuilderFactory.initializeBuilder(tx, new TransferOfferWithdrawnBuilder(this._coinConfig)); + } + getTransferRejectBuilder(tx?: Transaction): TransferRejectionBuilder { return TransactionBuilderFactory.initializeBuilder(tx, new TransferRejectionBuilder(this._coinConfig)); } diff --git a/modules/sdk-coin-canton/src/lib/transferOfferWithdrawnBuilder.ts b/modules/sdk-coin-canton/src/lib/transferOfferWithdrawnBuilder.ts new file mode 100644 index 0000000000..e789e275fe --- /dev/null +++ b/modules/sdk-coin-canton/src/lib/transferOfferWithdrawnBuilder.ts @@ -0,0 +1,139 @@ +import { InvalidTransactionError, PublicKey, TransactionType } from '@bitgo/sdk-core'; +import { BaseCoin as CoinConfig } from '@bitgo/statics'; +import { CantonPrepareCommandResponse, CantonTransferOfferWithdrawnRequest } from './iface'; +import { TransactionBuilder } from './transactionBuilder'; +import { Transaction } from './transaction/transaction'; +import utils from './utils'; + +export class TransferOfferWithdrawnBuilder extends TransactionBuilder { + private _commandId: string; + private _contractId: string; + private _actAsPartyId: string; + private _tokenName: string; + constructor(_coinConfig: Readonly) { + super(_coinConfig); + } + + initBuilder(tx: Transaction): void { + super.initBuilder(tx); + this.setTransactionType(); + } + + get transactionType(): TransactionType { + return TransactionType.TransferOfferWithdrawn; + } + + setTransactionType(): void { + this.transaction.transactionType = TransactionType.TransferOfferWithdrawn; + } + + setTransaction(transaction: CantonPrepareCommandResponse): void { + this.transaction.prepareCommand = transaction; + } + + /** @inheritDoc */ + addSignature(publicKey: PublicKey, signature: Buffer): void { + 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 offer withdrawn + * 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 contract id the receiver needs to withdraw + * @param id - canton withdrawn contract id + * @returns The current builder instance for chaining. + * @throws Error if id is empty. + */ + contractId(id: string): this { + if (!id || !id.trim()) { + throw new Error('contractId must be a non-empty string'); + } + this._contractId = id.trim(); + return this; + } + + /** + * The sender who wants to withdraw the offer + * + * @param id - the sender party id + * @returns The current builder instance for chaining. + * @throws Error if id is empty. + */ + actAs(id: string): this { + if (!id || !id.trim()) { + throw new Error('actAsPartyId must be a non-empty string'); + } + this._actAsPartyId = id.trim(); + return this; + } + + /** + * The token name to withdraw the offer + * @param name - the bitgo name of the asset + * @returns The current builder instance for chaining. + * @throws Error if name is empty. + */ + tokenName(name: string): this { + if (!name || !name.trim()) { + throw new Error('tokenName must be a non-empty string'); + } + this._tokenName = name.trim(); + return this; + } + + /** + * Builds and returns the CantonTransferOfferWithdrawnRequest object from the builder's internal state. + * + * This method performs validation before constructing the object. If required fields are + * missing or invalid, it throws an error. + * + * @returns {CantonTransferOfferWithdrawnRequest} - A fully constructed and validated request object for transfer offer withdrawal. + * @throws {Error} If any required field is missing or fails validation. + */ + toRequestObject(): CantonTransferOfferWithdrawnRequest { + this.validate(); + + return { + commandId: this._commandId, + contractId: this._contractId, + verboseHashing: false, + actAs: [this._actAsPartyId], + readAs: [], + tokenName: this._tokenName, + }; + } + + /** + * Validates the internal state of the builder before building the request object. + * + * @private + * @throws {Error} If any required field is missing or invalid. + */ + private validate(): void { + if (!this._commandId) throw new Error('commandId is missing'); + if (!this._contractId) throw new Error('contractId is missing'); + if (!this._actAsPartyId) throw new Error('receiver partyId is missing'); + } +} diff --git a/modules/sdk-coin-canton/src/lib/utils.ts b/modules/sdk-coin-canton/src/lib/utils.ts index db9bcc9668..55a2973571 100644 --- a/modules/sdk-coin-canton/src/lib/utils.ts +++ b/modules/sdk-coin-canton/src/lib/utils.ts @@ -101,6 +101,8 @@ export class Utils implements BaseUtils { let transferNode: RecordField[] = []; let transferAcceptRejectNode: RecordField[] = []; let tokenTransferAcceptRejectNode: RecordField[] = []; + let withdrawnNode: RecordField[] = []; + let tokenWithdrawnNode: RecordField[] = []; const nodes = decodedData.transaction?.nodes; nodes?.forEach((node) => { @@ -140,6 +142,20 @@ export class Utils implements BaseUtils { tokenTransferAcceptRejectNode = transferSum.record?.fields ?? []; } } + if ( + template?.entityName === 'Amulet' && + !withdrawnNode.length && + txType === TransactionType.TransferOfferWithdrawn + ) { + withdrawnNode = fields; + } + if ( + template?.entityName === 'Holding' && + !tokenWithdrawnNode.length && + txType === TransactionType.TransferOfferWithdrawn + ) { + tokenWithdrawnNode = fields; + } }); nodes?.forEach((node) => { @@ -247,6 +263,42 @@ export class Utils implements BaseUtils { instrumentId = idData.text ?? ''; } } + } else if (withdrawnNode.length) { + const ownerData = getField(withdrawnNode, 'owner'); + if (ownerData?.oneofKind === 'party') { + receiver = ownerData.party ?? ''; + sender = receiver; + } + const amountField = getField(withdrawnNode, 'amount'); + if (amountField?.oneofKind === 'record') { + const amountFields = amountField.record?.fields ?? []; + const initialAmountData = getField(amountFields, 'initialAmount'); + if (initialAmountData?.oneofKind === 'numeric') { + amount = initialAmountData.numeric ?? ''; + } + } + } else if (tokenWithdrawnNode.length) { + const ownerData = getField(tokenWithdrawnNode, 'owner'); + if (ownerData?.oneofKind === 'party') { + receiver = ownerData.party ?? ''; + sender = receiver; + } + const amountData = getField(tokenWithdrawnNode, 'amount'); + if (amountData?.oneofKind === 'numeric') { + amount = amountData.numeric ?? ''; + } + const instrumentData = getField(tokenWithdrawnNode, 'instrument'); + if (instrumentData?.oneofKind === 'record') { + const instrumentFields = instrumentData.record?.fields ?? []; + const adminData = getField(instrumentFields, 'source'); + if (adminData?.oneofKind === 'party') { + instrumentAdmin = adminData.party ?? ''; + } + const idData = getField(instrumentFields, 'id'); + if (idData?.oneofKind === 'text') { + instrumentId = idData.text ?? ''; + } + } } if (!sender || !receiver || !amount) { const missingFields: string[] = []; diff --git a/modules/sdk-coin-canton/test/resources.ts b/modules/sdk-coin-canton/test/resources.ts index 3ce6719645..aabf5fab88 100644 --- a/modules/sdk-coin-canton/test/resources.ts +++ b/modules/sdk-coin-canton/test/resources.ts @@ -181,6 +181,34 @@ export const CantonTokenTransferPrepareResponse = { }, }; +export const CantonTransferOfferWithdrawnPrepareResponse = { + preparedTransaction: + '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', + preparedTransactionHash: 'frwu54rtLjTLcHCSn5W+R4iM1unhM9ctJZ6KJWHpRsE=', + hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2', + hashingDetails: null, + costEstimation: { + estimationTimestamp: '2026-02-02T10:35:13.488193Z', + confirmationRequestTrafficCostEstimation: 8020, + confirmationResponseTrafficCostEstimation: 448, + totalTrafficCostEstimation: 8468, + }, +}; + +export const CantonTokenTransferOfferWithdrawnPrepareResponse = { + preparedTransaction: + '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', + preparedTransactionHash: 'TVQ0tafaH+CA4vth+bxzfcihSjS6AfPRBjYKxQwtu/E=', + hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2', + hashingDetails: null, + costEstimation: { + estimationTimestamp: '2026-02-02T10:38:49.458751Z', + confirmationRequestTrafficCostEstimation: 4591, + confirmationResponseTrafficCostEstimation: 448, + totalTrafficCostEstimation: 5039, + }, +}; + export const CantonTokenTransferRawTxn = '{"prepareCommandResponse":{"preparedTransaction":"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","preparedTransactionHash":"mLsZZWsZZ5jlHGdjOHjZFBiWLdSy3lTe+TcDlETHeVE=","hashingSchemeVersion":"HASHING_SCHEME_VERSION_V2","hashingDetails":null,"costEstimation":{"estimationTimestamp":"2026-02-04T07:42:39.890141Z","confirmationRequestTrafficCostEstimation":5334,"confirmationResponseTrafficCostEstimation":448,"totalTrafficCostEstimation":5782}},"txType":"Send","preparedTransaction":"","partySignatures":{"signatures":[]},"deduplicationPeriod":{"Empty":{}},"submissionId":"9d4fbb39-9bf0-4864-a209-66c53b429828","hashingSchemeVersion":"HASHING_SCHEME_VERSION_V2","minLedgerTime":{"time":{"Empty":{}}}}'; diff --git a/modules/sdk-coin-canton/test/unit/builder/transferOfferWithdrawn/transferOfferWithdrawnBuilder.ts b/modules/sdk-coin-canton/test/unit/builder/transferOfferWithdrawn/transferOfferWithdrawnBuilder.ts new file mode 100644 index 0000000000..67a74d33f0 --- /dev/null +++ b/modules/sdk-coin-canton/test/unit/builder/transferOfferWithdrawn/transferOfferWithdrawnBuilder.ts @@ -0,0 +1,70 @@ +import assert from 'assert'; +import should from 'should'; + +import { coins } from '@bitgo/statics'; + +import { TransferAcceptanceBuilder, Transaction, TransferOfferWithdrawnBuilder } from '../../../../src'; +import { CantonTransferAcceptRejectRequest } from '../../../../src/lib/iface'; + +import { + CantonTokenTransferOfferWithdrawnPrepareResponse, + CantonTransferOfferWithdrawnPrepareResponse, + TransferAcceptance, +} from '../../../resources'; + +describe('Transfer Offer Withdrawn Builder', () => { + it('should get the transfer offer withdrawn request object', function () { + const txBuilder = new TransferOfferWithdrawnBuilder(coins.get('tcanton')); + const transferOfferWithdrawnTx = new Transaction(coins.get('tcanton')); + txBuilder.initBuilder(transferOfferWithdrawnTx); + txBuilder.setTransaction(CantonTransferOfferWithdrawnPrepareResponse); + const { commandId, contractId, partyId } = TransferAcceptance; + txBuilder.commandId(commandId).contractId(contractId).actAs(partyId); + const requestObj: CantonTransferAcceptRejectRequest = txBuilder.toRequestObject(); + should.exist(requestObj); + assert.equal(requestObj.commandId, commandId); + assert.equal(requestObj.contractId, contractId); + assert.equal(requestObj.actAs.length, 1); + const actAs = requestObj.actAs[0]; + assert.equal(actAs, partyId); + }); + + it('should validate raw canton transfer offer withdrawn transaction', function () { + const txBuilder = new TransferAcceptanceBuilder(coins.get('tcanton')); + const transferOfferWithdrawnTx = new Transaction(coins.get('tcanton')); + txBuilder.initBuilder(transferOfferWithdrawnTx); + txBuilder.setTransaction(CantonTransferOfferWithdrawnPrepareResponse); + txBuilder.validateRawTransaction(CantonTransferOfferWithdrawnPrepareResponse.preparedTransaction); + }); + + it('should validate raw canton token transfer offer withdrawn transaction', function () { + const txBuilder = new TransferAcceptanceBuilder(coins.get('tcanton')); + const transferOfferWithdrawnTx = new Transaction(coins.get('tcanton')); + txBuilder.initBuilder(transferOfferWithdrawnTx); + txBuilder.setTransaction(CantonTokenTransferOfferWithdrawnPrepareResponse); + txBuilder.validateRawTransaction(CantonTokenTransferOfferWithdrawnPrepareResponse.preparedTransaction); + }); + + it('should validate the transaction', function () { + const txBuilder = new TransferAcceptanceBuilder(coins.get('tcanton')); + const transferOfferWithdrawnTx = new Transaction(coins.get('tcanton')); + transferOfferWithdrawnTx.prepareCommand = CantonTransferOfferWithdrawnPrepareResponse; + txBuilder.initBuilder(transferOfferWithdrawnTx); + txBuilder.setTransaction(CantonTransferOfferWithdrawnPrepareResponse); + txBuilder.validateTransaction(transferOfferWithdrawnTx); + }); + + it('should throw error in validating raw transaction', function () { + const txBuilder = new TransferAcceptanceBuilder(coins.get('tcanton')); + const transferOfferWithdrawnTx = new Transaction(coins.get('tcanton')); + txBuilder.initBuilder(transferOfferWithdrawnTx); + const invalidPrepareResponse = CantonTransferOfferWithdrawnPrepareResponse; + invalidPrepareResponse.preparedTransactionHash = '+vlIXv6Vgd2ypPXD0mrdn7RlcSH4c2hCRj2/tXqqUVs='; + txBuilder.setTransaction(invalidPrepareResponse); + try { + txBuilder.validateRawTransaction(invalidPrepareResponse.preparedTransaction); + } catch (e) { + assert.equal(e.message, 'invalid raw transaction, hash not matching'); + } + }); +}); diff --git a/modules/sdk-core/src/account-lib/baseCoin/enum.ts b/modules/sdk-core/src/account-lib/baseCoin/enum.ts index 1c984d1a4a..9d7eb9afee 100644 --- a/modules/sdk-core/src/account-lib/baseCoin/enum.ts +++ b/modules/sdk-core/src/account-lib/baseCoin/enum.ts @@ -95,6 +95,8 @@ export enum TransactionType { TransferAcknowledge, // canton transfer reject, 2-step TransferReject, + // canton transfer offer withdrawn, 2-step + TransferOfferWithdrawn, // trx FREEZE,