feat: added canton offer withdrawn builder

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:

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;

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';

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));
   }

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<CoinConfig>) {
+    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');
+  }
+}

modules/sdk-coin-canton/src/lib/utils.ts

@@ -101,6 +101,8 @@
     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 @@
           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,46 @@
           instrumentId = idData.text ?? '';
         }
       }
+    } else if (withdrawnNode.length) {
+      const ownerData = getField(withdrawnNode, 'owner');
+      if (ownerData?.oneofKind === 'party') {
+        receiver = ownerData.party ?? '';
+        if (!sender) {
+          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 ?? '';
+        if (!sender) {
+          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[] = [];

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');
+    }
+  });
+});

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,