@bitgo/sdk-coin-stx 3.8.15 → 3.9.0

package/dist/src/lib/sendmanyBuilder.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendmanyBuilder = void 0;
+const statics_1 = require("@bitgo/statics");
+const bn_js_1 = __importDefault(require("bn.js"));
+const transactions_1 = require("@stacks/transactions");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+const abstractContractBuilder_1 = require("./abstractContractBuilder");
+class SendmanyBuilder extends abstractContractBuilder_1.AbstractContractBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._sendParams = [];
+        this.sendParamsToFunctionArgs = (sendParams) => [
+            (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 ===
+            (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 [
+            (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),
+        ];
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        this._sendParams = (0, utils_1.functionArgsToSendParams)(tx.stxTransaction.payload.functionArgs);
+    }
+    /**
+     *  Set a transfer
+     *
+     * @param {SendParams} sendParams - the sender address
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    send({ address, amount, memo }) {
+        if (!address || !(0, utils_1.isValidAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing address, got: ' + address);
+        }
+        if (!amount || !(0, utils_1.isValidAmount)(amount)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing amount, got: ' + amount);
+        }
+        if (!!memo && !(0, utils_1.isValidMemo)(memo)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid memo, got: ' + memo);
+        }
+        this._sendParams.push({ address, amount, memo });
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        this._contractAddress = this._coinConfig.network.sendmanymemoContractAddress;
+        this._contractName = constants_1.CONTRACT_NAME_SENDMANY;
+        this._functionName = constants_1.FUNCTION_NAME_SENDMANY;
+        this._functionArgs = this.sendParamsToFunctionArgs(this._sendParams);
+        this._postConditionMode = transactions_1.PostConditionMode.Deny;
+        this._postConditions = this.sendParamsToPostcondition(this._sendParams);
+        return await super.buildImplementation();
+    }
+}
+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/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/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"]}

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

@@ -0,0 +1,49 @@
+import { StacksTransaction } from '@stacks/transactions';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseKey, BaseTransaction, TransactionType } from '@bitgo/sdk-core';
+import { SignatureData, TxData } from './iface';
+import { KeyPair } from './keyPair';
+export declare class Transaction extends BaseTransaction {
+    private _stxTransaction;
+    protected _type: TransactionType;
+    private _sigHash;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    canSign(key: BaseKey): boolean;
+    sign(keyPair: KeyPair[] | KeyPair, sigHash?: string): Promise<void>;
+    appendOrigin(pubKeyString: string[] | string): Promise<void>;
+    signWithSignatures(signature: SignatureData[] | SignatureData, isMultiSig: boolean): Promise<void>;
+    get signature(): string[];
+    /** @inheritdoc */
+    toJson(): TxData;
+    private getPayloadData;
+    /**
+     * Return the length of a transaction.  This is needed to calculate
+     * the transaction fee.
+     *
+     * @returns {number} size in bytes of the serialized transaction
+     */
+    transactionSize(): number;
+    toBroadcastFormat(): string;
+    get stxTransaction(): StacksTransaction;
+    set stxTransaction(t: StacksTransaction);
+    private getNonce;
+    /**
+     * Sets this transaction payload
+     *
+     * @param rawTransaction
+     */
+    fromRawTransaction(rawTransaction: string): void;
+    /**
+     * Set the transaction type
+     *
+     * @param {TransactionType} transactionType The transaction type to be set
+     */
+    setTransactionType(transactionType: TransactionType): void;
+    /**
+     * Load the input and output data on this transaction using the transaction json
+     * if there are outputs.
+     */
+    loadInputsAndOutputs(): void;
+}
+//# sourceMappingURL=transaction.d.ts.map

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

@@ -0,0 +1 @@
+{"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,gBAAgB,CAAC;AAEvE,OAAO,EACL,OAAO,EACP,eAAe,EAKf,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAIzB,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"}

package/dist/src/lib/transaction.js

@@ -0,0 +1,241 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const transactions_1 = require("@stacks/transactions");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const bn_js_1 = __importDefault(require("bn.js"));
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+class Transaction extends sdk_core_1.BaseTransaction {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /** @inheritdoc */
+    canSign(key) {
+        return true;
+    }
+    async sign(keyPair, sigHash) {
+        const keyPairs = keyPair instanceof Array ? keyPair : [keyPair];
+        const signer = new transactions_1.TransactionSigner(this._stxTransaction);
+        signer.checkOversign = false;
+        signer.sigHash = sigHash ?? this._sigHash ?? this._stxTransaction.verifyBegin();
+        for (const kp of keyPairs) {
+            const keys = kp.getKeys(kp.getCompressed());
+            if (!keys.prv) {
+                throw new sdk_core_1.SigningError('Missing private key');
+            }
+            const privKey = (0, transactions_1.createStacksPrivateKey)(keys.prv);
+            signer.signOrigin(privKey);
+            this._sigHash = signer.sigHash;
+        }
+    }
+    async appendOrigin(pubKeyString) {
+        const pubKeyStrings = pubKeyString instanceof Array ? pubKeyString : [pubKeyString];
+        const signer = new transactions_1.TransactionSigner(this._stxTransaction);
+        pubKeyStrings.forEach((pubKey) => {
+            signer.appendOrigin((0, transactions_1.createStacksPublicKey)(pubKey));
+        });
+    }
+    async signWithSignatures(signature, isMultiSig) {
+        if (!signature) {
+            throw new sdk_core_1.SigningError('Missing signatures');
+        }
+        const signatures = signature instanceof Array ? signature : [signature];
+        if (!isMultiSig) {
+            this._stxTransaction = this._stxTransaction.createTxWithSignature(signatures[0].data);
+        }
+        else {
+            const authFields = signatures.map((sig) => (0, transactions_1.createTransactionAuthField)(transactions_1.PubKeyEncoding.Compressed, sig));
+            this._stxTransaction.auth.spendingCondition.fields = this._stxTransaction.auth.spendingCondition.fields.concat(authFields);
+        }
+        if (signatures.length > 0) {
+            this._sigHash = signatures[signatures.length - 1].sigHash;
+        }
+    }
+    get signature() {
+        if (this._stxTransaction && this._stxTransaction.auth.spendingCondition) {
+            if ((0, transactions_1.isSingleSig)(this._stxTransaction.auth.spendingCondition)) {
+                return [this._stxTransaction.auth.spendingCondition.signature.data];
+            }
+            else {
+                const signatures = [];
+                this._stxTransaction.auth.spendingCondition.fields.forEach((field) => {
+                    if (field.contents.type === transactions_1.StacksMessageType.MessageSignature) {
+                        signatures.push(field.contents.data);
+                    }
+                });
+                return signatures;
+            }
+        }
+        return [];
+    }
+    /** @inheritdoc */
+    toJson() {
+        if (!this._stxTransaction) {
+            throw new sdk_core_1.ParseTransactionError('Empty transaction');
+        }
+        const result = {
+            id: this._stxTransaction.txid(),
+            fee: this._stxTransaction.auth.getFee().toString(10),
+            from: (0, utils_1.getTxSenderAddress)(this._stxTransaction),
+            nonce: this.getNonce(),
+            payload: this.getPayloadData(),
+        };
+        return result;
+    }
+    getPayloadData() {
+        if (this._stxTransaction.payload.payloadType === transactions_1.PayloadType.TokenTransfer) {
+            const payload = this._stxTransaction.payload;
+            const txPayload = {
+                payloadType: transactions_1.PayloadType.TokenTransfer,
+                // result.payload.memo will be padded with \u0000 up to
+                // MEMO_MAX_LENGTH_BYTES as defined in @stacks/transactions
+                memo: (0, utils_1.unpadMemo)(payload.memo.content),
+                to: (0, transactions_1.addressToString)({
+                    type: transactions_1.StacksMessageType.Address,
+                    version: payload.recipient.address.version,
+                    hash160: payload.recipient.address.hash160.toString(),
+                }),
+                amount: payload.amount.toString(),
+            };
+            return txPayload;
+        }
+        else if (this._stxTransaction.payload.payloadType === transactions_1.PayloadType.ContractCall) {
+            const payload = this._stxTransaction.payload;
+            const contractPayload = {
+                payloadType: transactions_1.PayloadType.ContractCall,
+                contractAddress: (0, transactions_1.addressToString)(payload.contractAddress),
+                contractName: payload.contractName.content,
+                functionName: payload.functionName.content,
+                functionArgs: payload.functionArgs.map(utils_1.stringifyCv),
+            };
+            return contractPayload;
+        }
+        else {
+            throw new sdk_core_1.NotSupported('payload type not supported');
+        }
+    }
+    /**
+     * Return the length of a transaction.  This is needed to calculate
+     * the transaction fee.
+     *
+     * @returns {number} size in bytes of the serialized transaction
+     */
+    transactionSize() {
+        return this._stxTransaction.serialize().length;
+    }
+    toBroadcastFormat() {
+        if (!this._stxTransaction) {
+            throw new sdk_core_1.ParseTransactionError('Empty transaction');
+        }
+        return this._stxTransaction.serialize().toString('hex');
+    }
+    get stxTransaction() {
+        return this._stxTransaction;
+    }
+    set stxTransaction(t) {
+        this._stxTransaction = t;
+    }
+    getNonce() {
+        if (this._stxTransaction.auth.spendingCondition) {
+            return Number(this._stxTransaction.auth.spendingCondition.nonce);
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError('spending condition is null');
+        }
+    }
+    /**
+     * Sets this transaction payload
+     *
+     * @param rawTransaction
+     */
+    fromRawTransaction(rawTransaction) {
+        const raw = (0, utils_1.removeHexPrefix)(rawTransaction);
+        try {
+            this._stxTransaction = (0, transactions_1.deserializeTransaction)(transactions_1.BufferReader.fromBuffer(Buffer.from(raw, 'hex')));
+        }
+        catch (e) {
+            throw new sdk_core_1.ParseTransactionError('Error parsing the raw transaction');
+        }
+        this.loadInputsAndOutputs();
+    }
+    /**
+     * Set the transaction type
+     *
+     * @param {TransactionType} transactionType The transaction type to be set
+     */
+    setTransactionType(transactionType) {
+        this._type = transactionType;
+    }
+    /**
+     * Load the input and output data on this transaction using the transaction json
+     * if there are outputs.
+     */
+    loadInputsAndOutputs() {
+        const txJson = this.toJson();
+        if (txJson.payload.payloadType === transactions_1.PayloadType.TokenTransfer) {
+            if (txJson.payload.to && txJson.payload.amount) {
+                this._outputs = [
+                    {
+                        address: txJson.payload.to,
+                        value: txJson.payload.amount,
+                        coin: this._coinConfig.name,
+                    },
+                ];
+                this._inputs = [
+                    {
+                        address: txJson.from,
+                        value: txJson.payload.amount,
+                        coin: this._coinConfig.name,
+                    },
+                ];
+            }
+        }
+        else if (txJson.payload.payloadType === transactions_1.PayloadType.ContractCall) {
+            if (txJson.payload.contractAddress === this._coinConfig.network.sendmanymemoContractAddress) {
+                const sendParams = (0, utils_1.functionArgsToSendParams)(this.stxTransaction.payload.functionArgs);
+                const coin = this._coinConfig.name;
+                const sum = sendParams.reduce((current, next) => current.add(new bn_js_1.default(next.amount)), new bn_js_1.default(0));
+                this._outputs = sendParams.map((sendParam) => ({ address: sendParam.address, value: sendParam.amount, coin }));
+                this._inputs = [{ address: txJson.from, value: sum.toString(), coin }];
+            }
+            else if (txJson.payload.functionName === constants_1.FUNCTION_NAME_TRANSFER && txJson.payload.functionArgs.length >= 3) {
+                this._outputs = [
+                    {
+                        address: (0, transactions_1.cvToString)(txJson.payload.functionArgs[2]),
+                        value: (0, transactions_1.cvToValue)(txJson.payload.functionArgs[0]).toString(),
+                        coin: this._coinConfig.name,
+                    },
+                ];
+                this._inputs = [
+                    {
+                        address: (0, transactions_1.cvToString)(txJson.payload.functionArgs[1]),
+                        value: (0, transactions_1.cvToValue)(txJson.payload.functionArgs[0]).toString(),
+                        coin: this._coinConfig.name,
+                    },
+                ];
+            }
+            else {
+                this._outputs = [
+                    {
+                        address: txJson.payload.contractAddress,
+                        value: '0',
+                        coin: this._coinConfig.name,
+                    },
+                ];
+                this._inputs = [
+                    {
+                        address: txJson.from,
+                        value: '0',
+                        coin: this._coinConfig.name,
+                    },
+                ];
+            }
+        }
+    }
+}
+exports.Transaction = Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  addressToString,\n  BufferReader,\n  ContractCallPayload,\n  createStacksPrivateKey,\n  createStacksPublicKey,\n  createTransactionAuthField,\n  cvToString,\n  cvToValue,\n  deserializeTransaction,\n  isSingleSig,\n  MultiSigSpendingCondition,\n  PayloadType,\n  PubKeyEncoding,\n  StacksMessageType,\n  StacksTransaction,\n  TransactionSigner,\n} from '@stacks/transactions';\n\nimport { BaseCoin as CoinConfig, StacksNetwork } from '@bitgo/statics';\n\nimport {\n  BaseKey,\n  BaseTransaction,\n  InvalidTransactionError,\n  NotSupported,\n  ParseTransactionError,\n  SigningError,\n  TransactionType,\n} from '@bitgo/sdk-core';\n\nimport BigNum from 'bn.js';\n\nimport { SignatureData, StacksContractPayload, StacksTransactionPayload, TxData } from './iface';\nimport { functionArgsToSendParams, getTxSenderAddress, removeHexPrefix, stringifyCv, unpadMemo } from './utils';\nimport { KeyPair } from './keyPair';\nimport { FUNCTION_NAME_TRANSFER } from './constants';\n\nexport class Transaction extends BaseTransaction {\n  private _stxTransaction: StacksTransaction;\n  protected _type: TransactionType;\n  private _sigHash: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /** @inheritdoc */\n  canSign(key: BaseKey): boolean {\n    return true;\n  }\n\n  async sign(keyPair: KeyPair[] | KeyPair, sigHash?: string): Promise<void> {\n    const keyPairs = keyPair instanceof Array ? keyPair : [keyPair];\n    const signer = new TransactionSigner(this._stxTransaction);\n    signer.checkOversign = false;\n    signer.sigHash = sigHash ?? this._sigHash ?? this._stxTransaction.verifyBegin();\n    for (const kp of keyPairs) {\n      const keys = kp.getKeys(kp.getCompressed());\n      if (!keys.prv) {\n        throw new SigningError('Missing private key');\n      }\n      const privKey = createStacksPrivateKey(keys.prv);\n      signer.signOrigin(privKey);\n      this._sigHash = signer.sigHash;\n    }\n  }\n\n  async appendOrigin(pubKeyString: string[] | string): Promise<void> {\n    const pubKeyStrings = pubKeyString instanceof Array ? pubKeyString : [pubKeyString];\n    const signer: TransactionSigner = new TransactionSigner(this._stxTransaction);\n    pubKeyStrings.forEach((pubKey) => {\n      signer.appendOrigin(createStacksPublicKey(pubKey));\n    });\n  }\n\n  async signWithSignatures(signature: SignatureData[] | SignatureData, isMultiSig: boolean): Promise<void> {\n    if (!signature) {\n      throw new SigningError('Missing signatures');\n    }\n    const signatures = signature instanceof Array ? signature : [signature];\n\n    if (!isMultiSig) {\n      this._stxTransaction = this._stxTransaction.createTxWithSignature(signatures[0].data);\n    } else {\n      const authFields = signatures.map((sig) => createTransactionAuthField(PubKeyEncoding.Compressed, sig));\n      (this._stxTransaction.auth.spendingCondition as MultiSigSpendingCondition).fields = (\n        this._stxTransaction.auth.spendingCondition as MultiSigSpendingCondition\n      ).fields.concat(authFields);\n    }\n    if (signatures.length > 0) {\n      this._sigHash = signatures[signatures.length - 1].sigHash;\n    }\n  }\n\n  get signature(): string[] {\n    if (this._stxTransaction && this._stxTransaction.auth.spendingCondition) {\n      if (isSingleSig(this._stxTransaction.auth.spendingCondition)) {\n        return [this._stxTransaction.auth.spendingCondition.signature.data];\n      } else {\n        const signatures: string[] = [];\n        this._stxTransaction.auth.spendingCondition.fields.forEach((field) => {\n          if (field.contents.type === StacksMessageType.MessageSignature) {\n            signatures.push(field.contents.data);\n          }\n        });\n        return signatures;\n      }\n    }\n    return [];\n  }\n\n  /** @inheritdoc */\n  toJson(): TxData {\n    if (!this._stxTransaction) {\n      throw new ParseTransactionError('Empty transaction');\n    }\n    const result: TxData = {\n      id: this._stxTransaction.txid(),\n      fee: this._stxTransaction.auth.getFee().toString(10),\n      from: getTxSenderAddress(this._stxTransaction),\n      nonce: this.getNonce(),\n      payload: this.getPayloadData(),\n    };\n    return result;\n  }\n\n  private getPayloadData(): StacksTransactionPayload | StacksContractPayload {\n    if (this._stxTransaction.payload.payloadType === PayloadType.TokenTransfer) {\n      const payload = this._stxTransaction.payload;\n      const txPayload: StacksTransactionPayload = {\n        payloadType: PayloadType.TokenTransfer,\n        // result.payload.memo will be padded with \\u0000 up to\n        // MEMO_MAX_LENGTH_BYTES as defined in @stacks/transactions\n        memo: unpadMemo(payload.memo.content),\n        to: addressToString({\n          type: StacksMessageType.Address,\n          version: payload.recipient.address.version,\n          hash160: payload.recipient.address.hash160.toString(),\n        }),\n        amount: payload.amount.toString(),\n      };\n      return txPayload;\n    } else if (this._stxTransaction.payload.payloadType === PayloadType.ContractCall) {\n      const payload = this._stxTransaction.payload;\n      const contractPayload: StacksContractPayload = {\n        payloadType: PayloadType.ContractCall,\n        contractAddress: addressToString(payload.contractAddress),\n        contractName: payload.contractName.content,\n        functionName: payload.functionName.content,\n        functionArgs: payload.functionArgs.map(stringifyCv),\n      };\n      return contractPayload;\n    } else {\n      throw new NotSupported('payload type not supported');\n    }\n  }\n\n  /**\n   * Return the length of a transaction.  This is needed to calculate\n   * the transaction fee.\n   *\n   * @returns {number} size in bytes of the serialized transaction\n   */\n  transactionSize(): number {\n    return this._stxTransaction.serialize().length;\n  }\n\n  toBroadcastFormat(): string {\n    if (!this._stxTransaction) {\n      throw new ParseTransactionError('Empty transaction');\n    }\n    return this._stxTransaction.serialize().toString('hex');\n  }\n\n  get stxTransaction(): StacksTransaction {\n    return this._stxTransaction;\n  }\n\n  set stxTransaction(t: StacksTransaction) {\n    this._stxTransaction = t;\n  }\n\n  private getNonce(): number {\n    if (this._stxTransaction.auth.spendingCondition) {\n      return Number(this._stxTransaction.auth.spendingCondition.nonce);\n    } else {\n      throw new InvalidTransactionError('spending condition is null');\n    }\n  }\n\n  /**\n   * Sets this transaction payload\n   *\n   * @param rawTransaction\n   */\n  fromRawTransaction(rawTransaction: string): void {\n    const raw = removeHexPrefix(rawTransaction);\n    try {\n      this._stxTransaction = deserializeTransaction(BufferReader.fromBuffer(Buffer.from(raw, 'hex')));\n    } catch (e) {\n      throw new ParseTransactionError('Error parsing the raw transaction');\n    }\n    this.loadInputsAndOutputs();\n  }\n\n  /**\n   * Set the transaction type\n   *\n   * @param {TransactionType} transactionType The transaction type to be set\n   */\n  setTransactionType(transactionType: TransactionType): void {\n    this._type = transactionType;\n  }\n\n  /**\n   * Load the input and output data on this transaction using the transaction json\n   * if there are outputs.\n   */\n  loadInputsAndOutputs(): void {\n    const txJson = this.toJson();\n    if (txJson.payload.payloadType === PayloadType.TokenTransfer) {\n      if (txJson.payload.to && txJson.payload.amount) {\n        this._outputs = [\n          {\n            address: txJson.payload.to,\n            value: txJson.payload.amount,\n            coin: this._coinConfig.name,\n          },\n        ];\n\n        this._inputs = [\n          {\n            address: txJson.from,\n            value: txJson.payload.amount,\n            coin: this._coinConfig.name,\n          },\n        ];\n      }\n    } else if (txJson.payload.payloadType === PayloadType.ContractCall) {\n      if (txJson.payload.contractAddress === (this._coinConfig.network as StacksNetwork).sendmanymemoContractAddress) {\n        const sendParams = functionArgsToSendParams((this.stxTransaction.payload as ContractCallPayload).functionArgs);\n        const coin = this._coinConfig.name;\n        const sum: BigNum = sendParams.reduce((current, next) => current.add(new BigNum(next.amount)), new BigNum(0));\n        this._outputs = sendParams.map((sendParam) => ({ address: sendParam.address, value: sendParam.amount, coin }));\n        this._inputs = [{ address: txJson.from, value: sum.toString(), coin }];\n      } else if (txJson.payload.functionName === FUNCTION_NAME_TRANSFER && txJson.payload.functionArgs.length >= 3) {\n        this._outputs = [\n          {\n            address: cvToString(txJson.payload.functionArgs[2]),\n            value: cvToValue(txJson.payload.functionArgs[0]).toString(),\n            coin: this._coinConfig.name,\n          },\n        ];\n        this._inputs = [\n          {\n            address: cvToString(txJson.payload.functionArgs[1]),\n            value: cvToValue(txJson.payload.functionArgs[0]).toString(),\n            coin: this._coinConfig.name,\n          },\n        ];\n      } else {\n        this._outputs = [\n          {\n            address: txJson.payload.contractAddress,\n            value: '0',\n            coin: this._coinConfig.name,\n          },\n        ];\n\n        this._inputs = [\n          {\n            address: txJson.from,\n            value: '0',\n            coin: this._coinConfig.name,\n          },\n        ];\n      }\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,86 @@
+import BigNumber from 'bignumber.js';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { StacksNetwork } from '@stacks/network';
+import { BaseAddress, BaseFee, BaseKey, BaseTransactionBuilder } from '@bitgo/sdk-core';
+import { Transaction } from './transaction';
+import { KeyPair } from './keyPair';
+import { SignatureData } from './iface';
+export declare abstract class TransactionBuilder extends BaseTransactionBuilder {
+    private _transaction;
+    protected _anchorMode: number;
+    protected _fee: BaseFee;
+    protected _nonce: number;
+    protected _memo: string;
+    protected _numberSignatures: number;
+    protected _multiSignerKeyPairs: KeyPair[];
+    protected _signatures: SignatureData[];
+    protected _network: StacksNetwork;
+    protected _fromPubKeys: string[];
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     */
+    initBuilder(tx: Transaction): void;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    private getSignature;
+    private getPrivateKey;
+    /** @inheritdoc */
+    protected signImplementation(key: BaseKey): Transaction;
+    /** @inheritdoc */
+    protected get transaction(): Transaction;
+    /** @inheritdoc */
+    protected set transaction(transaction: Transaction);
+    /**
+     * Validates that the given key is not already in this._multiSignerKeyPairs
+     *
+     * @param {BaseKey} key - The key to check
+     */
+    private checkDuplicatedKeys;
+    /**
+     * Set the transaction fees
+     *
+     * @param {BaseFee} fee The maximum gas to pay
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    fee(fee: BaseFee): this;
+    nonce(n: number): this;
+    fromPubKey(senderPubKey: string | string[]): this;
+    /**
+     *  Set the memo
+     *
+     * @param {string} memo
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    memo(memo: string): this;
+    /**
+     *  Set the number of signatures for multi-sig
+     *
+     * @param {number} numSigns
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    numberSignatures(numSigns: number): this;
+    /** @inheritdoc */
+    validateAddress(address: BaseAddress, addressFormat?: string): void;
+    /** @inheritdoc */
+    validateKey(key: BaseKey): void;
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction: string): void;
+    /** @inheritdoc */
+    validateTransaction(transaction?: Transaction): void;
+    /** @inheritdoc */
+    validateValue(value: BigNumber): void;
+    /**
+     * Validates that the fee field is defined
+     */
+    private validateFee;
+    /**
+     * Validates that nonce is defined
+     */
+    private validateNonce;
+}
+//# sourceMappingURL=transactionBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAe,MAAM,gBAAgB,CAAC;AAarE,OAAO,EAAE,aAAa,EAAgC,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EACL,WAAW,EACX,OAAO,EACP,OAAO,EACP,sBAAsB,EAOvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAIxC,8BAAsB,kBAAmB,SAAQ,sBAAsB;IACrE,OAAO,CAAC,YAAY,CAAc;IAClC,SAAS,CAAC,WAAW,EAAE,MAAM,CAAC;IAC9B,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACpC,SAAS,CAAC,oBAAoB,EAAE,OAAO,EAAE,CAAC;IAC1C,SAAS,CAAC,WAAW,EAAE,aAAa,EAAE,CAAC;IACvC,SAAS,CAAC,QAAQ,EAAE,aAAa,CAAC;IAClC,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC;gBAErB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAW7C;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IA2ClC,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAYjE,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAwB3D,OAAO,CAAC,YAAY,CAC8B;IAClD,OAAO,CAAC,aAAa,CACoF;IAEzG,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW;IAmBvD,kBAAkB;IAClB,SAAS,KAAK,WAAW,IAAI,WAAW,CAEvC;IAED,kBAAkB;IAClB,SAAS,KAAK,WAAW,CAAC,WAAW,EAAE,WAAW,EAEjD;IAED;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAMvB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAKtB,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAajD;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQxB;;;;;OAKG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAOxC,kBAAkB;IAClB,eAAe,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI;IAMnE,kBAAkB;IAClB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAO/B,kBAAkB;IAClB,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAWpD,kBAAkB;IAClB,mBAAmB,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI;IAKpD,kBAAkB;IAClB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAMrC;;OAEG;IACH,OAAO,CAAC,WAAW;IAWnB;;OAEG;IACH,OAAO,CAAC,aAAa;CAUtB"}