@bitgo-beta/sdk-core 8.2.1-beta.19 → 8.2.1-beta.1900

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

@@ -0,0 +1,49 @@
+"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') {
+        (0, assert_1.default)(requestedApiVersion === 'full', 'For ECDSA tss wallets, parameter `apiVersion` must be `full`.');
+    }
+    else if (wallet.multisigTypeVersion() === 'MPCv2') {
+        (0, assert_1.default)(requestedApiVersion === 'full', 'For EdDSA MPCv2 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' || wallet.multisigTypeVersion() === 'MPCv2') {
+        return 'full';
+    }
+    else if (wallet.type() === 'hot') {
+        // default to lite for hot eddsa tss wallets (v1 only)
+        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":"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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"]}

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

@@ -0,0 +1,161 @@
+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;
+    minValue: t.UnknownC;
+    minConfirms: t.UnknownC;
+    maxValue: t.UnknownC;
+    targetWalletUnspents: t.UnknownC;
+    strategy: t.UnknownC;
+    strategyAllowFallback: t.UnknownC;
+    noSplitChange: t.UnknownC;
+    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;
+    }>>;
+    qr: t.BooleanC;
+}>;
+export declare const BuildParamsStacks: t.PartialC<{
+    contractName: t.UnknownC;
+    functionName: t.UnknownC;
+    functionArgs: t.UnknownC;
+}>;
+export declare const SbtcWithdrawParams: t.PartialC<{
+    amount: t.StringC;
+    btcAddress: t.StringC;
+    maxFee: t.StringC;
+}>;
+export declare const BuildParamsSbtc: t.PartialC<{
+    sbtcWithdrawParams: t.PartialC<{
+        amount: t.StringC;
+        btcAddress: t.StringC;
+        maxFee: t.StringC;
+    }>;
+    sbtcDepositParams: t.UnknownC;
+}>;
+export declare const BuildParamsOffchain: t.PartialC<{
+    idfSignedTimestamp: t.UnknownC;
+    idfVersion: t.UnknownC;
+    idfUserId: t.UnknownC;
+}>;
+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;
+    minValue: t.UnknownC;
+    minConfirms: t.UnknownC;
+    maxValue: t.UnknownC;
+    targetWalletUnspents: t.UnknownC;
+    strategy: t.UnknownC;
+    strategyAllowFallback: t.UnknownC;
+    noSplitChange: t.UnknownC;
+    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;
+    }>>;
+    qr: t.BooleanC;
+}>, t.PartialC<{
+    contractName: t.UnknownC;
+    functionName: t.UnknownC;
+    functionArgs: t.UnknownC;
+}>, t.PartialC<{
+    sbtcWithdrawParams: t.PartialC<{
+        amount: t.StringC;
+        btcAddress: t.StringC;
+        maxFee: t.StringC;
+    }>;
+    sbtcDepositParams: t.UnknownC;
+}>, t.PartialC<{
+    idfSignedTimestamp: t.UnknownC;
+    idfVersion: t.UnknownC;
+    idfUserId: t.UnknownC;
+}>, t.PartialC<{
+    apiVersion: t.UnknownC;
+    consolidateAddresses: t.UnknownC;
+    consolidateId: t.UnknownC;
+    comment: t.StringC;
+    delayMs: t.UnknownC;
+    fee: t.UnknownC;
+    feeRate: t.UnknownC;
+    feeMultiplier: t.UnknownC;
+    enableTokens: t.UnknownC;
+    gasLimit: t.UnknownC;
+    gasPrice: t.UnknownC;
+    hopParams: t.UnknownC;
+    instant: t.UnknownC;
+    lastLedgerSequence: t.UnknownC;
+    ledgerSequenceDelta: t.UnknownC;
+    maxFee: t.UnknownC;
+    maxFeeRate: t.UnknownC;
+    memo: t.UnknownC;
+    transferId: t.UnknownC;
+    message: t.UnknownC;
+    numBlocks: t.UnknownC;
+    nonce: t.UnknownC;
+    pendingApprovalId: t.UnknownC;
+    preview: t.UnknownC;
+    previewPendingTxs: t.UnknownC;
+    senderAddress: t.UnknownC;
+    receiveAddress: t.UnknownC;
+    recipients: t.UnknownC;
+    reservation: t.UnknownC;
+    refundOptions: t.UnknownC;
+    sequenceId: t.UnknownC;
+    sourceChain: t.UnknownC;
+    destinationChain: t.UnknownC;
+    trustlines: t.UnknownC;
+    type: t.UnknownC;
+    limit: t.UnknownC;
+    timeBounds: t.UnknownC;
+    startTime: t.UnknownC;
+    stateProofKey: t.UnknownC;
+    nonParticipation: t.UnknownC;
+    validFromBlock: t.UnknownC;
+    validToBlock: t.UnknownC;
+    messageKey: t.UnknownC;
+    stakingParams: t.UnknownC;
+    stakingOptions: t.UnknownC;
+    unstakingOptions: t.UnknownC;
+    eip1559: t.UnknownC;
+    keyregTxBase64: t.UnknownC;
+    closeRemainderTo: t.UnknownC;
+    tokenName: t.UnknownC;
+    prebuildTx: t.UnknownC;
+    emergency: t.UnknownC;
+    solInstructions: t.UnknownC;
+    solVersionedTransactionData: t.UnknownC;
+    aptosCustomTransactionParams: t.UnknownC;
+    isTestTransaction: t.UnknownC;
+    feeToken: t.UnknownC;
+    bridgingParams: t.UnknownC;
+}>]>>;
+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

