diff --git a/modules/sdk-coin-canton/src/lib/constant.ts b/modules/sdk-coin-canton/src/lib/constant.ts
index 0fefb27d03..8c76c73ee9 100644
--- a/modules/sdk-coin-canton/src/lib/constant.ts
+++ b/modules/sdk-coin-canton/src/lib/constant.ts
@@ -14,3 +14,6 @@ export const PUBLIC_KEY_FORMAT = 'CRYPTO_KEY_FORMAT_RAW';
 export const PUBLIC_KEY_SPEC = 'SIGNING_KEY_SPEC_EC_CURVE25519';
 export const SIGNATURE_FORMAT = 'SIGNATURE_FORMAT_RAW';
 export const SIGNATURE_ALGORITHM_SPEC = 'SIGNING_ALGORITHM_SPEC_ED25519';
+export const HASHING_SCHEME_VERSION = 'HASHING_SCHEME_VERSION_V2';
+
+export const DUMMY_HASH = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=';
diff --git a/modules/sdk-coin-canton/src/lib/iface.ts b/modules/sdk-coin-canton/src/lib/iface.ts
index 2eb70f7030..2437696f36 100644
--- a/modules/sdk-coin-canton/src/lib/iface.ts
+++ b/modules/sdk-coin-canton/src/lib/iface.ts
@@ -81,6 +81,30 @@ export interface WalletInitBroadcastData {
   multiHashSignatures: MultiHashSignature[];
 }
 
+export interface PartySignature {
+  party: string;
+  signatures: MultiHashSignature[];
+}
+
+export interface TransactionBroadcastData {
+  prepareCommandResponse?: CantonPrepareCommandResponse;
+  txType: string;
+  preparedTransaction?: string;
+  partySignatures?: {
+    signatures: PartySignature[];
+  };
+  deduplicationPeriod?: {
+    Empty: Record<string, never>;
+  };
+  submissionId: string;
+  hashingSchemeVersion?: string;
+  minLedgerTime?: {
+    time: {
+      Empty: Record<string, never>;
+    };
+  };
+}
+
 export interface CantonOneStepEnablementRequest extends CantonPrepareCommandRequest {
   receiverId: string;
 }
@@ -88,3 +112,11 @@ export interface CantonOneStepEnablementRequest extends CantonPrepareCommandRequ
 export interface CantonTransferAcceptRequest extends CantonPrepareCommandRequest {
   contractId: string;
 }
+
+export interface TransferAcknowledge {
+  contractId: string;
+  senderPartyId: string;
+  amount: number;
+  expiryEpoch: number;
+  updateId: string;
+}
diff --git a/modules/sdk-coin-canton/src/lib/index.ts b/modules/sdk-coin-canton/src/lib/index.ts
index 50e53cd342..bfff8ef769 100644
--- a/modules/sdk-coin-canton/src/lib/index.ts
+++ b/modules/sdk-coin-canton/src/lib/index.ts
@@ -5,6 +5,7 @@ export { KeyPair } from './keyPair';
 export { OneStepPreApprovalBuilder } from './oneStepPreApprovalBuilder';
 export { Transaction } from './transaction/transaction';
 export { TransferAcceptanceBuilder } from './transferAcceptanceBuilder';
+export { TransferAcknowledgeBuilder } from './transferAcknowledgeBuilder';
 export { TransactionBuilder } from './transactionBuilder';
 export { TransactionBuilderFactory } from './transactionBuilderFactory';
 export { WalletInitBuilder } from './walletInitBuilder';
diff --git a/modules/sdk-coin-canton/src/lib/oneStepPreApprovalBuilder.ts b/modules/sdk-coin-canton/src/lib/oneStepPreApprovalBuilder.ts
index 71d6333a0c..c0c0a01bd2 100644
--- a/modules/sdk-coin-canton/src/lib/oneStepPreApprovalBuilder.ts
+++ b/modules/sdk-coin-canton/src/lib/oneStepPreApprovalBuilder.ts
@@ -1,8 +1,9 @@
-import { TransactionType } from '@bitgo/sdk-core';
+import { InvalidTransactionError, PublicKey, TransactionType } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { CantonPrepareCommandResponse, CantonOneStepEnablementRequest } from './iface';
 import { TransactionBuilder } from './transactionBuilder';
 import { Transaction } from './transaction/transaction';
