@bitgo-beta/sdk-core 8.2.1-beta.172 → 8.2.1-beta.1721

package/dist/src/bitgo/utils/tss/recipientUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipientUtils.d.ts","sourceRoot":"","sources":["../../../../../src/bitgo/utils/tss/recipientUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,EAAmB,SAAS,EAAE,MAAM,aAAa,CAAC;AAEzD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,aAShC,CAAC;AAEH;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,iBAAiB,GAAG,SAAS,GACtC,iBAAiB,CAmBnB"}

package/dist/src/bitgo/utils/tss/recipientUtils.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_RECIPIENT_TX_TYPES = void 0;
+exports.resolveEffectiveTxParams = resolveEffectiveTxParams;
+const errors_1 = require("../../errors");
+/**
+ * Transaction types that legitimately carry no explicit recipients.
+ * verifyTransaction handles no-recipient validation for these internally.
+ * Mirrors the bypass list in abstractEthLikeNewCoins.ts verifyTssTransaction.
+ */
+exports.NO_RECIPIENT_TX_TYPES = new Set([
+    'acceleration',
+    'fillNonce',
+    'transferToken',
+    'tokenApproval',
+    'consolidate',
+    'bridgeFunds',
+    'enableToken',
+    'customTx', // DeFi/WalletConnect smart contract interactions have no traditional recipients
+]);
+/**
+ * Resolves the effective txParams for TSS signing recipient verification.
+ *
+ * For smart contract interactions, recipients live in txRequest.intent.recipients
+ * (native amount = 0, so buildParams is empty). Falls back to intent recipients
+ * mapped to ITransactionRecipient shape when txParams.recipients is absent.
+ *
+ * Throws InvalidTransactionError if no recipients can be resolved and the
+ * transaction type is not a known no-recipient type.
+ */
+function resolveEffectiveTxParams(txRequest, txParams) {
+    const intentRecipients = txRequest.intent?.recipients?.map((intentRecipient) => ({
+        address: intentRecipient.address.address,
+        amount: intentRecipient.amount.value,
+        data: intentRecipient.data,
+    }));
+    const effectiveTxParams = {
+        ...txParams,
+        recipients: txParams?.recipients?.length ? txParams.recipients : intentRecipients,
+    };
+    if (!effectiveTxParams.recipients?.length && !exports.NO_RECIPIENT_TX_TYPES.has(effectiveTxParams.type ?? '')) {
+        throw new errors_1.InvalidTransactionError('Recipient details are required to verify this transaction before signing. Pass txParams with at least one recipient.');
+    }
+    return effectiveTxParams;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/bitgo/utils/txRequest.d.ts

@@ -0,0 +1,10 @@
+import { ApiVersion, IWallet } from '../wallet';
+export declare function validateTxRequestApiVersion(wallet: IWallet, requestedApiVersion: ApiVersion): void;
+/**
+ * Get the api version for the provided wallet.
+ * If the user requested api version is invalid, this will throw an error.
+ * @param wallet
+ * @param requestedApiVersion
+ */
+export declare function getTxRequestApiVersion(wallet: IWallet, requestedApiVersion?: ApiVersion): ApiVersion;
+//# sourceMappingURL=txRequest.d.ts.map

package/dist/src/bitgo/utils/txRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"txRequest.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/utils/txRequest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGhD,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,OAAO,EAAE,mBAAmB,EAAE,UAAU,GAAG,IAAI,CAgBlG;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,mBAAmB,CAAC,EAAE,UAAU,GAAG,UAAU,CAcpG"}

