@bitgo-beta/sdk-coin-stx 1.1.1-beta.232 → 1.1.1-beta.2321

package/dist/src/lib/pox5Builder.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pox5Builder = void 0;
+const transactions_1 = require("@stacks/transactions");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const contractBuilder_1 = require("./contractBuilder");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+function byteBuffer(value, field, expectedLength) {
+    // String inputs are hexadecimal, with an optional 0x prefix; use Buffer for text bytes.
+    let buffer;
+    if (Buffer.isBuffer(value)) {
+        buffer = value;
+    }
+    else if (value instanceof Uint8Array) {
+        buffer = Buffer.from(value);
+    }
+    else {
+        const hex = value.startsWith('0x') ? value.slice(2) : value;
+        if (hex.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(hex)) {
+            throw new sdk_core_1.InvalidParameterValueError(`${field} must be an even-length hexadecimal string`);
+        }
+        buffer = Buffer.from(hex, 'hex');
+    }
+    if (expectedLength !== undefined && buffer.length !== expectedLength) {
+        throw new sdk_core_1.InvalidParameterValueError(`${field} must be exactly ${expectedLength} bytes`);
+    }
+    return buffer;
+}
+function optionalBuffer(value) {
+    return value === undefined ? (0, transactions_1.noneCV)() : (0, transactions_1.someCV)((0, transactions_1.bufferCV)(byteBuffer(value, 'signerCalldata')));
+}
+function lockupValue(lockup) {
+    if (lockup.kind === 'sbtc') {
+        // PoX-5 ABI represents an sBTC lockup as err uint and an L1 BTC lockup as ok tuple.
+        return (0, transactions_1.responseErrorCV)((0, transactions_1.uintCV)(lockup.sbtcSats));
+    }
+    if (lockup.outputs.length === 0 || lockup.outputs.length > 10) {
+        throw new sdk_core_1.InvalidParameterValueError('btc lockup outputs must contain between 1 and 10 outputs');
+    }
+    for (const [index, output] of lockup.outputs.entries()) {
+        if (output.leafHashes.length > 14) {
+            throw new sdk_core_1.InvalidParameterValueError(`btc lockup output ${index} has more than 14 merkle siblings`);
+        }
+    }
+    return (0, transactions_1.responseOkCV)((0, transactions_1.tupleCV)({
+        outputs: (0, transactions_1.listCV)(lockup.outputs.map((output) => (0, transactions_1.tupleCV)({
+            height: (0, transactions_1.uintCV)(output.height),
+            tx: (0, transactions_1.bufferCV)(byteBuffer(output.tx, 'tx')),
+            'output-index': (0, transactions_1.uintCV)(output.outputIndex),
+            header: (0, transactions_1.bufferCV)(byteBuffer(output.header, 'header', 80)),
+            'leaf-hashes': (0, transactions_1.listCV)(output.leafHashes.map((hash) => (0, transactions_1.bufferCV)(byteBuffer(hash, 'leafHash', 32)))),
+            'tx-count': (0, transactions_1.uintCV)(output.txCount),
+            'tx-index': (0, transactions_1.uintCV)(output.txIndex),
+            amount: (0, transactions_1.uintCV)(output.amount),
+            'unlock-burn-height': (0, transactions_1.uintCV)(output.unlockBurnHeight),
+        }))),
+        'staker-unlock-bytes': (0, transactions_1.bufferCV)(byteBuffer(lockup.unlockBytes, 'unlockBytes')),
+    }));
+}
+class Pox5Builder extends contractBuilder_1.ContractBuilder {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._contractAddress = coinConfig.network.stakingContractAddress;
+        this._contractName = constants_1.CONTRACT_NAME_POX5;
+    }
+    static isValidContractCall(coinConfig, payload) {
+        return (coinConfig.network.stakingContractAddress === (0, transactions_1.addressToString)(payload.contractAddress) &&
+            payload.contractName.content === constants_1.CONTRACT_NAME_POX5);
+    }
+    registerForBond(params) {
+        this.functionName(constants_1.FUNCTION_NAME_REGISTER_FOR_BOND);
+        this.functionArgs([
+            (0, transactions_1.uintCV)(params.bondIndex),
+            (0, utils_1.contractPrincipalCVFromString)(params.signerManager),
+            (0, transactions_1.uintCV)(params.amountUstx),
+            lockupValue(params.lockup),
+            optionalBuffer(params.signerCalldata),
+        ]);
+        return this;
+    }
+    updateBondRegistration(params) {
+        this.functionName(constants_1.FUNCTION_NAME_UPDATE_BOND_REGISTRATION);
+        this.functionArgs([
+            (0, utils_1.contractPrincipalCVFromString)(params.signerManager),
+            (0, utils_1.contractPrincipalCVFromString)(params.oldSignerManager),
+            optionalBuffer(params.signerCalldata),
+        ]);
+        return this;
+    }
+    announceL1EarlyExit(params) {
+        this.functionName(constants_1.FUNCTION_NAME_ANNOUNCE_L1_EARLY_EXIT);
+        this.functionArgs([
+            (0, utils_1.standardPrincipalCVFromString)(params.staker),
+            (0, utils_1.contractPrincipalCVFromString)(params.oldSignerManager),
+        ]);
+        return this;
+    }
+    stake(params) {
+        this.functionName(constants_1.FUNCTION_NAME_STAKE);
+        this.functionArgs([
+            (0, utils_1.contractPrincipalCVFromString)(params.signerManager),
+            (0, transactions_1.uintCV)(params.amountUstx),
+            (0, transactions_1.uintCV)(params.numCycles),
+            (0, transactions_1.uintCV)(params.startBurnHt),
+            optionalBuffer(params.signerCalldata),
+        ]);
+        return this;
+    }
+    stakeUpdate(params) {
+        this.functionName(constants_1.FUNCTION_NAME_STAKE_UPDATE);
+        this.functionArgs([
+            (0, utils_1.contractPrincipalCVFromString)(params.signerManager),
+            (0, utils_1.contractPrincipalCVFromString)(params.oldSignerManager),
+            // The PoX-5 ABI uses uint values; omitted values intentionally encode zero.
+            (0, transactions_1.uintCV)(params.cyclesToExtend ?? 0),
+            (0, transactions_1.uintCV)(params.amountIncrease ?? 0),
+            optionalBuffer(params.signerCalldata),
+        ]);
+        return this;
+    }
+    unstake(oldSignerManager) {
+        this.functionName(constants_1.FUNCTION_NAME_UNSTAKE);
+        this.functionArgs([(0, utils_1.contractPrincipalCVFromString)(oldSignerManager)]);
+        return this;
+    }
+    calculateRewards(bondIndices) {
+        this.functionName(constants_1.FUNCTION_NAME_CALCULATE_REWARDS);
+        this.functionArgs([(0, transactions_1.listCV)(bondIndices.map((bondIndex) => (0, transactions_1.uintCV)(bondIndex)))]);
+        return this;
+    }
+    claimRewards(params) {
+        this.functionName(constants_1.FUNCTION_NAME_CLAIM_REWARDS);
+        this.functionArgs([(0, transactions_1.listCV)(params.bondIndices.map((bondIndex) => (0, transactions_1.uintCV)(bondIndex))), (0, transactions_1.uintCV)(params.rewardCycle)]);
+        return this;
+    }
+    claimStakerRewardsForSigner(params) {
+        this.functionName(constants_1.FUNCTION_NAME_CLAIM_STAKER_REWARDS);
+        this.functionArgs([
+            (0, utils_1.standardPrincipalCVFromString)(params.staker),
+            (0, transactions_1.uintCV)(params.rewardCycle),
+            params.bondIndex === undefined ? (0, transactions_1.noneCV)() : (0, transactions_1.someCV)((0, transactions_1.uintCV)(params.bondIndex)),
+        ]);
+        return this;
+    }
+}
+exports.Pox5Builder = Pox5Builder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pox5Builder.js","sourceRoot":"","sources":["../../../src/lib/pox5Builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig, StacksNetwork as BitgoStacksNetwork } from '@bitgo-beta/statics';\nimport {\n  bufferCV,\n  ContractCallPayload,\n  ClarityValue,\n  listCV,\n  noneCV,\n  responseErrorCV,\n  responseOkCV,\n  someCV,\n  tupleCV,\n  uintCV,\n  addressToString,\n} from '@stacks/transactions';\nimport { InvalidParameterValueError } from '@bitgo-beta/sdk-core';\nimport { ContractBuilder } from './contractBuilder';\nimport {\n  CONTRACT_NAME_POX5,\n  FUNCTION_NAME_ANNOUNCE_L1_EARLY_EXIT,\n  FUNCTION_NAME_CALCULATE_REWARDS,\n  FUNCTION_NAME_CLAIM_REWARDS,\n  FUNCTION_NAME_CLAIM_STAKER_REWARDS,\n  FUNCTION_NAME_REGISTER_FOR_BOND,\n  FUNCTION_NAME_STAKE,\n  FUNCTION_NAME_STAKE_UPDATE,\n  FUNCTION_NAME_UNSTAKE,\n  FUNCTION_NAME_UPDATE_BOND_REGISTRATION,\n} from './constants';\nimport { contractPrincipalCVFromString, standardPrincipalCVFromString } from './utils';\n\ntype Integer = bigint | number | string;\ntype ByteValue = Buffer | Uint8Array | string;\n\nexport interface Pox5LockupOutput {\n  height: number;\n  tx: ByteValue;\n  outputIndex: number;\n  header: ByteValue;\n  leafHashes: ByteValue[];\n  txCount: number;\n  txIndex: number;\n  amount: Integer;\n  unlockBurnHeight: number;\n}\n\nexport type Pox5Lockup =\n  | {\n      kind: 'btc';\n      outputs: Pox5LockupOutput[];\n      unlockBytes: ByteValue;\n    }\n  | {\n      kind: 'sbtc';\n      sbtcSats: Integer;\n    };\n\nexport interface Pox5RegisterForBondParams {\n  bondIndex: Integer;\n  signerManager: string;\n  amountUstx: Integer;\n  lockup: Pox5Lockup;\n  signerCalldata?: ByteValue;\n}\n\nexport interface Pox5UpdateBondRegistrationParams {\n  signerManager: string;\n  oldSignerManager: string;\n  signerCalldata?: ByteValue;\n}\n\nexport interface Pox5AnnounceL1EarlyExitParams {\n  staker: string;\n  oldSignerManager: string;\n}\n\nexport interface Pox5StakeParams {\n  signerManager: string;\n  amountUstx: Integer;\n  numCycles: Integer;\n  startBurnHt: Integer;\n  signerCalldata?: ByteValue;\n}\n\nexport interface Pox5StakeUpdateParams {\n  signerManager: string;\n  oldSignerManager: string;\n  cyclesToExtend?: Integer;\n  amountIncrease?: Integer;\n  signerCalldata?: ByteValue;\n}\n\nexport interface Pox5ClaimRewardsParams {\n  bondIndices: Integer[];\n  rewardCycle: Integer;\n}\n\nexport interface Pox5ClaimStakerRewardsParams {\n  staker: string;\n  rewardCycle: Integer;\n  bondIndex?: Integer;\n}\n\nfunction byteBuffer(value: ByteValue, field: string, expectedLength?: number): Buffer {\n  // String inputs are hexadecimal, with an optional 0x prefix; use Buffer for text bytes.\n  let buffer: Buffer;\n  if (Buffer.isBuffer(value)) {\n    buffer = value;\n  } else if (value instanceof Uint8Array) {\n    buffer = Buffer.from(value);\n  } else {\n    const hex = value.startsWith('0x') ? value.slice(2) : value;\n    if (hex.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(hex)) {\n      throw new InvalidParameterValueError(`${field} must be an even-length hexadecimal string`);\n    }\n    buffer = Buffer.from(hex, 'hex');\n  }\n  if (expectedLength !== undefined && buffer.length !== expectedLength) {\n    throw new InvalidParameterValueError(`${field} must be exactly ${expectedLength} bytes`);\n  }\n  return buffer;\n}\n\nfunction optionalBuffer(value: ByteValue | undefined): ClarityValue {\n  return value === undefined ? noneCV() : someCV(bufferCV(byteBuffer(value, 'signerCalldata')));\n}\n\nfunction lockupValue(lockup: Pox5Lockup): ClarityValue {\n  if (lockup.kind === 'sbtc') {\n    // PoX-5 ABI represents an sBTC lockup as err uint and an L1 BTC lockup as ok tuple.\n    return responseErrorCV(uintCV(lockup.sbtcSats));\n  }\n  if (lockup.outputs.length === 0 || lockup.outputs.length > 10) {\n    throw new InvalidParameterValueError('btc lockup outputs must contain between 1 and 10 outputs');\n  }\n  for (const [index, output] of lockup.outputs.entries()) {\n    if (output.leafHashes.length > 14) {\n      throw new InvalidParameterValueError(`btc lockup output ${index} has more than 14 merkle siblings`);\n    }\n  }\n  return responseOkCV(\n    tupleCV({\n      outputs: listCV(\n        lockup.outputs.map((output) =>\n          tupleCV({\n            height: uintCV(output.height),\n            tx: bufferCV(byteBuffer(output.tx, 'tx')),\n            'output-index': uintCV(output.outputIndex),\n            header: bufferCV(byteBuffer(output.header, 'header', 80)),\n            'leaf-hashes': listCV(output.leafHashes.map((hash) => bufferCV(byteBuffer(hash, 'leafHash', 32)))),\n            'tx-count': uintCV(output.txCount),\n            'tx-index': uintCV(output.txIndex),\n            amount: uintCV(output.amount),\n            'unlock-burn-height': uintCV(output.unlockBurnHeight),\n          })\n        )\n      ),\n      'staker-unlock-bytes': bufferCV(byteBuffer(lockup.unlockBytes, 'unlockBytes')),\n    })\n  );\n}\n\nexport class Pox5Builder extends ContractBuilder {\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._contractAddress = (coinConfig.network as BitgoStacksNetwork).stakingContractAddress;\n    this._contractName = CONTRACT_NAME_POX5;\n  }\n\n  public static isValidContractCall(coinConfig: Readonly<CoinConfig>, payload: ContractCallPayload): boolean {\n    return (\n      (coinConfig.network as BitgoStacksNetwork).stakingContractAddress === addressToString(payload.contractAddress) &&\n      payload.contractName.content === CONTRACT_NAME_POX5\n    );\n  }\n\n  registerForBond(params: Pox5RegisterForBondParams): this {\n    this.functionName(FUNCTION_NAME_REGISTER_FOR_BOND);\n    this.functionArgs([\n      uintCV(params.bondIndex),\n      contractPrincipalCVFromString(params.signerManager),\n      uintCV(params.amountUstx),\n      lockupValue(params.lockup),\n      optionalBuffer(params.signerCalldata),\n    ]);\n    return this;\n  }\n\n  updateBondRegistration(params: Pox5UpdateBondRegistrationParams): this {\n    this.functionName(FUNCTION_NAME_UPDATE_BOND_REGISTRATION);\n    this.functionArgs([\n      contractPrincipalCVFromString(params.signerManager),\n      contractPrincipalCVFromString(params.oldSignerManager),\n      optionalBuffer(params.signerCalldata),\n    ]);\n    return this;\n  }\n\n  announceL1EarlyExit(params: Pox5AnnounceL1EarlyExitParams): this {\n    this.functionName(FUNCTION_NAME_ANNOUNCE_L1_EARLY_EXIT);\n    this.functionArgs([\n      standardPrincipalCVFromString(params.staker),\n      contractPrincipalCVFromString(params.oldSignerManager),\n    ]);\n    return this;\n  }\n\n  stake(params: Pox5StakeParams): this {\n    this.functionName(FUNCTION_NAME_STAKE);\n    this.functionArgs([\n      contractPrincipalCVFromString(params.signerManager),\n      uintCV(params.amountUstx),\n      uintCV(params.numCycles),\n      uintCV(params.startBurnHt),\n      optionalBuffer(params.signerCalldata),\n    ]);\n    return this;\n  }\n\n  stakeUpdate(params: Pox5StakeUpdateParams): this {\n    this.functionName(FUNCTION_NAME_STAKE_UPDATE);\n    this.functionArgs([\n      contractPrincipalCVFromString(params.signerManager),\n      contractPrincipalCVFromString(params.oldSignerManager),\n      // The PoX-5 ABI uses uint values; omitted values intentionally encode zero.\n      uintCV(params.cyclesToExtend ?? 0),\n      uintCV(params.amountIncrease ?? 0),\n      optionalBuffer(params.signerCalldata),\n    ]);\n    return this;\n  }\n\n  unstake(oldSignerManager: string): this {\n    this.functionName(FUNCTION_NAME_UNSTAKE);\n    this.functionArgs([contractPrincipalCVFromString(oldSignerManager)]);\n    return this;\n  }\n\n  calculateRewards(bondIndices: Integer[]): this {\n    this.functionName(FUNCTION_NAME_CALCULATE_REWARDS);\n    this.functionArgs([listCV(bondIndices.map((bondIndex) => uintCV(bondIndex)))]);\n    return this;\n  }\n\n  claimRewards(params: Pox5ClaimRewardsParams): this {\n    this.functionName(FUNCTION_NAME_CLAIM_REWARDS);\n    this.functionArgs([listCV(params.bondIndices.map((bondIndex) => uintCV(bondIndex))), uintCV(params.rewardCycle)]);\n    return this;\n  }\n\n  claimStakerRewardsForSigner(params: Pox5ClaimStakerRewardsParams): this {\n    this.functionName(FUNCTION_NAME_CLAIM_STAKER_REWARDS);\n    this.functionArgs([\n      standardPrincipalCVFromString(params.staker),\n      uintCV(params.rewardCycle),\n      params.bondIndex === undefined ? noneCV() : someCV(uintCV(params.bondIndex)),\n    ]);\n    return this;\n  }\n}\n"]}

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

@@ -0,0 +1,38 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Transaction } from './transaction';
+import { SbtcWithdrawParams } from './iface';
+import { ContractCallPayload } from '@stacks/transactions/dist/payload';
+import { AbstractContractBuilder } from './abstractContractBuilder';
+export declare class SbtcWithdrawBuilder extends AbstractContractBuilder {
+    private _withdrawParams;
+    private _isDeserialized;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Check whether a deserialized contract-call payload matches the sBTC withdrawal contract.
+     */
+    static isValidContractCall(coinConfig: Readonly<CoinConfig>, payload: ContractCallPayload): boolean;
+    /**
+     * Set withdrawal parameters.
+     *
+     * @param {SbtcWithdrawParams} params - amount (satoshis), btcAddress, maxFee
+     * @returns {this}
+     */
+    withdraw(params: SbtcWithdrawParams): this;
+    initBuilder(tx: Transaction): void;
+    /**
+     * Get the withdrawal params decoded from the deserialized/built transaction, including the
+     * raw sBTC recipient version and hash bytes (as opposed to a btcAddress string, which cannot
+     * be recovered from the on-chain args alone).
+     */
+    getWithdrawParams(): {
+        amount: string;
+        maxFee: string;
+        recipientVersion: number;
+        recipientHashBytes: Buffer;
+    } | undefined;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    private withdrawParamsToFunctionArgs;
+    private withdrawParamsToPostCondition;
+}
+//# sourceMappingURL=sbtcWithdrawBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sbtcWithdrawBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/sbtcWithdrawBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAoD,MAAM,qBAAqB,CAAC;AAiB/G,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAMpE,qBAAa,mBAAoB,SAAQ,uBAAuB;IAC9D,OAAO,CAAC,eAAe,CAAiC;IACxD,OAAO,CAAC,eAAe,CAAS;gBAEpB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;OAEG;WACW,mBAAmB,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO;IAS1G;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IAc1C,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAuClC;;;;OAIG;IACH,iBAAiB,IACb;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAA;KAAE,GACxF,SAAS;IAsBb,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAqB3D,OAAO,CAAC,4BAA4B;IAYpC,OAAO,CAAC,6BAA6B;CAqBtC"}