@@ -0,0 +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,aAAa;;;EAGxB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B1B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;EAI5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;EAI7B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;EAG1B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAyEvB,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

@@ -0,0 +1,168 @@
+"use strict";
+/* eslint no-redeclare: off */
+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.buildParamKeys = exports.BuildParams = exports.BuildParamsOffchain = exports.BuildParamsSbtc = exports.SbtcWithdrawParams = 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,
+    /* the change address type */
+    changeAddressType: t.unknown,
+    /* a fixed change address */
+    changeAddress: t.unknown,
+    allowExternalChangeAddress: t.boolean,
+    cpfpFeeRate: t.unknown,
+    cpfpTxIds: t.unknown,
+    unspents: t.unknown,
+    minValue: t.unknown,
+    minConfirms: t.unknown,
+    maxValue: t.unknown,
+    targetWalletUnspents: t.unknown,
+    /* unspent selection strategy */
+    strategy: t.unknown,
+    strategyAllowFallback: t.unknown,
+    noSplitChange: t.unknown,
+    smallestChangeSplitSize: t.unknown,
+    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),
+    qr: t.boolean,
+});
+exports.BuildParamsStacks = t.partial({
+    contractName: t.unknown,
+    functionName: t.unknown,
+    functionArgs: t.unknown,
+});
+exports.SbtcWithdrawParams = t.partial({
+    amount: t.string,
+    btcAddress: t.string,
+    maxFee: t.string,
+});
+exports.BuildParamsSbtc = t.partial({
+    sbtcWithdrawParams: exports.SbtcWithdrawParams,
+    sbtcDepositParams: t.unknown,
+});
+exports.BuildParamsOffchain = t.partial({
+    idfSignedTimestamp: t.unknown,
+    idfVersion: t.unknown,
+    idfUserId: t.unknown,
+});
+exports.BuildParams = t.exact(t.intersection([
+    exports.BuildParamsUTXO,
+    exports.BuildParamsStacks,
+    exports.BuildParamsSbtc,
+    exports.BuildParamsOffchain,
+    t.partial({
+        apiVersion: t.unknown,
+        consolidateAddresses: t.unknown,
+        consolidateId: t.unknown,
+        comment: t.string,
+        delayMs: t.unknown,
+        fee: t.unknown,
+        feeRate: t.unknown,
+        feeMultiplier: t.unknown,
+        enableTokens: t.unknown,
+        gasLimit: t.unknown,
+        gasPrice: t.unknown,
+        hopParams: t.unknown,
+        instant: t.unknown,
+        lastLedgerSequence: t.unknown,
+        ledgerSequenceDelta: t.unknown,
+        maxFee: t.unknown,
+        maxFeeRate: t.unknown,
+        memo: t.unknown,
+        transferId: t.unknown,
+        message: t.unknown,
+        numBlocks: t.unknown,
+        nonce: t.unknown,
+        pendingApprovalId: t.unknown,
+        preview: t.unknown,
+        previewPendingTxs: t.unknown,
+        senderAddress: t.unknown,
+        receiveAddress: t.unknown,
+        recipients: t.unknown,
+        reservation: t.unknown,
+        refundOptions: t.unknown,
+        sequenceId: t.unknown,
+        sourceChain: t.unknown,
+        destinationChain: t.unknown,
+        trustlines: t.unknown,
+        type: t.unknown,
+        limit: t.unknown,
+        timeBounds: t.unknown,
+        startTime: t.unknown,
+        stateProofKey: t.unknown,
+        nonParticipation: t.unknown,
+        validFromBlock: t.unknown,
+        validToBlock: t.unknown,
+        messageKey: t.unknown,
+        stakingParams: t.unknown,
+        stakingOptions: t.unknown,
+        unstakingOptions: t.unknown,
+        eip1559: t.unknown,
+        keyregTxBase64: t.unknown,
+        closeRemainderTo: t.unknown,
+        tokenName: t.unknown,
+        prebuildTx: t.unknown,
+        // 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,
+        // Bridging parameters for cross-chain operations (e.g., BTC to sBTC)
+        bridgingParams: t.unknown,
+    }),
+]));
+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  qr: t.boolean,\n});\n\nexport const BuildParamsStacks = t.partial({\n  contractName: t.unknown,\n  functionName: t.unknown,\n  functionArgs: t.unknown,\n});\n\nexport const SbtcWithdrawParams = t.partial({\n  amount: t.string,\n  btcAddress: t.string,\n  maxFee: t.string,\n});\n\nexport const BuildParamsSbtc = t.partial({\n  sbtcWithdrawParams: SbtcWithdrawParams,\n  sbtcDepositParams: 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    BuildParamsSbtc,\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      // Bridging parameters for cross-chain operations (e.g., BTC to sBTC)\n      bridgingParams: t.unknown,\n    }),\n  ])\n);\n\nexport type BuildParams = t.TypeOf<typeof BuildParams>;\nexport const buildParamKeys = getCodecProperties(BuildParams);\n"]}