+import utils from './utils';
 
 export class OneStepPreApprovalBuilder extends TransactionBuilder {
   private _commandId: string;
@@ -28,6 +29,17 @@ export class OneStepPreApprovalBuilder extends TransactionBuilder {
     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 1-step enablement
    * Also sets the _id of the transaction
diff --git a/modules/sdk-coin-canton/src/lib/transaction/transaction.ts b/modules/sdk-coin-canton/src/lib/transaction/transaction.ts
index dd82e45410..201356d398 100644
--- a/modules/sdk-coin-canton/src/lib/transaction/transaction.ts
+++ b/modules/sdk-coin-canton/src/lib/transaction/transaction.ts
@@ -1,10 +1,19 @@
 import { BaseKey, BaseTransaction, InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import { CantonPrepareCommandResponse, PreparedTxnParsedInfo, TxData } from '../iface';
+import {
+  CantonPrepareCommandResponse,
+  MultiHashSignature,
+  PartySignature,
+  PreparedTxnParsedInfo,
+  TransactionBroadcastData,
+  TxData,
+} from '../iface';
 import utils from '../utils';
+import { DUMMY_HASH, HASHING_SCHEME_VERSION, SIGNATURE_ALGORITHM_SPEC, SIGNATURE_FORMAT } from '../constant';
 
 export class Transaction extends BaseTransaction {
   private _prepareCommand: CantonPrepareCommandResponse;
+  private _signerFingerprint: string;
 
   constructor(coinConfig: Readonly<CoinConfig>) {
     super(coinConfig);
@@ -37,23 +46,84 @@ export class Transaction extends BaseTransaction {
     return false;
   }
 
+  set signatures(signature: string) {
+    this._signatures.push(signature);
+  }
+
+  set signerFingerprint(fingerprint: string) {
+    this._signerFingerprint = fingerprint;
+  }
+
   toBroadcastFormat(): string {
+    if (!this._type) {
+      throw new InvalidTransactionError('Transaction type is not set');
+    }
+    if (this._type === TransactionType.TransferAcknowledge) {
+      const minData: TransactionBroadcastData = {
+        txType: TransactionType[this._type],
+        submissionId: this.id,
+      };
+      return Buffer.from(JSON.stringify(minData)).toString('base64');
+    }
     if (!this._prepareCommand) {
       throw new InvalidTransactionError('Empty transaction data');
     }
-    return Buffer.from(JSON.stringify(this._prepareCommand)).toString('base64');
+    const partySignatures: PartySignature[] = [];
+    const data: TransactionBroadcastData = {
+      prepareCommandResponse: this._prepareCommand,
+      txType: this._type ? TransactionType[this._type] : '',
+      preparedTransaction: '',
+      partySignatures: {
+        signatures: partySignatures,
+      },
+      deduplicationPeriod: {
+        Empty: {},
+      },
+      submissionId: this.id,
+      hashingSchemeVersion: HASHING_SCHEME_VERSION,
+      minLedgerTime: {
+        time: {
+          Empty: {},
+        },
+      },
+    };
+    const signatures: MultiHashSignature[] = [];
+    if (this._signatures.length > 0 && this._signerFingerprint) {
+      const signerPartyId = `${this._signerFingerprint.slice(0, 5)}::${this._signerFingerprint}`;
+      this.signature.map((signature) => {
+        const signatureObj: MultiHashSignature = {
+          format: SIGNATURE_FORMAT,
+          signature: signature,
+          signedBy: this._signerFingerprint,
+          signingAlgorithmSpec: SIGNATURE_ALGORITHM_SPEC,
+        };
+        signatures.push(signatureObj);
+      });
+      const partySignature = {
+        party: signerPartyId,
+        signatures: signatures,
+      };
+      data.partySignatures?.signatures.push(partySignature);
+      data.preparedTransaction = this._prepareCommand.preparedTransaction
+        ? this._prepareCommand.preparedTransaction
+        : '';
+    }
+    return Buffer.from(JSON.stringify(data)).toString('base64');
   }
 
   toJson(): TxData {
-    if (!this._prepareCommand || !this._prepareCommand.preparedTransaction) {
-      throw new InvalidTransactionError('Empty transaction data');
-    }
     const result: TxData = {
       id: this.id,
       type: this._type as TransactionType,
       sender: '',
       receiver: '',
     };
+    if (this._type === TransactionType.TransferAcknowledge) {
+      return result;
+    }
+    if (!this._prepareCommand || !this._prepareCommand.preparedTransaction) {
+      throw new InvalidTransactionError('Empty transaction data');
+    }
     // TODO: extract other required data (utxo used, request time, execute before etc)
     let parsedInfo: PreparedTxnParsedInfo;
     try {
@@ -67,6 +137,9 @@ export class Transaction extends BaseTransaction {
   }
 
   get signablePayload(): Buffer {
+    if (this._type === TransactionType.TransferAcknowledge) {
+      return Buffer.from(DUMMY_HASH, 'base64');
+    }
     if (!this._prepareCommand) {
       throw new InvalidTransactionError('Empty transaction data');
     }
@@ -75,8 +148,18 @@ export class Transaction extends BaseTransaction {
 
   fromRawTransaction(rawTx: string): void {
     try {
-      const decoded: CantonPrepareCommandResponse = JSON.parse(Buffer.from(rawTx, 'base64').toString('utf8'));
-      this.prepareCommand = decoded;
+      const decoded: TransactionBroadcastData = JSON.parse(Buffer.from(rawTx, 'base64').toString('utf8'));
+      this.id = decoded.submissionId;
+      this.transactionType = TransactionType[decoded.txType];
+      if (this.transactionType !== TransactionType.TransferAcknowledge) {
+        if (decoded.prepareCommandResponse) {
+          this.prepareCommand = decoded.prepareCommandResponse;
+        }
+        if (decoded.partySignatures && decoded.partySignatures.signatures.length > 0) {
+          this.signerFingerprint = decoded.partySignatures.signatures[0].party.split('::')[1];
+          this.signatures = decoded.partySignatures.signatures[0].signatures[0].signature;
+        }
+      }
     } catch (e) {
       throw new InvalidTransactionError('Unable to parse raw transaction data');
     }
diff --git a/modules/sdk-coin-canton/src/lib/transactionBuilder.ts b/modules/sdk-coin-canton/src/lib/transactionBuilder.ts
index 8b635f05af..a130bf7fcc 100644
--- a/modules/sdk-coin-canton/src/lib/transactionBuilder.ts
+++ b/modules/sdk-coin-canton/src/lib/transactionBuilder.ts
@@ -15,7 +15,7 @@ import utils from './utils';
 
 export abstract class TransactionBuilder extends BaseTransactionBuilder {
   protected _transaction: Transaction;
-  private _signatures: Signature[] = [];
+  protected _signatures: Signature[] = [];
 
   initBuilder(tx: Transaction): void {
     this._transaction = tx;
@@ -40,9 +40,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   }
 
   /** @inheritDoc */
-  addSignature(publicKey: BasePublicKey, signature: Buffer): void {
-    this._signatures.push({ publicKey, signature });
-  }
+  abstract addSignature(publicKey: BasePublicKey, signature: Buffer): void;
 
   /** @inheritdoc */
   protected fromImplementation(rawTransaction: string): Transaction {
diff --git a/modules/sdk-coin-canton/src/lib/transactionBuilderFactory.ts b/modules/sdk-coin-canton/src/lib/transactionBuilderFactory.ts
index 99e54d12b3..0418c8ea01 100644
--- a/modules/sdk-coin-canton/src/lib/transactionBuilderFactory.ts
+++ b/modules/sdk-coin-canton/src/lib/transactionBuilderFactory.ts
@@ -6,6 +6,7 @@ import {
 } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { TransferAcceptanceBuilder } from './transferAcceptanceBuilder';
+import { TransferAcknowledgeBuilder } from './transferAcknowledgeBuilder';
 import { TransactionBuilder } from './transactionBuilder';
 import { TransferBuilder } from './transferBuilder';
 import { Transaction } from './transaction/transaction';
@@ -32,6 +33,9 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
         case TransactionType.TransferAccept: {
           return this.getTransferAcceptanceBuilder(tx);
         }
+        case TransactionType.TransferAcknowledge: {
+          return this.getTransferAcknowledgeBuilder(tx);
+        }
         default: {
           throw new InvalidTransactionError('unsupported transaction');
         }
@@ -39,11 +43,14 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     }
   }
 
-  /** @inheritdoc */
   getTransferAcceptanceBuilder(tx?: Transaction): TransferAcceptanceBuilder {
     return TransactionBuilderFactory.initializeBuilder(tx, new TransferAcceptanceBuilder(this._coinConfig));
   }
 
+  getTransferAcknowledgeBuilder(tx?: Transaction): TransferAcknowledgeBuilder {
+    return TransactionBuilderFactory.initializeBuilder(tx, new TransferAcknowledgeBuilder(this._coinConfig));
+  }
+
   /** @inheritdoc */
   getTransferBuilder(tx?: Transaction): TransferBuilder {
     return TransactionBuilderFactory.initializeBuilder(tx, new TransferBuilder(this._coinConfig));
diff --git a/modules/sdk-coin-canton/src/lib/transferAcceptanceBuilder.ts b/modules/sdk-coin-canton/src/lib/transferAcceptanceBuilder.ts
index 5b07d2bcaf..4a8319db2f 100644
--- a/modules/sdk-coin-canton/src/lib/transferAcceptanceBuilder.ts
+++ b/modules/sdk-coin-canton/src/lib/transferAcceptanceBuilder.ts
@@ -1,8 +1,9 @@
-import { TransactionType } from '@bitgo/sdk-core';
+import { InvalidTransactionError, PublicKey, TransactionType } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { CantonPrepareCommandResponse, CantonTransferAcceptRequest } from './iface';
 import { TransactionBuilder } from './transactionBuilder';
 import { Transaction } from './transaction/transaction';
+import utils from './utils';
 
 export class TransferAcceptanceBuilder extends TransactionBuilder {
   private _commandId: string;
@@ -29,6 +30,17 @@ export class TransferAcceptanceBuilder extends TransactionBuilder {
     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 acceptance
    * Also sets the _id of the transaction
diff --git a/modules/sdk-coin-canton/src/lib/transferAcknowledgeBuilder.ts b/modules/sdk-coin-canton/src/lib/transferAcknowledgeBuilder.ts
new file mode 100644
index 0000000000..742d4f95d0
--- /dev/null
+++ b/modules/sdk-coin-canton/src/lib/transferAcknowledgeBuilder.ts
@@ -0,0 +1,145 @@
+import { PublicKey, TransactionType } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { CantonPrepareCommandResponse, TransferAcknowledge } from './iface';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction/transaction';
+
+export class TransferAcknowledgeBuilder extends TransactionBuilder {
+  private _contractId: string;
+  private _senderPartyId: string;
+  private _amount: number;
+  private _updateId: string;
+  private _expiryEpoch: number;
+  constructor(_coinConfig: Readonly<CoinConfig>) {
+    super(_coinConfig);
+  }
+
+  initBuilder(tx: Transaction): void {
+    super.initBuilder(tx);
+    this.setTransactionType();
+  }
+
+  get transactionType(): TransactionType {
+    return TransactionType.TransferAcknowledge;
+  }
+
+  setTransactionType(): void {
+    this.transaction.transactionType = TransactionType.TransferAcknowledge;
+  }
+
+  setTransaction(transaction: CantonPrepareCommandResponse): void {
+    throw new Error('Not implemented!');
+  }
+
+  /** @inheritDoc */
+  addSignature(publicKey: PublicKey, signature: Buffer): void {
+    throw new Error('Not implemented!');
+  }
+
+  /**
+   * Sets the contract id the receiver needs to accept/reject
+   * @param id - canton 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;
+  }
+
+  /**
+   * Sets the sender party id
+   * @param id - sender party id (address)
+   * @returns The current builder instance for chaining.
+   * @throws Error if id is empty.
+   */
+  senderPartyId(id: string): this {
+    if (!id || !id.trim()) {
+      throw new Error('partyId must be a non-empty string');
+    }
+    this._senderPartyId = id.trim();
+    return this;
+  }
+
+  /**
+   * Sets the amount to accept or reject
+   * @param amount - incoming deposit amount
+   * @returns The current builder instance for chaining.
+   * @throws Error if amount <= 0
+   */
+  amount(amount: number): this {
+    if (isNaN(amount) || amount <= 0) {
+      throw new Error('amount must be positive number');
+    }
+    this._amount = amount;
+    return this;
+  }
+
+  /**
+   * Sets the incoming txn id (updateId of the ledger update)
+   * @param id - ledger update id
+   * @returns The current builder instance for chaining.
+   * @throws Error if id is empty.
+   */
+  updateId(id: string): this {
+    if (!id || !id.trim()) {
+      throw new Error('updateId must be a non-empty string');
+    }
+    this._updateId = id.trim();
+    // also set the transaction id
+    this.transaction.id = id.trim();
+    return this;
+  }
+
+  /**
+   * Sets the deposit txn expiry
+   * @param expiry - expiry epoch
+   * @returns The current builder instance for chaining.
+   * @throws Error if epoch is invalid
+   */
+  expiryEpoch(expiry: number): this {
+    if (isNaN(expiry)) {
+      throw new Error('invalid expiry');
+    }
+    this._expiryEpoch = expiry;
+    return this;
+  }
+
+  /**
+   * Builds and returns the TransferAcknowledge 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 {TransferAcknowledge} - A fully constructed and validated request object for transfer acknowledge.
+   * @throws {Error} If any required field is missing or fails validation.
+   */
+  toRequestObject(): TransferAcknowledge {
+    this.validate();
+
+    return {
+      contractId: this._contractId,
+      senderPartyId: this._senderPartyId,
+      updateId: this._updateId,
+      amount: this._amount,
+      expiryEpoch: this._expiryEpoch,
+    };
+  }
+
+  /**
+   * 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._contractId) throw new Error('contractId is missing');
+    if (!this._updateId) throw new Error('updateId is missing');
+    if (!this._senderPartyId) throw new Error('sender partyId is missing');
+    if (!this._amount) throw new Error('amount is missing');
+    if (!this._expiryEpoch) throw new Error('expiry is missing');
+  }
+}
diff --git a/modules/sdk-coin-canton/src/lib/transferBuilder.ts b/modules/sdk-coin-canton/src/lib/transferBuilder.ts
index 1dd42469c4..b79ab750ac 100644
--- a/modules/sdk-coin-canton/src/lib/transferBuilder.ts
+++ b/modules/sdk-coin-canton/src/lib/transferBuilder.ts
@@ -1,4 +1,4 @@
-import { TransactionType } from '@bitgo/sdk-core';
+import { PublicKey, TransactionType } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { TransactionBuilder } from './transactionBuilder';
 import { CantonPrepareCommandResponse } from './iface';
@@ -15,4 +15,9 @@ export class TransferBuilder extends TransactionBuilder {
   setTransaction(transaction: CantonPrepareCommandResponse): void {
     this.transaction.prepareCommand = transaction;
   }
+
+  /** @inheritDoc */
+  addSignature(publicKey: PublicKey, signature: Buffer): void {
+    throw new Error('Not implemented');
+  }
 }
diff --git a/modules/sdk-coin-canton/src/lib/utils.ts b/modules/sdk-coin-canton/src/lib/utils.ts
index 58050e9df8..905554cd5a 100644
--- a/modules/sdk-coin-canton/src/lib/utils.ts
+++ b/modules/sdk-coin-canton/src/lib/utils.ts
@@ -53,6 +53,15 @@ export class Utils implements BaseUtils {
     return regex.test(value);
   }
 
+  /**
+   * Helper method to convert hex value to base64
+   * @param {String} hexString - hex encoded string
+   * @returns {String} base64 encoded string
+   */
+  getBase64FromHex(hexString: string): string {
+    return Buffer.from(hexString, 'hex').toString('base64');
+  }
+
   /**
    * Method to create fingerprint (part of the canton partyId) from public key
    * @param {String} publicKey the public key
diff --git a/modules/sdk-coin-canton/test/resources.ts b/modules/sdk-coin-canton/test/resources.ts
index c7c985aa6b..0484b537fb 100644
--- a/modules/sdk-coin-canton/test/resources.ts
+++ b/modules/sdk-coin-canton/test/resources.ts
@@ -77,6 +77,15 @@ export const TransferAcceptance = {
     '001b549bfa833bab661ab30e4d0a3ab0ec01fcc4a2bef5369795f4928147706353ca1112205a8d0e780cf3b3115cf8be0d6315f4aed6a1c25b67e8c5d64cf9848d0458fd17',
 };
 
+export const TransferAcknowledgeRequest = {
+  contractId:
+    '001b549bfa833bab661ab30e4d0a3ab0ec01fcc4a2bef5369795f4928147706353ca1112205a8d0e780cf3b3115cf8be0d6315f4aed6a1c25b67e8c5d64cf9848d0458fd17',
+  senderPartyId: '12205::12205b4e3537a95126d90604592344d8ad3c3ddccda4f79901954280ee19c576714d',
+  amount: 100,
+  updateId: '12205b4e3537a95126d90604592344d8ad3c3ddccda4f79901954280ee19c576714d',
+  expiryEpoch: 1761382334000,
+};
+
 export const TransferAcceptancePrepareResponse = {
   preparedTransaction:
     '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',
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 c89d990feb..f3875f58ab 100644
--- a/modules/sdk-coin-canton/test/unit/builder/oneStepEnablement/oneStepEnablementBuilder.ts
+++ b/modules/sdk-coin-canton/test/unit/builder/oneStepEnablement/oneStepEnablementBuilder.ts
@@ -3,9 +3,8 @@ import should from 'should';
 
 import { coins } from '@bitgo/statics';
 
-import { Transaction } from '../../../../src';
+import { OneStepPreApprovalBuilder, Transaction } from '../../../../src';
 import { CantonOneStepEnablementRequest } from '../../../../src/lib/iface';
-import { OneStepPreApprovalBuilder } from '../../../../src/lib/oneStepPreApprovalBuilder';
 
 import {
   InvalidOneStepPreApprovalPrepareResponse,
diff --git a/modules/sdk-coin-canton/test/unit/builder/transferAcknowledge/transferAcknowledgeBuilder.ts b/modules/sdk-coin-canton/test/unit/builder/transferAcknowledge/transferAcknowledgeBuilder.ts
new file mode 100644
index 0000000000..d48fc14f87
--- /dev/null
+++ b/modules/sdk-coin-canton/test/unit/builder/transferAcknowledge/transferAcknowledgeBuilder.ts
@@ -0,0 +1,31 @@
+import assert from 'assert';
+import should from 'should';
+
+import { coins } from '@bitgo/statics';
+
+import { TransferAcknowledgeBuilder, Transaction } from '../../../../src';
+import { TransferAcknowledge } from '../../../../src/lib/iface';
+
+import { TransferAcknowledgeRequest } from '../../../resources';
+
+describe('Transfer Acknowledge Builder', () => {
+  it('should get the transfer acknowledge request object', function () {
+    const txBuilder = new TransferAcknowledgeBuilder(coins.get('tcanton'));
+    const tx = new Transaction(coins.get('tcanton'));
+    txBuilder.initBuilder(tx);
+    const { contractId, updateId, senderPartyId, amount, expiryEpoch } = TransferAcknowledgeRequest;
+    txBuilder
+      .contractId(contractId)
+      .senderPartyId(senderPartyId)
+      .updateId(updateId)
+      .amount(amount)
+      .expiryEpoch(expiryEpoch);
+    const requestObj: TransferAcknowledge = txBuilder.toRequestObject();
+    should.exist(requestObj);
+    assert.equal(requestObj.contractId, contractId);
+    assert.equal(requestObj.senderPartyId, senderPartyId);
+    assert.equal(requestObj.updateId, updateId);
+    assert.equal(requestObj.amount, amount);
+    assert.equal(requestObj.expiryEpoch, expiryEpoch);
+  });
+});
diff --git a/modules/sdk-core/src/account-lib/baseCoin/enum.ts b/modules/sdk-core/src/account-lib/baseCoin/enum.ts
index 689800c81f..14dd125214 100644
--- a/modules/sdk-core/src/account-lib/baseCoin/enum.ts
+++ b/modules/sdk-core/src/account-lib/baseCoin/enum.ts
@@ -91,6 +91,8 @@ export enum TransactionType {
   OneStepPreApproval,
   // canton transfer accept, 2-step
   TransferAccept,
+  // canton transfer acknowledgement
+  TransferAcknowledge,
 
   // trx
   FREEZE,