package/dist/src/lib/sbtcWithdrawBuilder.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SbtcWithdrawBuilder = void 0;
+const statics_1 = require("@bitgo-beta/statics");
+const bn_js_1 = __importDefault(require("bn.js"));
+const transactions_1 = require("@stacks/transactions");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+const abstractContractBuilder_1 = require("./abstractContractBuilder");
+const btcAddressUtils_1 = require("./btcAddressUtils");
+const SBTC_TOKEN_CONTRACT_NAME = 'sbtc-token';
+const SBTC_TOKEN_ASSET_NAME = 'sbtc-token';
+class SbtcWithdrawBuilder extends abstractContractBuilder_1.AbstractContractBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._isDeserialized = false;
+    }
+    /**
+     * Check whether a deserialized contract-call payload matches the sBTC withdrawal contract.
+     */
+    static isValidContractCall(coinConfig, payload) {
+        return (coinConfig.network.sbtcWithdrawalContractAddress ===
+            (0, transactions_1.addressToString)(payload.contractAddress) &&
+            constants_1.CONTRACT_NAME_SBTC_WITHDRAWAL === payload.contractName.content &&
+            constants_1.FUNCTION_NAME_INITIATE_WITHDRAWAL === payload.functionName.content);
+    }
+    /**
+     * Set withdrawal parameters.
+     *
+     * @param {SbtcWithdrawParams} params - amount (satoshis), btcAddress, maxFee
+     * @returns {this}
+     */
+    withdraw(params) {
+        if (!params.amount || !(0, utils_1.isValidAmount)(params.amount) || params.amount === '0') {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing amount, got: ' + params.amount);
+        }
+        if (!params.btcAddress || !(0, btcAddressUtils_1.isValidBtcAddress)(params.btcAddress)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing btcAddress, got: ' + params.btcAddress);
+        }
+        if (!params.maxFee || !(0, utils_1.isValidAmount)(params.maxFee) || params.maxFee === '0') {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing maxFee, got: ' + params.maxFee);
+        }
+        this._withdrawParams = params;
+        return this;
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        const payload = tx.stxTransaction.payload;
+        const args = payload.functionArgs;
+        if (args.length !== 3) {
+            throw new sdk_core_1.BuildTransactionError('Invalid number of function args for sBTC withdrawal');
+        }
+        // args[0] = uint (amount)
+        if (args[0].type !== transactions_1.ClarityType.UInt) {
+            throw new sdk_core_1.BuildTransactionError('Expected uint for amount argument');
+        }
+        const amount = args[0].value.toString();
+        // args[1] = tuple { version: (buff 1), hashbytes: (buff 32) }
+        if (args[1].type !== transactions_1.ClarityType.Tuple) {
+            throw new sdk_core_1.BuildTransactionError('Expected tuple for recipient argument');
+        }
+        const versionBuf = args[1].data['version'];
+        const hashbytesBuf = args[1].data['hashbytes'];
+        if (versionBuf?.type !== transactions_1.ClarityType.Buffer || hashbytesBuf?.type !== transactions_1.ClarityType.Buffer) {
+            throw new sdk_core_1.BuildTransactionError('Expected buffer fields in recipient tuple');
+        }
+        // args[2] = uint (max-fee)
+        if (args[2].type !== transactions_1.ClarityType.UInt) {
+            throw new sdk_core_1.BuildTransactionError('Expected uint for max-fee argument');
+        }
+        const maxFee = args[2].value.toString();
+        this._withdrawParams = {
+            amount,
+            btcAddress: '', // not needed for rebuild; function args are preserved from the original tx
+            maxFee,
+        };
+        this._isDeserialized = true;
+    }
+    /**
+     * Get the withdrawal params decoded from the deserialized/built transaction, including the
+     * raw sBTC recipient version and hash bytes (as opposed to a btcAddress string, which cannot
+     * be recovered from the on-chain args alone).
+     */
+    getWithdrawParams() {
+        if (!this._withdrawParams) {
+            return undefined;
+        }
+        const payload = this.transaction.stxTransaction.payload;
+        const recipientTuple = payload.functionArgs[1];
+        if (recipientTuple?.type !== transactions_1.ClarityType.Tuple) {
+            return undefined;
+        }
+        const versionBuf = recipientTuple.data['version'];
+        const hashbytesBuf = recipientTuple.data['hashbytes'];
+        if (versionBuf?.type !== transactions_1.ClarityType.Buffer || hashbytesBuf?.type !== transactions_1.ClarityType.Buffer) {
+            return undefined;
+        }
+        return {
+            amount: this._withdrawParams.amount,
+            maxFee: this._withdrawParams.maxFee,
+            recipientVersion: versionBuf.buffer[0],
+            recipientHashBytes: Buffer.from(hashbytesBuf.buffer),
+        };
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        if (!this._withdrawParams) {
+            throw new sdk_core_1.BuildTransactionError('Withdrawal params are not set. Use withdraw() to set them.');
+        }
+        const network = this._coinConfig.network;
+        this._contractAddress = network.sbtcWithdrawalContractAddress;
+        this._contractName = constants_1.CONTRACT_NAME_SBTC_WITHDRAWAL;
+        this._functionName = constants_1.FUNCTION_NAME_INITIATE_WITHDRAWAL;
+        // For deserialized transactions, function args are already preserved from the original tx.
+        // For fresh builds, construct them from the withdraw params.
+        if (!this._isDeserialized) {
+            this._functionArgs = this.withdrawParamsToFunctionArgs(this._withdrawParams);
+        }
+        this._postConditionMode = transactions_1.PostConditionMode.Deny;
+        this._postConditions = this.withdrawParamsToPostCondition(this._withdrawParams);
+        return await super.buildImplementation();
+    }
+    withdrawParamsToFunctionArgs(params) {
+        const decoded = (0, btcAddressUtils_1.decodeBtcAddress)(params.btcAddress);
+        return [
+            (0, transactions_1.uintCV)(params.amount),
+            (0, transactions_1.tupleCV)({
+                version: (0, transactions_1.bufferCV)(Buffer.from([decoded.version])),
+                hashbytes: (0, transactions_1.bufferCV)(decoded.hashBytes),
+            }),
+            (0, transactions_1.uintCV)(params.maxFee),
+        ];
+    }
+    withdrawParamsToPostCondition(params) {
+        const amount = new bn_js_1.default(params.amount).add(new bn_js_1.default(params.maxFee));
+        const network = this._coinConfig.network;
+        const sbtcContractAddress = network.sbtcWithdrawalContractAddress;
+        return [
+            (0, transactions_1.makeStandardFungiblePostCondition)((0, utils_1.getSTXAddressFromPubKeys)(this._fromPubKeys, this._coinConfig.network.type === statics_1.NetworkType.MAINNET
+                ? transactions_1.AddressVersion.MainnetMultiSig
+                : transactions_1.AddressVersion.TestnetMultiSig, this._fromPubKeys.length > 1 ? transactions_1.AddressHashMode.SerializeP2SH : transactions_1.AddressHashMode.SerializeP2PKH, this._numberSignatures).address, transactions_1.FungibleConditionCode.Equal, amount.toString(), (0, transactions_1.createAssetInfo)(sbtcContractAddress, SBTC_TOKEN_CONTRACT_NAME, SBTC_TOKEN_ASSET_NAME)),
+        ];
+    }
+}
+exports.SbtcWithdrawBuilder = SbtcWithdrawBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sbtcWithdrawBuilder.js","sourceRoot":"","sources":["../../../src/lib/sbtcWithdrawBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig, NetworkType, StacksNetwork as BitgoStacksNetwork } from '@bitgo-beta/statics';\nimport BigNum from 'bn.js';\nimport {\n  AddressHashMode,\n  addressToString,\n  AddressVersion,\n  bufferCV,\n  ClarityType,\n  createAssetInfo,\n  FungibleConditionCode,\n  makeStandardFungiblePostCondition,\n  PostCondition,\n  PostConditionMode,\n  tupleCV,\n  uintCV,\n} from '@stacks/transactions';\nimport { BuildTransactionError } from '@bitgo-beta/sdk-core';\nimport { Transaction } from './transaction';\nimport { getSTXAddressFromPubKeys, isValidAmount } from './utils';\nimport { SbtcWithdrawParams } from './iface';\nimport { CONTRACT_NAME_SBTC_WITHDRAWAL, FUNCTION_NAME_INITIATE_WITHDRAWAL } from './constants';\nimport { ContractCallPayload } from '@stacks/transactions/dist/payload';\nimport { AbstractContractBuilder } from './abstractContractBuilder';\nimport { decodeBtcAddress, isValidBtcAddress } from './btcAddressUtils';\n\nconst SBTC_TOKEN_CONTRACT_NAME = 'sbtc-token';\nconst SBTC_TOKEN_ASSET_NAME = 'sbtc-token';\n\nexport class SbtcWithdrawBuilder extends AbstractContractBuilder {\n  private _withdrawParams: SbtcWithdrawParams | undefined;\n  private _isDeserialized = false;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * Check whether a deserialized contract-call payload matches the sBTC withdrawal contract.\n   */\n  public static isValidContractCall(coinConfig: Readonly<CoinConfig>, payload: ContractCallPayload): boolean {\n    return (\n      (coinConfig.network as BitgoStacksNetwork).sbtcWithdrawalContractAddress ===\n        addressToString(payload.contractAddress) &&\n      CONTRACT_NAME_SBTC_WITHDRAWAL === payload.contractName.content &&\n      FUNCTION_NAME_INITIATE_WITHDRAWAL === payload.functionName.content\n    );\n  }\n\n  /**\n   * Set withdrawal parameters.\n   *\n   * @param {SbtcWithdrawParams} params - amount (satoshis), btcAddress, maxFee\n   * @returns {this}\n   */\n  withdraw(params: SbtcWithdrawParams): this {\n    if (!params.amount || !isValidAmount(params.amount) || params.amount === '0') {\n      throw new BuildTransactionError('Invalid or missing amount, got: ' + params.amount);\n    }\n    if (!params.btcAddress || !isValidBtcAddress(params.btcAddress)) {\n      throw new BuildTransactionError('Invalid or missing btcAddress, got: ' + params.btcAddress);\n    }\n    if (!params.maxFee || !isValidAmount(params.maxFee) || params.maxFee === '0') {\n      throw new BuildTransactionError('Invalid or missing maxFee, got: ' + params.maxFee);\n    }\n    this._withdrawParams = params;\n    return this;\n  }\n\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    const payload = tx.stxTransaction.payload as ContractCallPayload;\n    const args = payload.functionArgs;\n\n    if (args.length !== 3) {\n      throw new BuildTransactionError('Invalid number of function args for sBTC withdrawal');\n    }\n\n    // args[0] = uint (amount)\n    if (args[0].type !== ClarityType.UInt) {\n      throw new BuildTransactionError('Expected uint for amount argument');\n    }\n    const amount = args[0].value.toString();\n\n    // args[1] = tuple { version: (buff 1), hashbytes: (buff 32) }\n    if (args[1].type !== ClarityType.Tuple) {\n      throw new BuildTransactionError('Expected tuple for recipient argument');\n    }\n    const versionBuf = args[1].data['version'];\n    const hashbytesBuf = args[1].data['hashbytes'];\n    if (versionBuf?.type !== ClarityType.Buffer || hashbytesBuf?.type !== ClarityType.Buffer) {\n      throw new BuildTransactionError('Expected buffer fields in recipient tuple');\n    }\n\n    // args[2] = uint (max-fee)\n    if (args[2].type !== ClarityType.UInt) {\n      throw new BuildTransactionError('Expected uint for max-fee argument');\n    }\n    const maxFee = args[2].value.toString();\n\n    this._withdrawParams = {\n      amount,\n      btcAddress: '', // not needed for rebuild; function args are preserved from the original tx\n      maxFee,\n    };\n    this._isDeserialized = true;\n  }\n\n  /**\n   * Get the withdrawal params decoded from the deserialized/built transaction, including the\n   * raw sBTC recipient version and hash bytes (as opposed to a btcAddress string, which cannot\n   * be recovered from the on-chain args alone).\n   */\n  getWithdrawParams():\n    | { amount: string; maxFee: string; recipientVersion: number; recipientHashBytes: Buffer }\n    | undefined {\n    if (!this._withdrawParams) {\n      return undefined;\n    }\n    const payload = this.transaction.stxTransaction.payload as ContractCallPayload;\n    const recipientTuple = payload.functionArgs[1];\n    if (recipientTuple?.type !== ClarityType.Tuple) {\n      return undefined;\n    }\n    const versionBuf = recipientTuple.data['version'];\n    const hashbytesBuf = recipientTuple.data['hashbytes'];\n    if (versionBuf?.type !== ClarityType.Buffer || hashbytesBuf?.type !== ClarityType.Buffer) {\n      return undefined;\n    }\n    return {\n      amount: this._withdrawParams.amount,\n      maxFee: this._withdrawParams.maxFee,\n      recipientVersion: versionBuf.buffer[0],\n      recipientHashBytes: Buffer.from(hashbytesBuf.buffer),\n    };\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    if (!this._withdrawParams) {\n      throw new BuildTransactionError('Withdrawal params are not set. Use withdraw() to set them.');\n    }\n\n    const network = this._coinConfig.network as BitgoStacksNetwork;\n    this._contractAddress = network.sbtcWithdrawalContractAddress;\n    this._contractName = CONTRACT_NAME_SBTC_WITHDRAWAL;\n    this._functionName = FUNCTION_NAME_INITIATE_WITHDRAWAL;\n\n    // For deserialized transactions, function args are already preserved from the original tx.\n    // For fresh builds, construct them from the withdraw params.\n    if (!this._isDeserialized) {\n      this._functionArgs = this.withdrawParamsToFunctionArgs(this._withdrawParams);\n    }\n\n    this._postConditionMode = PostConditionMode.Deny;\n    this._postConditions = this.withdrawParamsToPostCondition(this._withdrawParams);\n    return await super.buildImplementation();\n  }\n\n  private withdrawParamsToFunctionArgs(params: SbtcWithdrawParams) {\n    const decoded = decodeBtcAddress(params.btcAddress);\n    return [\n      uintCV(params.amount),\n      tupleCV({\n        version: bufferCV(Buffer.from([decoded.version])),\n        hashbytes: bufferCV(decoded.hashBytes),\n      }),\n      uintCV(params.maxFee),\n    ];\n  }\n\n  private withdrawParamsToPostCondition(params: SbtcWithdrawParams): PostCondition[] {\n    const amount = new BigNum(params.amount).add(new BigNum(params.maxFee));\n    const network = this._coinConfig.network as BitgoStacksNetwork;\n    const sbtcContractAddress = network.sbtcWithdrawalContractAddress;\n\n    return [\n      makeStandardFungiblePostCondition(\n        getSTXAddressFromPubKeys(\n          this._fromPubKeys,\n          this._coinConfig.network.type === NetworkType.MAINNET\n            ? AddressVersion.MainnetMultiSig\n            : AddressVersion.TestnetMultiSig,\n          this._fromPubKeys.length > 1 ? AddressHashMode.SerializeP2SH : AddressHashMode.SerializeP2PKH,\n          this._numberSignatures\n        ).address,\n        FungibleConditionCode.Equal,\n        amount.toString(),\n        createAssetInfo(sbtcContractAddress, SBTC_TOKEN_CONTRACT_NAME, SBTC_TOKEN_ASSET_NAME)\n      ),\n    ];\n  }\n}\n"]}

package/dist/src/lib/sendmanyBuilder.js

@@ -16,30 +16,30 @@ class SendmanyBuilder extends abstractContractBuilder_1.AbstractContractBuilder
         super(_coinConfig);
         this._sendParams = [];
         this.sendParamsToFunctionArgs = (sendParams) => [
-            transactions_1.listCV(sendParams.map((recipient) => transactions_1.tupleCV({
-                to: transactions_1.standardPrincipalCV(recipient.address),
-                ustx: transactions_1.uintCV(recipient.amount),
-                memo: transactions_1.bufferCVFromString(recipient.memo || ''),
+            (0, transactions_1.listCV)(sendParams.map((recipient) => (0, transactions_1.tupleCV)({
+                to: (0, transactions_1.standardPrincipalCV)(recipient.address),
+                ustx: (0, transactions_1.uintCV)(recipient.amount),
+                memo: (0, transactions_1.bufferCVFromString)(recipient.memo || ''),
             }))),
         ];
     }
     static isValidContractCall(coinConfig, payload) {
         return (coinConfig.network.sendmanymemoContractAddress ===
-            transactions_1.addressToString(payload.contractAddress) &&
+            (0, transactions_1.addressToString)(payload.contractAddress) &&
             constants_1.CONTRACT_NAME_SENDMANY === payload.contractName.content &&
             constants_1.FUNCTION_NAME_SENDMANY === payload.functionName.content);
     }
     sendParamsToPostcondition(sendParams) {
         const sum = sendParams.reduce((current, next) => current.add(new bn_js_1.default(next.amount)), new bn_js_1.default(0));
         return [
-            transactions_1.makeStandardSTXPostCondition(utils_1.getSTXAddressFromPubKeys(this._fromPubKeys, this._coinConfig.network.type === statics_1.NetworkType.MAINNET
+            (0, transactions_1.makeStandardSTXPostCondition)((0, utils_1.getSTXAddressFromPubKeys)(this._fromPubKeys, this._coinConfig.network.type === statics_1.NetworkType.MAINNET
                 ? transactions_1.AddressVersion.MainnetMultiSig
-                : transactions_1.AddressVersion.TestnetMultiSig, this._fromPubKeys.length > 1 ? transactions_1.AddressHashMode.SerializeP2SH : transactions_1.AddressHashMode.SerializeP2PKH, this._numberSignatures).address, transactions_1.FungibleConditionCode.Equal, sum),
+                : transactions_1.AddressVersion.TestnetMultiSig, this._fromPubKeys.length > 1 ? transactions_1.AddressHashMode.SerializeP2SH : transactions_1.AddressHashMode.SerializeP2PKH, this._numberSignatures).address, transactions_1.FungibleConditionCode.Equal, sum.toString()),
         ];
     }
     initBuilder(tx) {
         super.initBuilder(tx);
-        this._sendParams = utils_1.functionArgsToSendParams(tx.stxTransaction.payload.functionArgs);
+        this._sendParams = (0, utils_1.functionArgsToSendParams)(tx.stxTransaction.payload.functionArgs);
     }
     /**
      *  Set a transfer
@@ -48,13 +48,13 @@ class SendmanyBuilder extends abstractContractBuilder_1.AbstractContractBuilder
      * @returns {TransactionBuilder} This transaction builder
      */
     send({ address, amount, memo }) {
-        if (!address || !utils_1.isValidAddress(address)) {
+        if (!address || !(0, utils_1.isValidAddress)(address)) {
             throw new sdk_core_1.BuildTransactionError('Invalid or missing address, got: ' + address);
         }
-        if (!amount || !utils_1.isValidAmount(amount)) {
+        if (!amount || !(0, utils_1.isValidAmount)(amount)) {
             throw new sdk_core_1.BuildTransactionError('Invalid or missing amount, got: ' + amount);
         }
-        if (!!memo && !utils_1.isValidMemo(memo)) {
+        if (!!memo && !(0, utils_1.isValidMemo)(memo)) {
             throw new sdk_core_1.BuildTransactionError('Invalid memo, got: ' + memo);
         }
         this._sendParams.push({ address, amount, memo });
@@ -72,4 +72,4 @@ class SendmanyBuilder extends abstractContractBuilder_1.AbstractContractBuilder
     }
 }
 exports.SendmanyBuilder = SendmanyBuilder;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sendmanyBuilder.js","sourceRoot":"","sources":["../../../src/lib/sendmanyBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig, NetworkType, StacksNetwork as BitgoStacksNetwork } from '@bitgo-beta/statics';\nimport BigNum from 'bn.js';\nimport {\n  AddressHashMode,\n  addressToString,\n  AddressVersion,\n  bufferCVFromString,\n  ClarityValue,\n  FungibleConditionCode,\n  listCV,\n  makeStandardSTXPostCondition,\n  PostCondition,\n  PostConditionMode,\n  standardPrincipalCV,\n  tupleCV,\n  uintCV,\n} from '@stacks/transactions';\nimport { BuildTransactionError } from '@bitgo-beta/sdk-core';\nimport { Transaction } from './transaction';\nimport {\n  functionArgsToSendParams,\n  getSTXAddressFromPubKeys,\n  isValidAddress,\n  isValidAmount,\n  isValidMemo,\n} from './utils';\nimport { SendParams } from './iface';\nimport { CONTRACT_NAME_SENDMANY, FUNCTION_NAME_SENDMANY } from './constants';\nimport { ContractCallPayload } from '@stacks/transactions/dist/payload';\nimport { AbstractContractBuilder } from './abstractContractBuilder';\n\nexport class SendmanyBuilder extends AbstractContractBuilder {\n  private _sendParams: SendParams[] = [];\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  public static isValidContractCall(coinConfig: Readonly<CoinConfig>, payload: ContractCallPayload): boolean {\n    return (\n      (coinConfig.network as BitgoStacksNetwork).sendmanymemoContractAddress ===\n        addressToString(payload.contractAddress) &&\n      CONTRACT_NAME_SENDMANY === payload.contractName.content &&\n      FUNCTION_NAME_SENDMANY === payload.functionName.content\n    );\n  }\n\n  private sendParamsToFunctionArgs = (sendParams: SendParams[]): ClarityValue[] => [\n    listCV(\n      sendParams.map((recipient) =>\n        tupleCV({\n          to: standardPrincipalCV(recipient.address),\n          ustx: uintCV(recipient.amount),\n          memo: bufferCVFromString(recipient.memo || ''),\n        })\n      )\n    ),\n  ];\n\n  private sendParamsToPostcondition(sendParams: SendParams[]): PostCondition[] {\n    const sum: BigNum = sendParams.reduce((current, next) => current.add(new BigNum(next.amount)), new BigNum(0));\n    return [\n      makeStandardSTXPostCondition(\n        getSTXAddressFromPubKeys(\n          this._fromPubKeys,\n          this._coinConfig.network.type === NetworkType.MAINNET\n            ? AddressVersion.MainnetMultiSig\n            : AddressVersion.TestnetMultiSig,\n          this._fromPubKeys.length > 1 ? AddressHashMode.SerializeP2SH : AddressHashMode.SerializeP2PKH,\n          this._numberSignatures\n        ).address,\n        FungibleConditionCode.Equal,\n        sum\n      ),\n    ];\n  }\n\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    this._sendParams = functionArgsToSendParams((tx.stxTransaction.payload as ContractCallPayload).functionArgs);\n  }\n\n  /**\n   *  Set a transfer\n   *\n   * @param {SendParams} sendParams - the sender address\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  send({ address, amount, memo }: SendParams): this {\n    if (!address || !isValidAddress(address)) {\n      throw new BuildTransactionError('Invalid or missing address, got: ' + address);\n    }\n    if (!amount || !isValidAmount(amount)) {\n      throw new BuildTransactionError('Invalid or missing amount, got: ' + amount);\n    }\n    if (!!memo && !isValidMemo(memo)) {\n      throw new BuildTransactionError('Invalid memo, got: ' + memo);\n    }\n\n    this._sendParams.push({ address, amount, memo });\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    this._contractAddress = (this._coinConfig.network as BitgoStacksNetwork).sendmanymemoContractAddress;\n    this._contractName = CONTRACT_NAME_SENDMANY;\n    this._functionName = FUNCTION_NAME_SENDMANY;\n    this._functionArgs = this.sendParamsToFunctionArgs(this._sendParams);\n    this._postConditionMode = PostConditionMode.Deny;\n    this._postConditions = this.sendParamsToPostcondition(this._sendParams);\n    return await super.buildImplementation();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sendmanyBuilder.js","sourceRoot":"","sources":["../../../src/lib/sendmanyBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig, NetworkType, StacksNetwork as BitgoStacksNetwork } from '@bitgo-beta/statics';\nimport BigNum from 'bn.js';\nimport {\n  AddressHashMode,\n  addressToString,\n  AddressVersion,\n  bufferCVFromString,\n  ClarityValue,\n  FungibleConditionCode,\n  listCV,\n  makeStandardSTXPostCondition,\n  PostCondition,\n  PostConditionMode,\n  standardPrincipalCV,\n  tupleCV,\n  uintCV,\n} from '@stacks/transactions';\nimport { BuildTransactionError } from '@bitgo-beta/sdk-core';\nimport { Transaction } from './transaction';\nimport {\n  functionArgsToSendParams,\n  getSTXAddressFromPubKeys,\n  isValidAddress,\n  isValidAmount,\n  isValidMemo,\n} from './utils';\nimport { SendParams } from './iface';\nimport { CONTRACT_NAME_SENDMANY, FUNCTION_NAME_SENDMANY } from './constants';\nimport { ContractCallPayload } from '@stacks/transactions/dist/payload';\nimport { AbstractContractBuilder } from './abstractContractBuilder';\n\nexport class SendmanyBuilder extends AbstractContractBuilder {\n  private _sendParams: SendParams[] = [];\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  public static isValidContractCall(coinConfig: Readonly<CoinConfig>, payload: ContractCallPayload): boolean {\n    return (\n      (coinConfig.network as BitgoStacksNetwork).sendmanymemoContractAddress ===\n        addressToString(payload.contractAddress) &&\n      CONTRACT_NAME_SENDMANY === payload.contractName.content &&\n      FUNCTION_NAME_SENDMANY === payload.functionName.content\n    );\n  }\n\n  private sendParamsToFunctionArgs = (sendParams: SendParams[]): ClarityValue[] => [\n    listCV(\n      sendParams.map((recipient) =>\n        tupleCV({\n          to: standardPrincipalCV(recipient.address),\n          ustx: uintCV(recipient.amount),\n          memo: bufferCVFromString(recipient.memo || ''),\n        })\n      )\n    ),\n  ];\n\n  private sendParamsToPostcondition(sendParams: SendParams[]): PostCondition[] {\n    const sum: BigNum = sendParams.reduce((current, next) => current.add(new BigNum(next.amount)), new BigNum(0));\n    return [\n      makeStandardSTXPostCondition(\n        getSTXAddressFromPubKeys(\n          this._fromPubKeys,\n          this._coinConfig.network.type === NetworkType.MAINNET\n            ? AddressVersion.MainnetMultiSig\n            : AddressVersion.TestnetMultiSig,\n          this._fromPubKeys.length > 1 ? AddressHashMode.SerializeP2SH : AddressHashMode.SerializeP2PKH,\n          this._numberSignatures\n        ).address,\n        FungibleConditionCode.Equal,\n        sum.toString()\n      ),\n    ];\n  }\n\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    this._sendParams = functionArgsToSendParams((tx.stxTransaction.payload as ContractCallPayload).functionArgs);\n  }\n\n  /**\n   *  Set a transfer\n   *\n   * @param {SendParams} sendParams - the sender address\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  send({ address, amount, memo }: SendParams): this {\n    if (!address || !isValidAddress(address)) {\n      throw new BuildTransactionError('Invalid or missing address, got: ' + address);\n    }\n    if (!amount || !isValidAmount(amount)) {\n      throw new BuildTransactionError('Invalid or missing amount, got: ' + amount);\n    }\n    if (!!memo && !isValidMemo(memo)) {\n      throw new BuildTransactionError('Invalid memo, got: ' + memo);\n    }\n\n    this._sendParams.push({ address, amount, memo });\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    this._contractAddress = (this._coinConfig.network as BitgoStacksNetwork).sendmanymemoContractAddress;\n    this._contractName = CONTRACT_NAME_SENDMANY;\n    this._functionName = FUNCTION_NAME_SENDMANY;\n    this._functionArgs = this.sendParamsToFunctionArgs(this._sendParams);\n    this._postConditionMode = PostConditionMode.Deny;\n    this._postConditions = this.sendParamsToPostcondition(this._sendParams);\n    return await super.buildImplementation();\n  }\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAYL,iBAAiB,EAElB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAiB,MAAM,qBAAqB,CAAC;AAC5E,OAAO,EACL,OAAO,EACP,eAAe,EAKf,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAmD,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjG,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,qBAAa,WAAY,SAAQ,eAAe;IAC9C,OAAO,CAAC,eAAe,CAAoB;IAC3C,SAAS,CAAC,KAAK,EAAE,eAAe,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAS;gBAEb,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAIxB,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBnE,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ5D,kBAAkB,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBxG,IAAI,SAAS,IAAI,MAAM,EAAE,CAexB;IAED,kBAAkB;IAClB,MAAM,IAAI,MAAM;IAchB,OAAO,CAAC,cAAc;IA+BtB;;;;;OAKG;IACH,eAAe,IAAI,MAAM;IAIzB,iBAAiB,IAAI,MAAM;IAO3B,IAAI,cAAc,IAAI,iBAAiB,CAEtC;IAED,IAAI,cAAc,CAAC,CAAC,EAAE,iBAAiB,EAEtC;IAED,OAAO,CAAC,QAAQ;IAQhB;;;;OAIG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAUhD;;;;OAIG;IACH,kBAAkB,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI;IAI1D;;;OAGG;IACH,oBAAoB,IAAI,IAAI;CA8C7B"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAeL,iBAAiB,EAElB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAiB,MAAM,qBAAqB,CAAC;AAE5E,OAAO,EACL,OAAO,EACP,eAAe,EAKf,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,aAAa,EAAmD,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjG,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,qBAAa,WAAY,SAAQ,eAAe;IAC9C,OAAO,CAAC,eAAe,CAAoB;IAC3C,SAAS,CAAC,KAAK,EAAE,eAAe,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAS;gBAEb,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAIxB,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBnE,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ5D,kBAAkB,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBxG,IAAI,SAAS,IAAI,MAAM,EAAE,CAexB;IAED,kBAAkB;IAClB,MAAM,IAAI,MAAM;IAchB,OAAO,CAAC,cAAc;IA+BtB;;;;;OAKG;IACH,eAAe,IAAI,MAAM;IAIzB,iBAAiB,IAAI,MAAM;IAO3B,IAAI,cAAc,IAAI,iBAAiB,CAEtC;IAED,IAAI,cAAc,CAAC,CAAC,EAAE,iBAAiB,EAEtC;IAED,OAAO,CAAC,QAAQ;IAQhB;;;;OAIG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAUhD;;;;OAIG;IACH,kBAAkB,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI;IAI1D;;;OAGG;IACH,oBAAoB,IAAI,IAAI;CA6D7B"}