package/dist/src/bitgo/utils/txRequest.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTxRequestApiVersion = validateTxRequestApiVersion;
+exports.getTxRequestApiVersion = getTxRequestApiVersion;
+const assert_1 = __importDefault(require("assert"));
+function validateTxRequestApiVersion(wallet, requestedApiVersion) {
+    if (wallet.multisigType() !== 'tss') {
+        // only tss wallets have api version requirements
+        return;
+    }
+    if (wallet.baseCoin.getMPCAlgorithm() === 'ecdsa') {
+        // ecdsa wallets can only use full, even if they are hot wallets
+        (0, assert_1.default)(requestedApiVersion === 'full', 'For ECDSA tss wallets, parameter `apiVersion` must be `full`.');
+    }
+    else if (wallet.type() !== 'hot') {
+        // all other cases should use full!
+        (0, assert_1.default)(requestedApiVersion === 'full', 'For non self-custodial (hot) tss wallets, parameter `apiVersion` must be `full`.');
+    }
+    return;
+}
+/**
+ * Get the api version for the provided wallet.
+ * If the user requested api version is invalid, this will throw an error.
+ * @param wallet
+ * @param requestedApiVersion
+ */
+function getTxRequestApiVersion(wallet, requestedApiVersion) {
+    if (requestedApiVersion) {
+        validateTxRequestApiVersion(wallet, requestedApiVersion);
+        return requestedApiVersion;
+    }
+    if (wallet.baseCoin.getMPCAlgorithm() === 'ecdsa') {
+        return 'full';
+    }
+    else if (wallet.type() === 'hot') {
+        // default to lite for hot eddsa tss wallets
+        return 'lite';
+    }
+    else {
+        // default to full for all other wallet types
+        return 'full';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/bitgo/utils/util.js

@@ -5,7 +5,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -15,13 +19,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Util = exports.RequestTracer = void 0;
 /**
@@ -50,7 +64,7 @@ Promise.resolve().then(() => __importStar(require('ethereumjs-util'))).then((eth
 class RequestTracer {
     constructor() {
         this._seq = 0;
-        this._seed = crypto_1.randomBytes(10);
+        this._seed = (0, crypto_1.randomBytes)(10);
     }
     inc() {
         this._seq++;
@@ -195,4 +209,4 @@ class Util {
     }
 }
 exports.Util = Util;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../src/bitgo/utils/util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n * @hidden\n */\n\n/**\n */\nimport { bip32 } from '@bitgo-beta/utxo-lib';\nimport * as Big from 'big.js';\nimport * as _ from 'lodash';\nimport { randomBytes } from 'crypto';\nimport { IRequestTracer } from '../../api';\nimport { EthereumLibraryUnavailableError } from '../errors';\n\nconst debug = require('debug')('bitgo:v2:util');\n\nlet ethUtil;\nlet isEthAvailable = false;\n\nconst ethImport = 'ethereumjs-util';\nimport('ethereumjs-util')\n  .then((eth) => {\n    ethUtil = eth;\n    isEthAvailable = true;\n  })\n  .catch((e) => {\n    // ethereum currently not supported\n    debug('unable to load ethereumjs-util:');\n    debug(e.stack);\n  });\n\n/**\n * Create a request tracer for tracing workflows which involve multiple round trips to the server\n */\nexport class RequestTracer implements IRequestTracer {\n  private _seq = 0;\n  private readonly _seed: Buffer;\n  constructor() {\n    this._seed = randomBytes(10);\n  }\n\n  inc() {\n    this._seq++;\n  }\n\n  toString() {\n    return `${this._seed.toString('hex')}-${_.padStart(this._seq.toString(16), 4, '0')}`;\n  }\n}\n\nexport class Util {\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  private constructor() {}\n\n  /**\n   * @deprecated\n   */\n  static isEthAvailable() {\n    return isEthAvailable;\n  }\n\n  /**\n   * Convert a big.js big number to an array of unsigned bytes\n   * @param bn\n   * @deprecated\n   */\n  static bnToByteArrayUnsigned(bn: any): any {\n    let ba = bn.abs().toByteArray();\n    if (ba.length) {\n      if (ba[0] === 0) {\n        ba = ba.slice(1);\n      }\n      return ba.map(function (v) {\n        return v < 0 ? v + 256 : v;\n      });\n    } else {\n      // Empty array, nothing to do\n      return ba;\n    }\n  }\n\n  /**\n   * Utility method for handling arguments of pageable queries\n   * @param params\n   * @deprecated\n   */\n  static preparePageableQuery(params: { limit?: number; skip?: number } = {}): { limit?: number; skip?: number } {\n    const query: any = {};\n    if (params.limit) {\n      if (!_.isNumber(params.limit)) {\n        throw new Error('invalid limit argument, expecting number');\n      }\n      query.limit = params.limit;\n    }\n    if (params.skip) {\n      if (!_.isNumber(params.skip)) {\n        throw new Error('invalid skip argument, expecting number');\n      }\n      query.skip = params.skip;\n    }\n    return query;\n  }\n\n  /**\n   * Create a request identifier for tracing multi-request workflows\n   */\n  static createRequestId(): RequestTracer {\n    return new RequestTracer();\n  }\n\n  /**\n   * Convert a BTC xpub to an Ethereum address (with 0x prefix)\n   * @param xpub\n   * @deprecated\n   */\n  static xpubToEthAddress(xpub: string): string {\n    if (!isEthAvailable) {\n      throw new EthereumLibraryUnavailableError(ethImport);\n    }\n    return ethUtil.bufferToHex(ethUtil.publicToAddress(bip32.fromBase58(xpub).publicKey, true /* sanitize */));\n  }\n\n  /**\n   * Convert a BTC xpriv to an Ethereum private key (without 0x prefix)\n   * @param xprv\n   * @deprecated\n   */\n  static xprvToEthPrivateKey(xprv: string): string {\n    const node = bip32.fromBase58(xprv);\n    if (!node.privateKey) {\n      throw new Error(`no privateKey`);\n    }\n    return node.privateKey.toString('hex');\n  }\n\n  /**\n   * Sign a message using Ethereum's ECsign method and return the signature string\n   * @param msgHash\n   * @param privKey\n   * @deprecated\n   */\n  static ethSignMsgHash(msgHash: string, privKey: string): string {\n    if (!isEthAvailable) {\n      throw new EthereumLibraryUnavailableError(ethImport);\n    }\n    const signatureInParts = ethUtil.ecsign(\n      Buffer.from(ethUtil.stripHexPrefix(msgHash), 'hex'),\n      Buffer.from(privKey, 'hex')\n    );\n\n    // Assemble strings from r, s and v\n    const r = ethUtil.setLengthLeft(signatureInParts.r, 32).toString('hex');\n    const s = ethUtil.setLengthLeft(signatureInParts.s, 32).toString('hex');\n    const v = ethUtil.stripHexPrefix(ethUtil.intToHex(signatureInParts.v));\n\n    // Concatenate the r, s and v parts to make the signature string\n    return ethUtil.addHexPrefix(r.concat(s, v));\n  }\n\n  /**\n   * Convert from wei string (or BN) to Ether (multiply by 1e18)\n   * @param wei\n   * @deprecated\n   */\n  static weiToEtherString(wei: any): string {\n    if (!isEthAvailable) {\n      throw new EthereumLibraryUnavailableError(ethImport);\n    }\n    let bn = wei;\n    if (!(wei instanceof ethUtil.BN)) {\n      bn = new ethUtil.BN(wei);\n    }\n    Big.E_POS = 256;\n    Big.E_NEG = -18;\n    const weiString = bn.toString(10);\n    const big = new Big(weiString);\n    // 10^18\n    const ether = big.div('1000000000000000000');\n    return ether.toPrecision();\n  }\n\n  /**\n   * Recover an ethereum address from a signature and message hash\n   * @param msgHash\n   * @param signature\n   * @deprecated\n   */\n  static ecRecoverEthAddress(msgHash: string, signature: string): string {\n    msgHash = ethUtil.stripHexPrefix(msgHash);\n    signature = ethUtil.stripHexPrefix(signature);\n\n    const v = parseInt(signature.slice(128, 130), 16);\n    const r = Buffer.from(signature.slice(0, 64), 'hex');\n    const s = Buffer.from(signature.slice(64, 128), 'hex');\n\n    const pubKey = ethUtil.ecrecover(Buffer.from(msgHash, 'hex'), v, r, s);\n    return ethUtil.bufferToHex(ethUtil.pubToAddress(pubKey));\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../src/bitgo/utils/util.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH;GACG;AACH,mDAA6C;AAC7C,4CAA8B;AAC9B,0CAA4B;AAC5B,mCAAqC;AAErC,sCAA4D;AAE5D,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,eAAe,CAAC,CAAC;AAEhD,IAAI,OAAO,CAAC;AACZ,IAAI,cAAc,GAAG,KAAK,CAAC;AAE3B,MAAM,SAAS,GAAG,iBAAiB,CAAC;AACpC,kDAAO,iBAAiB,IACrB,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;IACZ,OAAO,GAAG,GAAG,CAAC;IACd,cAAc,GAAG,IAAI,CAAC;AACxB,CAAC,CAAC;KACD,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;IACX,mCAAmC;IACnC,KAAK,CAAC,iCAAiC,CAAC,CAAC;IACzC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC,CAAC,CAAC;AAEL;;GAEG;AACH,MAAa,aAAa;IAGxB;QAFQ,SAAI,GAAG,CAAC,CAAC;QAGf,IAAI,CAAC,KAAK,GAAG,IAAA,oBAAW,EAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED,GAAG;QACD,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,QAAQ;QACN,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;IACvF,CAAC;CACF;AAdD,sCAcC;AAED,MAAa,IAAI;IACf,gEAAgE;IAChE,gBAAuB,CAAC;IAExB;;OAEG;IACH,MAAM,CAAC,cAAc;QACnB,OAAO,cAAc,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,qBAAqB,CAAC,EAAO;QAClC,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC;QAChC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;YACd,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;gBAChB,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACnB,CAAC;YACD,OAAO,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;gBACvB,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAC7B,CAAC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,6BAA6B;YAC7B,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,CAAC,SAA4C,EAAE;QACxE,MAAM,KAAK,GAAQ,EAAE,CAAC;QACtB,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;YACjB,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC9B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;YAC9D,CAAC;YACD,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC7B,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;YAChB,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7B,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;YAC7D,CAAC;YACD,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QAC3B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,eAAe;QACpB,OAAO,IAAI,aAAa,EAAE,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,CAAC,IAAY;QAClC,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,wCAA+B,CAAC,SAAS,CAAC,CAAC;QACvD,CAAC;QACD,OAAO,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,eAAe,CAAC,gBAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;IAC7G,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,mBAAmB,CAAC,IAAY;QACrC,MAAM,IAAI,GAAG,gBAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,OAAe,EAAE,OAAe;QACpD,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,wCAA+B,CAAC,SAAS,CAAC,CAAC;QACvD,CAAC;QACD,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAM,CACrC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,EACnD,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAC5B,CAAC;QAEF,mCAAmC;QACnC,MAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACxE,MAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACxE,MAAM,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;QAEvE,gEAAgE;QAChE,OAAO,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,CAAC,GAAQ;QAC9B,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,wCAA+B,CAAC,SAAS,CAAC,CAAC;QACvD,CAAC;QACD,IAAI,EAAE,GAAG,GAAG,CAAC;QACb,IAAI,CAAC,CAAC,GAAG,YAAY,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC;YACjC,EAAE,GAAG,IAAI,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAC3B,CAAC;QACD,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC;QAChB,GAAG,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;QAChB,MAAM,SAAS,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAClC,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;QAC/B,QAAQ;QACR,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;QAC7C,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAC,OAAe,EAAE,SAAiB;QAC3D,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC1C,SAAS,GAAG,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QAE9C,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QAClD,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QACrD,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;QAEvD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACvE,OAAO,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3D,CAAC;CACF;AApJD,oBAoJC","sourcesContent":["/**\n * @prettier\n * @hidden\n */\n\n/**\n */\nimport { bip32 } from '@bitgo-beta/utxo-lib';\nimport * as Big from 'big.js';\nimport * as _ from 'lodash';\nimport { randomBytes } from 'crypto';\nimport { IRequestTracer } from '../../api';\nimport { EthereumLibraryUnavailableError } from '../errors';\n\nconst debug = require('debug')('bitgo:v2:util');\n\nlet ethUtil;\nlet isEthAvailable = false;\n\nconst ethImport = 'ethereumjs-util';\nimport('ethereumjs-util')\n  .then((eth) => {\n    ethUtil = eth;\n    isEthAvailable = true;\n  })\n  .catch((e) => {\n    // ethereum currently not supported\n    debug('unable to load ethereumjs-util:');\n    debug(e.stack);\n  });\n\n/**\n * Create a request tracer for tracing workflows which involve multiple round trips to the server\n */\nexport class RequestTracer implements IRequestTracer {\n  private _seq = 0;\n  private readonly _seed: Buffer;\n  constructor() {\n    this._seed = randomBytes(10);\n  }\n\n  inc() {\n    this._seq++;\n  }\n\n  toString() {\n    return `${this._seed.toString('hex')}-${_.padStart(this._seq.toString(16), 4, '0')}`;\n  }\n}\n\nexport class Util {\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  private constructor() {}\n\n  /**\n   * @deprecated\n   */\n  static isEthAvailable() {\n    return isEthAvailable;\n  }\n\n  /**\n   * Convert a big.js big number to an array of unsigned bytes\n   * @param bn\n   * @deprecated\n   */\n  static bnToByteArrayUnsigned(bn: any): any {\n    let ba = bn.abs().toByteArray();\n    if (ba.length) {\n      if (ba[0] === 0) {\n        ba = ba.slice(1);\n      }\n      return ba.map(function (v) {\n        return v < 0 ? v + 256 : v;\n      });\n    } else {\n      // Empty array, nothing to do\n      return ba;\n    }\n  }\n\n  /**\n   * Utility method for handling arguments of pageable queries\n   * @param params\n   * @deprecated\n   */\n  static preparePageableQuery(params: { limit?: number; skip?: number } = {}): { limit?: number; skip?: number } {\n    const query: any = {};\n    if (params.limit) {\n      if (!_.isNumber(params.limit)) {\n        throw new Error('invalid limit argument, expecting number');\n      }\n      query.limit = params.limit;\n    }\n    if (params.skip) {\n      if (!_.isNumber(params.skip)) {\n        throw new Error('invalid skip argument, expecting number');\n      }\n      query.skip = params.skip;\n    }\n    return query;\n  }\n\n  /**\n   * Create a request identifier for tracing multi-request workflows\n   */\n  static createRequestId(): RequestTracer {\n    return new RequestTracer();\n  }\n\n  /**\n   * Convert a BTC xpub to an Ethereum address (with 0x prefix)\n   * @param xpub\n   * @deprecated\n   */\n  static xpubToEthAddress(xpub: string): string {\n    if (!isEthAvailable) {\n      throw new EthereumLibraryUnavailableError(ethImport);\n    }\n    return ethUtil.bufferToHex(ethUtil.publicToAddress(bip32.fromBase58(xpub).publicKey, true /* sanitize */));\n  }\n\n  /**\n   * Convert a BTC xpriv to an Ethereum private key (without 0x prefix)\n   * @param xprv\n   * @deprecated\n   */\n  static xprvToEthPrivateKey(xprv: string): string {\n    const node = bip32.fromBase58(xprv);\n    if (!node.privateKey) {\n      throw new Error(`no privateKey`);\n    }\n    return node.privateKey.toString('hex');\n  }\n\n  /**\n   * Sign a message using Ethereum's ECsign method and return the signature string\n   * @param msgHash\n   * @param privKey\n   * @deprecated\n   */\n  static ethSignMsgHash(msgHash: string, privKey: string): string {\n    if (!isEthAvailable) {\n      throw new EthereumLibraryUnavailableError(ethImport);\n    }\n    const signatureInParts = ethUtil.ecsign(\n      Buffer.from(ethUtil.stripHexPrefix(msgHash), 'hex'),\n      Buffer.from(privKey, 'hex')\n    );\n\n    // Assemble strings from r, s and v\n    const r = ethUtil.setLengthLeft(signatureInParts.r, 32).toString('hex');\n    const s = ethUtil.setLengthLeft(signatureInParts.s, 32).toString('hex');\n    const v = ethUtil.stripHexPrefix(ethUtil.intToHex(signatureInParts.v));\n\n    // Concatenate the r, s and v parts to make the signature string\n    return ethUtil.addHexPrefix(r.concat(s, v));\n  }\n\n  /**\n   * Convert from wei string (or BN) to Ether (multiply by 1e18)\n   * @param wei\n   * @deprecated\n   */\n  static weiToEtherString(wei: any): string {\n    if (!isEthAvailable) {\n      throw new EthereumLibraryUnavailableError(ethImport);\n    }\n    let bn = wei;\n    if (!(wei instanceof ethUtil.BN)) {\n      bn = new ethUtil.BN(wei);\n    }\n    Big.E_POS = 256;\n    Big.E_NEG = -18;\n    const weiString = bn.toString(10);\n    const big = new Big(weiString);\n    // 10^18\n    const ether = big.div('1000000000000000000');\n    return ether.toPrecision();\n  }\n\n  /**\n   * Recover an ethereum address from a signature and message hash\n   * @param msgHash\n   * @param signature\n   * @deprecated\n   */\n  static ecRecoverEthAddress(msgHash: string, signature: string): string {\n    msgHash = ethUtil.stripHexPrefix(msgHash);\n    signature = ethUtil.stripHexPrefix(signature);\n\n    const v = parseInt(signature.slice(128, 130), 16);\n    const r = Buffer.from(signature.slice(0, 64), 'hex');\n    const s = Buffer.from(signature.slice(64, 128), 'hex');\n\n    const pubKey = ethUtil.ecrecover(Buffer.from(msgHash, 'hex'), v, r, s);\n    return ethUtil.bufferToHex(ethUtil.pubToAddress(pubKey));\n  }\n}\n"]}

package/dist/src/bitgo/utils/wallet.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generate a random password
+ * @param   {Number} numWords     Number of 32-bit words
+ * @returns {String}          base58 random password
+ */
+export declare function generateRandomPassword(numWords: number): string;
+//# sourceMappingURL=wallet.d.ts.map

package/dist/src/bitgo/utils/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/utils/wallet.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG/D"}

package/dist/src/bitgo/utils/wallet.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomPassword = generateRandomPassword;
+const sjcl = __importStar(require("@bitgo-beta/sjcl"));
+const bs58 = __importStar(require("bs58"));
+/**
+ * Generate a random password
+ * @param   {Number} numWords     Number of 32-bit words
+ * @returns {String}          base58 random password
+ */
+function generateRandomPassword(numWords) {
+    const bytes = sjcl.codec.bytes.fromBits(sjcl.random.randomWords(numWords));
+    return bs58.encode(bytes);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FsbGV0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2JpdGdvL3V0aWxzL3dhbGxldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQVFBLHdEQUdDO0FBWEQsdURBQXlDO0FBQ3pDLDJDQUE2QjtBQUU3Qjs7OztHQUlHO0FBQ0gsU0FBZ0Isc0JBQXNCLENBQUMsUUFBZ0I7SUFDckQsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7SUFDM0UsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQzVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBzamNsIGZyb20gJ0BiaXRnby1iZXRhL3NqY2wnO1xuaW1wb3J0ICogYXMgYnM1OCBmcm9tICdiczU4JztcblxuLyoqXG4gKiBHZW5lcmF0ZSBhIHJhbmRvbSBwYXNzd29yZFxuICogQHBhcmFtICAge051bWJlcn0gbnVtV29yZHMgICAgIE51bWJlciBvZiAzMi1iaXQgd29yZHNcbiAqIEByZXR1cm5zIHtTdHJpbmd9ICAgICAgICAgIGJhc2U1OCByYW5kb20gcGFzc3dvcmRcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdlbmVyYXRlUmFuZG9tUGFzc3dvcmQobnVtV29yZHM6IG51bWJlcik6IHN0cmluZyB7XG4gIGNvbnN0IGJ5dGVzID0gc2pjbC5jb2RlYy5ieXRlcy5mcm9tQml0cyhzamNsLnJhbmRvbS5yYW5kb21Xb3JkcyhudW1Xb3JkcykpO1xuICByZXR1cm4gYnM1OC5lbmNvZGUoYnl0ZXMpO1xufVxuIl19

package/dist/src/bitgo/wallet/BuildParams.d.ts

@@ -1,8 +1,13 @@
 import * as t from 'io-ts';
+export declare const Bip322Message: t.TypeC<{
+    message: t.StringC;
+    address: t.StringC;
+}>;
 export declare const BuildParamsUTXO: t.PartialC<{
     addressType: t.UnknownC;
     changeAddressType: t.UnknownC;
     changeAddress: t.UnknownC;
+    allowExternalChangeAddress: t.BooleanC;
     cpfpFeeRate: t.UnknownC;
     cpfpTxIds: t.UnknownC;
     unspents: t.UnknownC;
@@ -16,7 +21,14 @@ export declare const BuildParamsUTXO: t.PartialC<{
     smallestChangeSplitSize: t.UnknownC;
     enforceMinConfirmsForChange: t.UnknownC;
     txFormat: t.UnknownC;
+    allowedInputScriptTypes: t.UnknownC;
     maxChangeOutputs: t.UnknownC;
+    rbfTxIds: t.ArrayC<t.StringC>;
+    isReplaceableByFee: t.BooleanC;
+    messages: t.ArrayC<t.TypeC<{
+        message: t.StringC;
+        address: t.StringC;
+    }>>;
 }>;
 export declare const BuildParamsStacks: t.PartialC<{
     contractName: t.UnknownC;
@@ -32,6 +44,7 @@ export declare const BuildParams: t.ExactC<t.IntersectionC<[t.PartialC<{
     addressType: t.UnknownC;
     changeAddressType: t.UnknownC;
     changeAddress: t.UnknownC;
+    allowExternalChangeAddress: t.BooleanC;
     cpfpFeeRate: t.UnknownC;
     cpfpTxIds: t.UnknownC;
     unspents: t.UnknownC;
@@ -45,7 +58,14 @@ export declare const BuildParams: t.ExactC<t.IntersectionC<[t.PartialC<{
     smallestChangeSplitSize: t.UnknownC;
     enforceMinConfirmsForChange: t.UnknownC;
     txFormat: t.UnknownC;
+    allowedInputScriptTypes: t.UnknownC;
     maxChangeOutputs: t.UnknownC;
+    rbfTxIds: t.ArrayC<t.StringC>;
+    isReplaceableByFee: t.BooleanC;
+    messages: t.ArrayC<t.TypeC<{
+        message: t.StringC;
+        address: t.StringC;
+    }>>;
 }>, t.PartialC<{
     contractName: t.UnknownC;
     functionName: t.UnknownC;
@@ -90,6 +110,7 @@ export declare const BuildParams: t.ExactC<t.IntersectionC<[t.PartialC<{
     destinationChain: t.UnknownC;
     trustlines: t.UnknownC;
     type: t.UnknownC;
+    limit: t.UnknownC;
     timeBounds: t.UnknownC;
     startTime: t.UnknownC;
     stateProofKey: t.UnknownC;
@@ -106,7 +127,12 @@ export declare const BuildParams: t.ExactC<t.IntersectionC<[t.PartialC<{
     tokenName: t.UnknownC;
     prebuildTx: t.UnknownC;
     emergency: t.UnknownC;
+    solInstructions: t.UnknownC;
+    solVersionedTransactionData: t.UnknownC;
+    aptosCustomTransactionParams: t.UnknownC;
+    isTestTransaction: t.UnknownC;
+    feeToken: t.UnknownC;
 }>]>>;
-export declare type BuildParams = t.TypeOf<typeof BuildParams>;
+export type BuildParams = t.TypeOf<typeof BuildParams>;
 export declare const buildParamKeys: string[];
 //# sourceMappingURL=BuildParams.d.ts.map

package/dist/src/bitgo/wallet/BuildParams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BuildParams.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/wallet/BuildParams.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAG3B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;EAuB1B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6DvB,CAAC;AAEF,oBAAY,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;AACvD,eAAO,MAAM,cAAc,UAAkC,CAAC"}
+{"version":3,"file":"BuildParams.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/wallet/BuildParams.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAG3B,eAAO,MAAM,aAAa;;;EAGxB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B1B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsEvB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;AACvD,eAAO,MAAM,cAAc,UAAkC,CAAC"}

package/dist/src/bitgo/wallet/BuildParams.js

@@ -2,7 +2,11 @@
 /* eslint no-redeclare: off */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -12,17 +16,31 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildParamKeys = exports.BuildParams = exports.BuildParamsOffchain = exports.BuildParamsStacks = exports.BuildParamsUTXO = void 0;
+exports.buildParamKeys = exports.BuildParams = exports.BuildParamsOffchain = exports.BuildParamsStacks = exports.BuildParamsUTXO = exports.Bip322Message = void 0;
 const t = __importStar(require("io-ts"));
 const codecProps_1 = require("../utils/codecProps");
+exports.Bip322Message = t.type({
+    message: t.string,
+    address: t.string,
+});
 exports.BuildParamsUTXO = t.partial({
     /* deprecated. the change address type */
     addressType: t.unknown,
@@ -30,6 +48,7 @@ exports.BuildParamsUTXO = t.partial({
     changeAddressType: t.unknown,
     /* a fixed change address */
     changeAddress: t.unknown,
+    allowExternalChangeAddress: t.boolean,
     cpfpFeeRate: t.unknown,
     cpfpTxIds: t.unknown,
     unspents: t.unknown,
@@ -45,7 +64,13 @@ exports.BuildParamsUTXO = t.partial({
     enforceMinConfirmsForChange: t.unknown,
     /* legacy or psbt */
     txFormat: t.unknown,
+    /* restrict which input script types WP may select (e.g. for legacy format compatibility) */
+    allowedInputScriptTypes: t.unknown,
     maxChangeOutputs: t.unknown,
+    /* rbf */
+    rbfTxIds: t.array(t.string),
+    isReplaceableByFee: t.boolean,
+    messages: t.array(exports.Bip322Message),
 });
 exports.BuildParamsStacks = t.partial({
     contractName: t.unknown,
@@ -97,6 +122,7 @@ exports.BuildParams = t.exact(t.intersection([
         destinationChain: t.unknown,
         trustlines: t.unknown,
         type: t.unknown,
+        limit: t.unknown,
         timeBounds: t.unknown,
         startTime: t.unknown,
         stateProofKey: t.unknown,
@@ -115,7 +141,15 @@ exports.BuildParams = t.exact(t.intersection([
         // param to set emergency flag on a custodial transaction.
         // This transaction should be performed in less than 1 hour or it will fail.
         emergency: t.unknown,
+        // Solana custom instructions for transaction building
+        solInstructions: t.unknown,
+        // Solana versioned transaction data for transaction building
+        solVersionedTransactionData: t.unknown,
+        // Aptos custom transaction parameters for smart contract calls
+        aptosCustomTransactionParams: t.unknown,
+        isTestTransaction: t.unknown,
+        feeToken: t.unknown,
     }),
 ]));
-exports.buildParamKeys = codecProps_1.getCodecProperties(exports.BuildParams);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BuildParams.js","sourceRoot":"","sources":["../../../../src/bitgo/wallet/BuildParams.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint no-redeclare: off */\n\nimport * as t from 'io-ts';\nimport { getCodecProperties } from '../utils/codecProps';\n\nexport const BuildParamsUTXO = t.partial({\n  /* deprecated. the change address type */\n  addressType: t.unknown,\n  /* the change address type */\n  changeAddressType: t.unknown,\n  /* a fixed change address */\n  changeAddress: t.unknown,\n  cpfpFeeRate: t.unknown,\n  cpfpTxIds: t.unknown,\n  unspents: t.unknown,\n  minValue: t.unknown,\n  minConfirms: t.unknown,\n  maxValue: t.unknown,\n  targetWalletUnspents: t.unknown,\n  /* unspent selection strategy */\n  strategy: t.unknown,\n  strategyAllowFallback: t.unknown,\n  noSplitChange: t.unknown,\n  smallestChangeSplitSize: t.unknown,\n  enforceMinConfirmsForChange: t.unknown,\n  /* legacy or psbt */\n  txFormat: t.unknown,\n  maxChangeOutputs: t.unknown,\n});\n\nexport const BuildParamsStacks = t.partial({\n  contractName: t.unknown,\n  functionName: t.unknown,\n  functionArgs: t.unknown,\n});\n\nexport const BuildParamsOffchain = t.partial({\n  idfSignedTimestamp: t.unknown,\n  idfVersion: t.unknown,\n  idfUserId: t.unknown,\n});\n\nexport const BuildParams = t.exact(\n  t.intersection([\n    BuildParamsUTXO,\n    BuildParamsStacks,\n    BuildParamsOffchain,\n    t.partial({\n      apiVersion: t.unknown,\n      consolidateAddresses: t.unknown,\n      consolidateId: t.unknown,\n      comment: t.string,\n      delayMs: t.unknown,\n      fee: t.unknown,\n      feeRate: t.unknown,\n      feeMultiplier: t.unknown,\n      enableTokens: t.unknown,\n      gasLimit: t.unknown,\n      gasPrice: t.unknown,\n      hopParams: t.unknown,\n      instant: t.unknown,\n      lastLedgerSequence: t.unknown,\n      ledgerSequenceDelta: t.unknown,\n      maxFee: t.unknown,\n      maxFeeRate: t.unknown,\n      memo: t.unknown,\n      transferId: t.unknown,\n      message: t.unknown,\n      numBlocks: t.unknown,\n      nonce: t.unknown,\n      pendingApprovalId: t.unknown,\n      preview: t.unknown,\n      previewPendingTxs: t.unknown,\n      senderAddress: t.unknown,\n      receiveAddress: t.unknown,\n      recipients: t.unknown,\n      reservation: t.unknown,\n      refundOptions: t.unknown,\n      sequenceId: t.unknown,\n      sourceChain: t.unknown,\n      destinationChain: t.unknown,\n      trustlines: t.unknown,\n      type: t.unknown,\n      timeBounds: t.unknown,\n      startTime: t.unknown,\n      stateProofKey: t.unknown,\n      nonParticipation: t.unknown,\n      validFromBlock: t.unknown,\n      validToBlock: t.unknown,\n      messageKey: t.unknown,\n      stakingParams: t.unknown,\n      stakingOptions: t.unknown,\n      unstakingOptions: t.unknown,\n      eip1559: t.unknown,\n      keyregTxBase64: t.unknown,\n      closeRemainderTo: t.unknown,\n      tokenName: t.unknown,\n      prebuildTx: t.unknown,\n      // param to set emergency flag on a custodial transaction.\n      // This transaction should be performed in less than 1 hour or it will fail.\n      emergency: t.unknown,\n    }),\n  ])\n);\n\nexport type BuildParams = t.TypeOf<typeof BuildParams>;\nexport const buildParamKeys = getCodecProperties(BuildParams);\n"]}
+exports.buildParamKeys = (0, codecProps_1.getCodecProperties)(exports.BuildParams);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BuildParams.js","sourceRoot":"","sources":["../../../../src/bitgo/wallet/BuildParams.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint no-redeclare: off */\n\nimport * as t from 'io-ts';\nimport { getCodecProperties } from '../utils/codecProps';\n\nexport const Bip322Message = t.type({\n  message: t.string,\n  address: t.string,\n});\n\nexport const BuildParamsUTXO = t.partial({\n  /* deprecated. the change address type */\n  addressType: t.unknown,\n  /* the change address type */\n  changeAddressType: t.unknown,\n  /* a fixed change address */\n  changeAddress: t.unknown,\n  allowExternalChangeAddress: t.boolean,\n  cpfpFeeRate: t.unknown,\n  cpfpTxIds: t.unknown,\n  unspents: t.unknown,\n  minValue: t.unknown,\n  minConfirms: t.unknown,\n  maxValue: t.unknown,\n  targetWalletUnspents: t.unknown,\n  /* unspent selection strategy */\n  strategy: t.unknown,\n  strategyAllowFallback: t.unknown,\n  noSplitChange: t.unknown,\n  smallestChangeSplitSize: t.unknown,\n  enforceMinConfirmsForChange: t.unknown,\n  /* legacy or psbt */\n  txFormat: t.unknown,\n  /* restrict which input script types WP may select (e.g. for legacy format compatibility) */\n  allowedInputScriptTypes: t.unknown,\n  maxChangeOutputs: t.unknown,\n  /* rbf */\n  rbfTxIds: t.array(t.string),\n  isReplaceableByFee: t.boolean,\n  messages: t.array(Bip322Message),\n});\n\nexport const BuildParamsStacks = t.partial({\n  contractName: t.unknown,\n  functionName: t.unknown,\n  functionArgs: t.unknown,\n});\n\nexport const BuildParamsOffchain = t.partial({\n  idfSignedTimestamp: t.unknown,\n  idfVersion: t.unknown,\n  idfUserId: t.unknown,\n});\n\nexport const BuildParams = t.exact(\n  t.intersection([\n    BuildParamsUTXO,\n    BuildParamsStacks,\n    BuildParamsOffchain,\n    t.partial({\n      apiVersion: t.unknown,\n      consolidateAddresses: t.unknown,\n      consolidateId: t.unknown,\n      comment: t.string,\n      delayMs: t.unknown,\n      fee: t.unknown,\n      feeRate: t.unknown,\n      feeMultiplier: t.unknown,\n      enableTokens: t.unknown,\n      gasLimit: t.unknown,\n      gasPrice: t.unknown,\n      hopParams: t.unknown,\n      instant: t.unknown,\n      lastLedgerSequence: t.unknown,\n      ledgerSequenceDelta: t.unknown,\n      maxFee: t.unknown,\n      maxFeeRate: t.unknown,\n      memo: t.unknown,\n      transferId: t.unknown,\n      message: t.unknown,\n      numBlocks: t.unknown,\n      nonce: t.unknown,\n      pendingApprovalId: t.unknown,\n      preview: t.unknown,\n      previewPendingTxs: t.unknown,\n      senderAddress: t.unknown,\n      receiveAddress: t.unknown,\n      recipients: t.unknown,\n      reservation: t.unknown,\n      refundOptions: t.unknown,\n      sequenceId: t.unknown,\n      sourceChain: t.unknown,\n      destinationChain: t.unknown,\n      trustlines: t.unknown,\n      type: t.unknown,\n      limit: t.unknown,\n      timeBounds: t.unknown,\n      startTime: t.unknown,\n      stateProofKey: t.unknown,\n      nonParticipation: t.unknown,\n      validFromBlock: t.unknown,\n      validToBlock: t.unknown,\n      messageKey: t.unknown,\n      stakingParams: t.unknown,\n      stakingOptions: t.unknown,\n      unstakingOptions: t.unknown,\n      eip1559: t.unknown,\n      keyregTxBase64: t.unknown,\n      closeRemainderTo: t.unknown,\n      tokenName: t.unknown,\n      prebuildTx: t.unknown,\n      // param to set emergency flag on a custodial transaction.\n      // This transaction should be performed in less than 1 hour or it will fail.\n      emergency: t.unknown,\n      // Solana custom instructions for transaction building\n      solInstructions: t.unknown,\n      // Solana versioned transaction data for transaction building\n      solVersionedTransactionData: t.unknown,\n      // Aptos custom transaction parameters for smart contract calls\n      aptosCustomTransactionParams: t.unknown,\n      isTestTransaction: t.unknown,\n      feeToken: t.unknown,\n    }),\n  ])\n);\n\nexport type BuildParams = t.TypeOf<typeof BuildParams>;\nexport const buildParamKeys = getCodecProperties(BuildParams);\n"]}