@bitgo-beta/sdk-coin-canton 1.0.1-beta.82 → 1.0.1-beta.821

package/dist/src/lib/transferBuilder.js

@@ -1,22 +1,184 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransferBuilder = void 0;
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
 const transactionBuilder_1 = require("./transactionBuilder");
+const utils_1 = __importDefault(require("./utils"));
+const amount_1 = require("./amount");
 class TransferBuilder extends transactionBuilder_1.TransactionBuilder {
     constructor(_coinConfig) {
         super(_coinConfig);
+        this._sendOneStep = false;
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        this.setTransactionType();
     }
     get transactionType() {
         return sdk_core_1.TransactionType.Send;
     }
+    setTransactionType() {
+        this.transaction.transactionType = sdk_core_1.TransactionType.Send;
+    }
     setTransaction(transaction) {
         this.transaction.prepareCommand = transaction;
     }
     /** @inheritDoc */
     addSignature(publicKey, signature) {
-        throw new Error('Not implemented');
+        if (!this.transaction) {
+            throw new sdk_core_1.InvalidTransactionError('transaction is empty!');
+        }
+        this._signatures.push({ publicKey, signature });
+        const pubKeyBase64 = utils_1.default.getBase64FromHex(publicKey.pub);
+        this.transaction.signerFingerprint = utils_1.default.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) {
+        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) {
+        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) {
+        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. Use a string or bigint above Number.MAX_SAFE_INTEGER.
+     * @returns The current builder instance for chaining.
+     * @throws Error if amount not present or negative
+     */
+    amount(amount) {
+        this._amount = (0, amount_1.normalizeCantonAmount)(amount, 'amount must be a positive number');
+        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) {
+        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) {
+        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) {
+        if (!id || !id.trim()) {
+            throw new Error('memoId must be a non-empty string');
+        }
+        this._memoId = id.trim();
+        return this;
+    }
+    /**
+     * Sets the optional token field if present, used for canton token transaction
+     * @param name - the bitgo name of the token
+     * @returns The current builder for chaining
+     * @throws Error if name is invalid
+     */
+    tokenName(name) {
+        if (!name || !name.trim()) {
+            throw new Error('token name must be a non-empty string');
+        }
+        this._tokenName = name.trim();
+        return this;
+    }
+    /**
+     * Get the canton transfer request object
+     * @returns CantonTransferRequest
+     * @throws Error if any required params are missing
+     */
+    toRequestObject() {
+        this.validate();
+        const data = {
+            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;
+        }
+        if (this._tokenName) {
+            data.tokenName = this._tokenName;
+        }
+        return data;
+    }
+    /**
+     * Method to validate the required fields
+     * @throws Error if required fields are not set
+     * @private
+     */
+    validate() {
+        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');
     }
 }
 exports.TransferBuilder = TransferBuilder;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmZXJCdWlsZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi90cmFuc2ZlckJ1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbURBQWtFO0FBRWxFLDZEQUEwRDtBQUcxRCxNQUFhLGVBQWdCLFNBQVEsdUNBQWtCO0lBQ3JELFlBQVksV0FBaUM7UUFDM0MsS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxJQUFjLGVBQWU7UUFDM0IsT0FBTywwQkFBZSxDQUFDLElBQUksQ0FBQztJQUM5QixDQUFDO0lBRUQsY0FBYyxDQUFDLFdBQXlDO1FBQ3RELElBQUksQ0FBQyxXQUFXLENBQUMsY0FBYyxHQUFHLFdBQVcsQ0FBQztJQUNoRCxDQUFDO0lBRUQsa0JBQWtCO0lBQ2xCLFlBQVksQ0FBQyxTQUFvQixFQUFFLFNBQWlCO1FBQ2xELE1BQU0sSUFBSSxLQUFLLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUNyQyxDQUFDO0NBQ0Y7QUFqQkQsMENBaUJDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUHVibGljS2V5LCBUcmFuc2FjdGlvblR5cGUgfSBmcm9tICdAYml0Z28tYmV0YS9zZGstY29yZSc7XG5pbXBvcnQgeyBCYXNlQ29pbiBhcyBDb2luQ29uZmlnIH0gZnJvbSAnQGJpdGdvLWJldGEvc3RhdGljcyc7XG5pbXBvcnQgeyBUcmFuc2FjdGlvbkJ1aWxkZXIgfSBmcm9tICcuL3RyYW5zYWN0aW9uQnVpbGRlcic7XG5pbXBvcnQgeyBDYW50b25QcmVwYXJlQ29tbWFuZFJlc3BvbnNlIH0gZnJvbSAnLi9pZmFjZSc7XG5cbmV4cG9ydCBjbGFzcyBUcmFuc2ZlckJ1aWxkZXIgZXh0ZW5kcyBUcmFuc2FjdGlvbkJ1aWxkZXIge1xuICBjb25zdHJ1Y3RvcihfY29pbkNvbmZpZzogUmVhZG9ubHk8Q29pbkNvbmZpZz4pIHtcbiAgICBzdXBlcihfY29pbkNvbmZpZyk7XG4gIH1cblxuICBwcm90ZWN0ZWQgZ2V0IHRyYW5zYWN0aW9uVHlwZSgpOiBUcmFuc2FjdGlvblR5cGUge1xuICAgIHJldHVybiBUcmFuc2FjdGlvblR5cGUuU2VuZDtcbiAgfVxuXG4gIHNldFRyYW5zYWN0aW9uKHRyYW5zYWN0aW9uOiBDYW50b25QcmVwYXJlQ29tbWFuZFJlc3BvbnNlKTogdm9pZCB7XG4gICAgdGhpcy50cmFuc2FjdGlvbi5wcmVwYXJlQ29tbWFuZCA9IHRyYW5zYWN0aW9uO1xuICB9XG5cbiAgLyoqIEBpbmhlcml0RG9jICovXG4gIGFkZFNpZ25hdHVyZShwdWJsaWNLZXk6IFB1YmxpY0tleSwgc2lnbmF0dXJlOiBCdWZmZXIpOiB2b2lkIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ05vdCBpbXBsZW1lbnRlZCcpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferBuilder.js","sourceRoot":"","sources":["../../../src/lib/transferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { InvalidTransactionError, PublicKey, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { Transaction } from './transaction/transaction';\nimport { CantonAmount, CantonAmountInput, CantonPrepareCommandResponse, CantonTransferRequest } from './iface';\nimport utils from './utils';\nimport { normalizeCantonAmount } from './amount';\n\nexport class TransferBuilder extends TransactionBuilder {\n  private _commandId: string;\n  private _senderId: string;\n  private _receiverId: string;\n  private _amount: CantonAmount;\n  private _sendOneStep = false;\n  private _expiryEpoch: number;\n  private _memoId: string;\n  private _tokenName: string;\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    this.setTransactionType();\n  }\n\n  get transactionType(): TransactionType {\n    return TransactionType.Send;\n  }\n\n  setTransactionType(): void {\n    this.transaction.transactionType = TransactionType.Send;\n  }\n\n  setTransaction(transaction: CantonPrepareCommandResponse): void {\n    this.transaction.prepareCommand = transaction;\n  }\n\n  /** @inheritDoc */\n  addSignature(publicKey: PublicKey, signature: Buffer): void {\n    if (!this.transaction) {\n      throw new InvalidTransactionError('transaction is empty!');\n    }\n    this._signatures.push({ publicKey, signature });\n    const pubKeyBase64 = utils.getBase64FromHex(publicKey.pub);\n    this.transaction.signerFingerprint = utils.getAddressFromPublicKey(pubKeyBase64);\n    this.transaction.signatures = signature.toString('base64');\n  }\n\n  /**\n   * Sets the unique id for the transfer\n   * Also sets the _id of the transaction\n   *\n   * @param id - A uuid\n   * @returns The current builder instance for chaining.\n   * @throws Error if id is empty.\n   */\n  commandId(id: string): this {\n    if (!id || !id.trim()) {\n      throw new Error('commandId must be a non-empty string');\n    }\n    this._commandId = id.trim();\n    // also set the transaction _id\n    this.transaction.id = id.trim();\n    return this;\n  }\n\n  /**\n   * Sets the sender party id for the transfer\n   * @param id - sender address (party id)\n   * @returns The current builder instance for chaining.\n   * @throws Error if id is empty.\n   */\n  senderId(id: string): this {\n    if (!id || !id.trim()) {\n      throw new Error('senderId must be a non-empty string');\n    }\n    this._senderId = id.trim();\n    return this;\n  }\n\n  /**\n   * Sets the receiver party id for the transfer\n   * @param id - receiver address (party id)\n   * @returns The current builder instance for chaining.\n   * @throws Error if id is empty.\n   */\n  receiverId(id: string): this {\n    if (!id || !id.trim()) {\n      throw new Error('receiverId must be a non-empty string');\n    }\n    this._receiverId = id.trim();\n    return this;\n  }\n\n  /**\n   * Sets the transfer amount.\n   * @param amount - transfer amount. Use a string or bigint above Number.MAX_SAFE_INTEGER.\n   * @returns The current builder instance for chaining.\n   * @throws Error if amount not present or negative\n   */\n  amount(amount: CantonAmountInput): this {\n    this._amount = normalizeCantonAmount(amount, 'amount must be a positive number');\n    return this;\n  }\n\n  /**\n   * Sets the 1-step enablement flag to send via 1-step, works only if recipient\n   * enabled the 1-step, defaults to `false`\n   * @param flag boolean value\n   * @returns The current builder for chaining\n   */\n  sendOneStep(flag: boolean): this {\n    this._sendOneStep = flag;\n    return this;\n  }\n\n  /**\n   * Sets the transfer expiry\n   * @param epoch - the expiry for 2-step transfer, defaults to 90 days and\n   * not applicable if sending via 1-step\n   * @returns The current builder for chaining\n   * @throws Error if the expiry value is invalid\n   */\n  expiryEpoch(epoch: number): this {\n    if (!epoch || epoch < 0) {\n      throw new Error('epoch must be a positive number');\n    }\n    this._expiryEpoch = epoch;\n    return this;\n  }\n\n  /**\n   * Sets the optional memoId if present\n   * @param id - memoId of the recipient\n   * @returns The current builder for chaining\n   * @throws Error if the memoId value is invalid\n   */\n  memoId(id: string): this {\n    if (!id || !id.trim()) {\n      throw new Error('memoId must be a non-empty string');\n    }\n    this._memoId = id.trim();\n    return this;\n  }\n\n  /**\n   * Sets the optional token field if present, used for canton token transaction\n   * @param name - the bitgo name of the token\n   * @returns The current builder for chaining\n   * @throws Error if name is invalid\n   */\n  tokenName(name: string): this {\n    if (!name || !name.trim()) {\n      throw new Error('token name must be a non-empty string');\n    }\n    this._tokenName = name.trim();\n    return this;\n  }\n\n  /**\n   * Get the canton transfer request object\n   * @returns CantonTransferRequest\n   * @throws Error if any required params are missing\n   */\n  toRequestObject(): CantonTransferRequest {\n    this.validate();\n    const data: CantonTransferRequest = {\n      commandId: this._commandId,\n      senderPartyId: this._senderId,\n      receiverPartyId: this._receiverId,\n      amount: this._amount,\n      expiryEpoch: this._expiryEpoch,\n      sendViaOneStep: this._sendOneStep,\n    };\n    if (this._memoId) {\n      data.memoId = this._memoId;\n    }\n    if (this._tokenName) {\n      data.tokenName = this._tokenName;\n    }\n    return data;\n  }\n\n  /**\n   * Method to validate the required fields\n   * @throws Error if required fields are not set\n   * @private\n   */\n  private validate(): void {\n    if (!this._commandId) throw new Error('commandId is missing');\n    if (!this._senderId) throw new Error('senderId is missing');\n    if (!this._receiverId) throw new Error('receiverId is missing');\n    if (!this._amount) throw new Error('amount is missing');\n    if (!this._expiryEpoch) throw new Error('expiryEpoch is missing');\n  }\n}\n"]}

package/dist/src/lib/transferOfferWithdrawnBuilder.d.ts

@@ -0,0 +1,67 @@
+import { PublicKey, TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { CantonPrepareCommandResponse, CantonTransferOfferWithdrawnRequest } from './iface';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction/transaction';
+export declare class TransferOfferWithdrawnBuilder extends TransactionBuilder {
+    private _commandId;
+    private _contractId;
+    private _actAsPartyId;
+    private _tokenName;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    initBuilder(tx: Transaction): void;
+    get transactionType(): TransactionType;
+    setTransactionType(): void;
+    setTransaction(transaction: CantonPrepareCommandResponse): void;
+    /** @inheritDoc */
+    addSignature(publicKey: PublicKey, signature: Buffer): void;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+//# sourceMappingURL=transferOfferWithdrawnBuilder.d.ts.map

package/dist/src/lib/transferOfferWithdrawnBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transferOfferWithdrawnBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transferOfferWithdrawnBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,SAAS,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,mCAAmC,EAAE,MAAM,SAAS,CAAC;AAC5F,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGxD,qBAAa,6BAA8B,SAAQ,kBAAkB;IACnE,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,UAAU,CAAS;gBACf,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAKlC,IAAI,eAAe,IAAI,eAAe,CAErC;IAED,kBAAkB,IAAI,IAAI;IAI1B,cAAc,CAAC,WAAW,EAAE,4BAA4B,GAAG,IAAI;IAI/D,kBAAkB;IAClB,YAAY,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAU3D;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAU3B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQ5B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQvB;;;;;OAKG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQ7B;;;;;;;;OAQG;IACH,eAAe,IAAI,mCAAmC;IAatD;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;CAKjB"}

package/dist/src/lib/transferOfferWithdrawnBuilder.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferOfferWithdrawnBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const utils_1 = __importDefault(require("./utils"));
+class TransferOfferWithdrawnBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        this.setTransactionType();
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.TransferOfferWithdrawn;
+    }
+    setTransactionType() {
+        this.transaction.transactionType = sdk_core_1.TransactionType.TransferOfferWithdrawn;
+    }
+    setTransaction(transaction) {
+        this.transaction.prepareCommand = transaction;
+    }
+    /** @inheritDoc */
+    addSignature(publicKey, signature) {
+        if (!this.transaction) {
+            throw new sdk_core_1.InvalidTransactionError('transaction is empty!');
+        }
+        this._signatures.push({ publicKey, signature });
+        const pubKeyBase64 = utils_1.default.getBase64FromHex(publicKey.pub);
+        this.transaction.signerFingerprint = utils_1.default.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) {
+        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) {
+        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) {
+        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) {
+        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() {
+        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.
+     */
+    validate() {
+        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');
+    }
+}
+exports.TransferOfferWithdrawnBuilder = TransferOfferWithdrawnBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferOfferWithdrawnBuilder.js","sourceRoot":"","sources":["../../../src/lib/transferOfferWithdrawnBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { InvalidTransactionError, PublicKey, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { CantonPrepareCommandResponse, CantonTransferOfferWithdrawnRequest } from './iface';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { Transaction } from './transaction/transaction';\nimport utils from './utils';\n\nexport class TransferOfferWithdrawnBuilder extends TransactionBuilder {\n  private _commandId: string;\n  private _contractId: string;\n  private _actAsPartyId: string;\n  private _tokenName: string;\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    this.setTransactionType();\n  }\n\n  get transactionType(): TransactionType {\n    return TransactionType.TransferOfferWithdrawn;\n  }\n\n  setTransactionType(): void {\n    this.transaction.transactionType = TransactionType.TransferOfferWithdrawn;\n  }\n\n  setTransaction(transaction: CantonPrepareCommandResponse): void {\n    this.transaction.prepareCommand = transaction;\n  }\n\n  /** @inheritDoc */\n  addSignature(publicKey: PublicKey, signature: Buffer): void {\n    if (!this.transaction) {\n      throw new InvalidTransactionError('transaction is empty!');\n    }\n    this._signatures.push({ publicKey, signature });\n    const pubKeyBase64 = utils.getBase64FromHex(publicKey.pub);\n    this.transaction.signerFingerprint = utils.getAddressFromPublicKey(pubKeyBase64);\n    this.transaction.signatures = signature.toString('base64');\n  }\n\n  /**\n   * Sets the unique id for the transfer offer withdrawn\n   * Also sets the _id of the transaction\n   *\n   * @param id - A uuid\n   * @returns The current builder instance for chaining.\n   * @throws Error if id is empty.\n   */\n  commandId(id: string): this {\n    if (!id || !id.trim()) {\n      throw new Error('commandId must be a non-empty string');\n    }\n    this._commandId = id.trim();\n    // also set the transaction _id\n    this.transaction.id = id.trim();\n    return this;\n  }\n\n  /**\n   * Sets the contract id the receiver needs to withdraw\n   * @param id - canton withdrawn contract id\n   * @returns The current builder instance for chaining.\n   * @throws Error if id is empty.\n   */\n  contractId(id: string): this {\n    if (!id || !id.trim()) {\n      throw new Error('contractId must be a non-empty string');\n    }\n    this._contractId = id.trim();\n    return this;\n  }\n\n  /**\n   * The sender who wants to withdraw the offer\n   *\n   * @param id - the sender party id\n   * @returns The current builder instance for chaining.\n   * @throws Error if id is empty.\n   */\n  actAs(id: string): this {\n    if (!id || !id.trim()) {\n      throw new Error('actAsPartyId must be a non-empty string');\n    }\n    this._actAsPartyId = id.trim();\n    return this;\n  }\n\n  /**\n   * The token name to withdraw the offer\n   * @param name - the bitgo name of the asset\n   * @returns The current builder instance for chaining.\n   * @throws Error if name is empty.\n   */\n  tokenName(name: string): this {\n    if (!name || !name.trim()) {\n      throw new Error('tokenName must be a non-empty string');\n    }\n    this._tokenName = name.trim();\n    return this;\n  }\n\n  /**\n   * Builds and returns the CantonTransferOfferWithdrawnRequest object from the builder's internal state.\n   *\n   * This method performs validation before constructing the object. If required fields are\n   * missing or invalid, it throws an error.\n   *\n   * @returns {CantonTransferOfferWithdrawnRequest} - A fully constructed and validated request object for transfer offer withdrawal.\n   * @throws {Error} If any required field is missing or fails validation.\n   */\n  toRequestObject(): CantonTransferOfferWithdrawnRequest {\n    this.validate();\n\n    return {\n      commandId: this._commandId,\n      contractId: this._contractId,\n      verboseHashing: false,\n      actAs: [this._actAsPartyId],\n      readAs: [],\n      tokenName: this._tokenName,\n    };\n  }\n\n  /**\n   * Validates the internal state of the builder before building the request object.\n   *\n   * @private\n   * @throws {Error} If any required field is missing or invalid.\n   */\n  private validate(): void {\n    if (!this._commandId) throw new Error('commandId is missing');\n    if (!this._contractId) throw new Error('contractId is missing');\n    if (!this._actAsPartyId) throw new Error('receiver partyId is missing');\n  }\n}\n"]}

package/dist/src/lib/transferPreapprovalCancelBuilder.d.ts

@@ -0,0 +1,68 @@
+import { PublicKey, TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { CantonPrepareCommandResponse, CantonTransferPreapprovalCancelRequest } from './iface';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction/transaction';
+/**
+ * Builds a transaction that reverts an active 1-step TransferPreapproval back to 2-step
+ * approval — the counterpart to OneStepPreApprovalBuilder. Structurally identical (same
+ * commandId/receiverPartyId/tokenName inputs, same request-object shape); the two are kept as
+ * separate builders/TransactionTypes (rather than a single builder with a direction flag) so
+ * each carries its own dedicated verifyTransaction validation, mirroring every other canton
+ * operation's one-intent-per-builder convention.
+ */
+export declare class TransferPreapprovalCancelBuilder extends TransactionBuilder {
+    private _commandId;
+    private _receiverPartyId;
+    private _tokenName;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    initBuilder(tx: Transaction): void;
+    get transactionType(): TransactionType;
+    setTransactionType(): void;
+    setTransaction(transaction: CantonPrepareCommandResponse): void;
+    /** @inheritDoc */
+    addSignature(publicKey: PublicKey, signature: Buffer): void;
+    /**
+     * Sets the unique id for the preapproval cancel.
+     * 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;
+    /**
+     * Sets the receiver (the party whose TransferPreapproval is being cancelled).
+     *
+     * @param id - the receiver party id (address)
+     * @returns The current builder instance for chaining.
+     * @throws Error if id is empty.
+     */
+    receiverPartyId(id: string): this;
+    /**
+     * Sets the optional token field if present, used for canton token preApproval cancellation.
+     * @param name - the bitgo name of the token
+     * @returns The current builder for chaining
+     * @throws Error if name is invalid
+     */
+    tokenName(name: string): this;
+    /**
+     * Builds and returns the CantonTransferPreapprovalCancelRequest 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 {CantonTransferPreapprovalCancelRequest} - A fully constructed and validated request object.
+     * @throws {Error} If any required field is missing or fails validation.
+     */
+    toRequestObject(): CantonTransferPreapprovalCancelRequest;
+    /**
+     * 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;
+}
+//# sourceMappingURL=transferPreapprovalCancelBuilder.d.ts.map

package/dist/src/lib/transferPreapprovalCancelBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transferPreapprovalCancelBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transferPreapprovalCancelBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,SAAS,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,sCAAsC,EAAE,MAAM,SAAS,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGxD;;;;;;;GAOG;AACH,qBAAa,gCAAiC,SAAQ,kBAAkB;IACtE,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,UAAU,CAAS;gBACf,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAKlC,IAAI,eAAe,IAAI,eAAe,CAErC;IAED,kBAAkB,IAAI,IAAI;IAI1B,cAAc,CAAC,WAAW,EAAE,4BAA4B,GAAG,IAAI;IAI/D,kBAAkB;IAClB,YAAY,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAU3D;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAU3B;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQjC;;;;;OAKG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQ7B;;;;;;;;;OASG;IACH,eAAe,IAAI,sCAAsC;IAazD;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;CAIjB"}

package/dist/src/lib/transferPreapprovalCancelBuilder.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferPreapprovalCancelBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const utils_1 = __importDefault(require("./utils"));
+/**
+ * Builds a transaction that reverts an active 1-step TransferPreapproval back to 2-step
+ * approval — the counterpart to OneStepPreApprovalBuilder. Structurally identical (same
+ * commandId/receiverPartyId/tokenName inputs, same request-object shape); the two are kept as
+ * separate builders/TransactionTypes (rather than a single builder with a direction flag) so
+ * each carries its own dedicated verifyTransaction validation, mirroring every other canton
+ * operation's one-intent-per-builder convention.
+ */
+class TransferPreapprovalCancelBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        this.setTransactionType();
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.TransferPreapprovalCancel;
+    }
+    setTransactionType() {
+        this.transaction.transactionType = sdk_core_1.TransactionType.TransferPreapprovalCancel;
+    }
+    setTransaction(transaction) {
+        this.transaction.prepareCommand = transaction;
+    }
+    /** @inheritDoc */
+    addSignature(publicKey, signature) {
+        if (!this.transaction) {
+            throw new sdk_core_1.InvalidTransactionError('transaction is empty!');
+        }
+        this._signatures.push({ publicKey, signature });
+        const pubKeyBase64 = utils_1.default.getBase64FromHex(publicKey.pub);
+        this.transaction.signerFingerprint = utils_1.default.getAddressFromPublicKey(pubKeyBase64);
+        this.transaction.signatures = signature.toString('base64');
+    }
+    /**
+     * Sets the unique id for the preapproval cancel.
+     * 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) {
+        if (!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 receiver (the party whose TransferPreapproval is being cancelled).
+     *
+     * @param id - the receiver party id (address)
+     * @returns The current builder instance for chaining.
+     * @throws Error if id is empty.
+     */
+    receiverPartyId(id) {
+        if (!id.trim()) {
+            throw new Error('receiverPartyId must be a non-empty string');
+        }
+        this._receiverPartyId = id.trim();
+        return this;
+    }
+    /**
+     * Sets the optional token field if present, used for canton token preApproval cancellation.
+     * @param name - the bitgo name of the token
+     * @returns The current builder for chaining
+     * @throws Error if name is invalid
+     */
+    tokenName(name) {
+        if (!name || !name.trim()) {
+            throw new Error('token name must be a non-empty string');
+        }
+        this._tokenName = name.trim();
+        return this;
+    }
+    /**
+     * Builds and returns the CantonTransferPreapprovalCancelRequest 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 {CantonTransferPreapprovalCancelRequest} - A fully constructed and validated request object.
+     * @throws {Error} If any required field is missing or fails validation.
+     */
+    toRequestObject() {
+        this.validate();
+        return {
+            commandId: this._commandId,
+            receiverId: this._receiverPartyId,
+            verboseHashing: false,
+            actAs: [this._receiverPartyId],
+            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.
+     */
+    validate() {
+        if (!this._commandId)
+            throw new Error('commandId is missing');
+        if (!this._receiverPartyId)
+            throw new Error('receiver partyId is missing');
+    }
+}
+exports.TransferPreapprovalCancelBuilder = TransferPreapprovalCancelBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferPreapprovalCancelBuilder.js","sourceRoot":"","sources":["../../../src/lib/transferPreapprovalCancelBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { InvalidTransactionError, PublicKey, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { CantonPrepareCommandResponse, CantonTransferPreapprovalCancelRequest } from './iface';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { Transaction } from './transaction/transaction';\nimport utils from './utils';\n\n/**\n * Builds a transaction that reverts an active 1-step TransferPreapproval back to 2-step\n * approval — the counterpart to OneStepPreApprovalBuilder. Structurally identical (same\n * commandId/receiverPartyId/tokenName inputs, same request-object shape); the two are kept as\n * separate builders/TransactionTypes (rather than a single builder with a direction flag) so\n * each carries its own dedicated verifyTransaction validation, mirroring every other canton\n * operation's one-intent-per-builder convention.\n */\nexport class TransferPreapprovalCancelBuilder extends TransactionBuilder {\n  private _commandId: string;\n  private _receiverPartyId: string;\n  private _tokenName: string;\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    this.setTransactionType();\n  }\n\n  get transactionType(): TransactionType {\n    return TransactionType.TransferPreapprovalCancel;\n  }\n\n  setTransactionType(): void {\n    this.transaction.transactionType = TransactionType.TransferPreapprovalCancel;\n  }\n\n  setTransaction(transaction: CantonPrepareCommandResponse): void {\n    this.transaction.prepareCommand = transaction;\n  }\n\n  /** @inheritDoc */\n  addSignature(publicKey: PublicKey, signature: Buffer): void {\n    if (!this.transaction) {\n      throw new InvalidTransactionError('transaction is empty!');\n    }\n    this._signatures.push({ publicKey, signature });\n    const pubKeyBase64 = utils.getBase64FromHex(publicKey.pub);\n    this.transaction.signerFingerprint = utils.getAddressFromPublicKey(pubKeyBase64);\n    this.transaction.signatures = signature.toString('base64');\n  }\n\n  /**\n   * Sets the unique id for the preapproval cancel.\n   * Also sets the _id of the transaction.\n   *\n   * @param id - A uuid\n   * @returns The current builder instance for chaining.\n   * @throws Error if id is empty.\n   */\n  commandId(id: string): this {\n    if (!id.trim()) {\n      throw new Error('commandId must be a non-empty string');\n    }\n    this._commandId = id.trim();\n    // also set the transaction _id\n    this.transaction.id = id.trim();\n    return this;\n  }\n\n  /**\n   * Sets the receiver (the party whose TransferPreapproval is being cancelled).\n   *\n   * @param id - the receiver party id (address)\n   * @returns The current builder instance for chaining.\n   * @throws Error if id is empty.\n   */\n  receiverPartyId(id: string): this {\n    if (!id.trim()) {\n      throw new Error('receiverPartyId must be a non-empty string');\n    }\n    this._receiverPartyId = id.trim();\n    return this;\n  }\n\n  /**\n   * Sets the optional token field if present, used for canton token preApproval cancellation.\n   * @param name - the bitgo name of the token\n   * @returns The current builder for chaining\n   * @throws Error if name is invalid\n   */\n  tokenName(name: string): this {\n    if (!name || !name.trim()) {\n      throw new Error('token name must be a non-empty string');\n    }\n    this._tokenName = name.trim();\n    return this;\n  }\n\n  /**\n   * Builds and returns the CantonTransferPreapprovalCancelRequest object from the builder's\n   * internal state.\n   *\n   * This method performs validation before constructing the object. If required fields are\n   * missing or invalid, it throws an error.\n   *\n   * @returns {CantonTransferPreapprovalCancelRequest} - A fully constructed and validated request object.\n   * @throws {Error} If any required field is missing or fails validation.\n   */\n  toRequestObject(): CantonTransferPreapprovalCancelRequest {\n    this.validate();\n\n    return {\n      commandId: this._commandId,\n      receiverId: this._receiverPartyId,\n      verboseHashing: false,\n      actAs: [this._receiverPartyId],\n      readAs: [],\n      tokenName: this._tokenName,\n    };\n  }\n\n  /**\n   * Validates the internal state of the builder before building the request object.\n   *\n   * @private\n   * @throws {Error} If any required field is missing or invalid.\n   */\n  private validate(): void {\n    if (!this._commandId) throw new Error('commandId is missing');\n    if (!this._receiverPartyId) throw new Error('receiver partyId is missing');\n  }\n}\n"]}