@bitgo-beta/sdk-coin-etc 1.2.3-alpha.171 → 1.2.3-alpha.172

package/CHANGELOG.md

@@ -3,10 +3,6 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [2.0.29](https://github.com/BitGo/BitGoJS/compare/@bitgo/sdk-coin-etc@2.0.28...@bitgo/sdk-coin-etc@2.0.29) (2024-08-07)
-
-**Note:** Version bump only for package @bitgo/sdk-coin-etc
-
 ## [2.0.28](https://github.com/BitGo/BitGoJS/compare/@bitgo/sdk-coin-etc@2.0.27...@bitgo/sdk-coin-etc@2.0.28) (2024-07-30)
 
 **Note:** Version bump only for package @bitgo/sdk-coin-etc

package/dist/src/etc.d.ts

@@ -1,14 +1,94 @@
+/// <reference types="node" />
 /**
  * @prettier
  */
-import { AbstractEthLikeCoin } from '@bitgo-beta/abstract-eth';
-import { BaseCoin, BitGoBase } from '@bitgo-beta/sdk-core';
-import { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
+import { AbstractEthLikeCoin, OfflineVaultTxInfo, RecoverOptions, RecoveryInfo } from '@bitgo-beta/abstract-eth';
+import { BaseCoin, BitGoBase, Recipient } from '@bitgo-beta/sdk-core';
+import { BaseCoin as StaticsBaseCoin, EthereumNetwork as EthLikeNetwork } from '@bitgo-beta/statics';
 import { TransactionBuilder } from './lib';
 export declare class Etc extends AbstractEthLikeCoin {
+    readonly staticsCoin?: Readonly<StaticsBaseCoin>;
+    protected readonly sendMethodName: 'sendMultiSig' | 'sendMultiSigToken';
     protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
     static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
     isValidPub(pub: string): boolean;
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param params
+     * @param {string} params.userKey - [encrypted] xprv
+     * @param {string} params.backupKey - [encrypted] xprv or xpub if the xprv is held by a KRS provider
+     * @param {string} params.walletPassphrase - used to decrypt userKey and backupKey
+     * @param {string} params.walletContractAddress - the ETH address of the wallet contract
+     * @param {string} params.krsProvider - necessary if backup key is held by KRS
+     * @param {string} params.recoveryDestination - target address to send recovered funds to
+     * @param {string} params.bitgoFeeAddress - wrong chain wallet fee address for evm based cross chain recovery txn
+     * @param {string} params.bitgoDestinationAddress - target bitgo address where fee will be sent for evm based cross chain recovery txn
+     */
+    recover(params: RecoverOptions): Promise<RecoveryInfo | OfflineVaultTxInfo>;
     protected getTransactionBuilder(): TransactionBuilder;
+    /**
+     * Query explorer for the balance of an address
+     * @param {String} address - the ETHLike address
+     * @returns {BigNumber} address balance
+     */
+    queryAddressBalance(address: string): Promise<any>;
+    /**
+     * Make a query to Arbiscan for information such as balance, token balance, solidity calls
+     * @param {Object} query key-value pairs of parameters to append after /api
+     * @returns {Promise<Object>} response from Arbiscan
+     */
+    recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<Record<string, unknown>>;
+    /**
+     * Method to validate recovery params
+     * @param {RecoverOptions} params
+     * @returns {void}
+     */
+    validateRecoveryParams(params: RecoverOptions): void;
+    /**
+     * Queries public block explorer to get the next ETHLike coin's nonce that should be used for the given ETH address
+     * @param {string} address
+     * @returns {Promise<number>}
+     */
+    getAddressNonce(address: string): Promise<number>;
+    /**
+     * Queries the contract (via explorer API) for the next sequence ID
+     * @param {String} address - address of the contract
+     * @returns {Promise<Number>} sequence ID
+     */
+    querySequenceId(address: string): Promise<number>;
+    /**
+     * Check whether the gas price passed in by user are within our max and min bounds
+     * If they are not set, set them to the defaults
+     * @param {number} userGasPrice - user defined gas price
+     * @returns {number} the gas price to use for this transaction
+     */
+    setGasPrice(userGasPrice?: number): number;
+    /**
+     * Check whether gas limit passed in by user are within our max and min bounds
+     * If they are not set, set them to the defaults
+     * @param {number} userGasLimit user defined gas limit
+     * @returns {number} the gas limit to use for this transaction
+     */
+    setGasLimit(userGasLimit?: number): number;
+    /**
+     * @param {Recipient[]} recipients - the recipients of the transaction
+     * @param {number} expireTime - the expire time of the transaction
+     * @param {number} contractSequenceId - the contract sequence id of the transaction
+     * @returns {string}
+     */
+    getOperationSha3ForExecuteAndConfirm(recipients: Recipient[], expireTime: number, contractSequenceId: number): string;
+    /**
+     * Get transfer operation for coin
+     * @param {Recipient} recipient - recipient info
+     * @param {number} expireTime - expiry time
+     * @param {number} contractSequenceId - sequence id
+     * @returns {Array} operation array
+     */
+    getOperation(recipient: Recipient, expireTime: number, contractSequenceId: number): (string | Buffer)[][];
+    /**
+     * Method to return the coin's network object
+     * @returns {EthLikeNetwork | undefined}
+     */
+    getNetwork(): EthLikeNetwork | undefined;
 }
 //# sourceMappingURL=etc.d.ts.map

package/dist/src/etc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"etc.d.ts","sourceRoot":"","sources":["../../src/etc.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAS,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAW,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAEpD,qBAAa,GAAI,SAAQ,mBAAmB;IAC1C,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAI/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAUhC,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;CAGtD"}
+{"version":3,"file":"etc.d.ts","sourceRoot":"","sources":["../../src/etc.ts"],"names":[],"mappings":";AAAA;;GAEG;AACH,OAAO,EACL,mBAAmB,EAEnB,kBAAkB,EAElB,cAAc,EAEd,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAoC,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACxG,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAS,eAAe,IAAI,cAAc,EAAiB,MAAM,qBAAqB,CAAC;AAC3H,OAAO,EAAE,kBAAkB,EAA0C,MAAM,OAAO,CAAC;AAKnF,qBAAa,GAAI,SAAQ,mBAAmB;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IACjD,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,cAAc,GAAG,mBAAmB,CAAC;IAExE,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAU/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAUhC;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,GAAG,kBAAkB,CAAC;IAsKjF,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;IAIrD;;;;OAIG;IACG,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAYxD;;;;OAIG;IACG,+BAA+B,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAMtG;;;;OAIG;IACH,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAsBpD;;;;OAIG;IACG,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAqBvD;;;;OAIG;IACG,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAuBvD;;;;;OAKG;IACH,WAAW,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM;IAY1C;;;;;OAKG;IACH,WAAW,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM;IAY1C;;;;;OAKG;IACH,oCAAoC,CAClC,UAAU,EAAE,SAAS,EAAE,EACvB,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,MAAM,GACzB,MAAM;IA+CT;;;;;;OAMG;IACH,YAAY,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE;IAezG;;;OAGG;IACH,UAAU,IAAI,cAAc,GAAG,SAAS;CAGzC"}

package/dist/src/etc.js

@@ -1,15 +1,47 @@
 "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 (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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Etc = void 0;
 /**
  * @prettier
  */
 const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
 const statics_1 = require("@bitgo-beta/statics");
 const lib_1 = require("./lib");
+const _ = __importStar(require("lodash"));
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const bignumber_js_1 = require("bignumber.js");
 class Etc extends abstract_eth_1.AbstractEthLikeCoin {
     constructor(bitgo, staticsCoin) {
         super(bitgo, staticsCoin);
+        if (!staticsCoin) {
+            throw new Error('missing required constructor parameter staticsCoin');
+        }
+        this.staticsCoin = staticsCoin;
+        this.sendMethodName = 'sendMultiSig';
     }
     static createInstance(bitgo, staticsCoin) {
         return new Etc(bitgo, staticsCoin);
@@ -24,9 +56,378 @@ class Etc extends abstract_eth_1.AbstractEthLikeCoin {
         }
         return valid;
     }
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param params
+     * @param {string} params.userKey - [encrypted] xprv
+     * @param {string} params.backupKey - [encrypted] xprv or xpub if the xprv is held by a KRS provider
+     * @param {string} params.walletPassphrase - used to decrypt userKey and backupKey
+     * @param {string} params.walletContractAddress - the ETH address of the wallet contract
+     * @param {string} params.krsProvider - necessary if backup key is held by KRS
+     * @param {string} params.recoveryDestination - target address to send recovered funds to
+     * @param {string} params.bitgoFeeAddress - wrong chain wallet fee address for evm based cross chain recovery txn
+     * @param {string} params.bitgoDestinationAddress - target bitgo address where fee will be sent for evm based cross chain recovery txn
+     */
+    async recover(params) {
+        var _a, _b;
+        this.validateRecoveryParams(params);
+        const isUnsignedSweep = (0, sdk_core_1.getIsUnsignedSweep)(params);
+        // Clean up whitespace from entered values
+        let userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        const gasLimit = new abstract_eth_1.optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));
+        const gasPrice = params.eip1559
+            ? new abstract_eth_1.optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)
+            : new abstract_eth_1.optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));
+        if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {
+            try {
+                userKey = this.bitgo.decrypt({
+                    input: userKey,
+                    password: params.walletPassphrase,
+                });
+            }
+            catch (e) {
+                throw new Error(`Error decrypting user keychain: ${e.message}`);
+            }
+        }
+        let backupKeyAddress;
+        let backupSigningKey;
+        if (isUnsignedSweep) {
+            const backupHDNode = utxo_lib_1.bip32.fromBase58(backupKey);
+            backupSigningKey = backupHDNode.publicKey;
+            backupKeyAddress = `0x${abstract_eth_1.optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`;
+        }
+        else {
+            // Decrypt backup private key and get address
+            let backupPrv;
+            try {
+                backupPrv = this.bitgo.decrypt({
+                    input: backupKey,
+                    password: params.walletPassphrase,
+                });
+            }
+            catch (e) {
+                throw new Error(`Error decrypting backup keychain: ${e.message}`);
+            }
+            const keyPair = new lib_1.KeyPair({ prv: backupPrv });
+            backupSigningKey = keyPair.getKeys().prv;
+            if (!backupSigningKey) {
+                throw new Error('no private key');
+            }
+            backupKeyAddress = keyPair.getAddress();
+        }
+        const backupKeyNonce = await this.getAddressNonce(backupKeyAddress);
+        // get balance of backupKey to ensure funds are available to pay fees
+        const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress);
+        const totalGasNeeded = gasPrice.mul(gasLimit);
+        const weiToGwei = 10 ** 9;
+        if (backupKeyBalance.lt(totalGasNeeded)) {
+            throw new Error(`Backup key address ${backupKeyAddress} has balance ${(backupKeyBalance / weiToGwei).toString()} Gwei.` +
+                `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +
+                ` Gwei to perform recoveries. Try sending some funds to this address then retry.`);
+        }
+        // get balance of wallet
+        const txAmount = await this.queryAddressBalance(params.walletContractAddress);
+        if (new bignumber_js_1.BigNumber(txAmount).isLessThanOrEqualTo(0)) {
+            throw new Error('Wallet does not have enough funds to recover');
+        }
+        // build recipients object
+        const recipients = [
+            {
+                address: params.recoveryDestination,
+                amount: txAmount.toString(10),
+            },
+        ];
+        // Get sequence ID using contract call
+        // we need to wait between making two explorer api calls to avoid getting banned
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const sequenceId = await this.querySequenceId(params.walletContractAddress);
+        let operationHash, signature;
+        // Get operation hash and sign it
+        if (!isUnsignedSweep) {
+            operationHash = this.getOperationSha3ForExecuteAndConfirm(recipients, (0, abstract_eth_1.getDefaultExpireTime)(), sequenceId);
+            signature = sdk_core_1.Util.ethSignMsgHash(operationHash, sdk_core_1.Util.xprvToEthPrivateKey(userKey));
+            try {
+                sdk_core_1.Util.ecRecoverEthAddress(operationHash, signature);
+            }
+            catch (e) {
+                throw new Error('Invalid signature');
+            }
+        }
+        // Build unsigned transaction
+        const txInfo = {
+            recipient: recipients[0],
+            expireTime: (0, abstract_eth_1.getDefaultExpireTime)(),
+            contractSequenceId: sequenceId,
+            operationHash: operationHash,
+            signature: signature,
+            gasLimit: gasLimit.toString(10),
+        };
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.counter(backupKeyNonce);
+        txBuilder.contract(params.walletContractAddress);
+        let txFee;
+        if (params.eip1559) {
+            txFee = {
+                eip1559: {
+                    maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,
+                    maxFeePerGas: params.eip1559.maxFeePerGas,
+                },
+            };
+        }
+        else {
+            txFee = { fee: gasPrice.toString() };
+        }
+        txBuilder.fee({
+            ...txFee,
+            gasLimit: gasLimit.toString(),
+        });
+        const transferBuilder = txBuilder.transfer();
+        transferBuilder
+            .coin((_a = this.staticsCoin) === null || _a === void 0 ? void 0 : _a.name)
+            .amount(recipients[0].amount)
+            .contractSequenceId(sequenceId)
+            .expirationTime((0, abstract_eth_1.getDefaultExpireTime)())
+            .to(params.recoveryDestination);
+        const tx = await txBuilder.build();
+        if (isUnsignedSweep) {
+            const response = {
+                txHex: tx.toBroadcastFormat(),
+                userKey,
+                backupKey,
+                coin: this.getChain(),
+                gasPrice: abstract_eth_1.optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),
+                gasLimit,
+                recipients: [txInfo.recipient],
+                walletContractAddress: tx.toJson().to,
+                amount: txInfo.recipient.amount,
+                backupKeyNonce,
+                eip1559: params.eip1559,
+            };
+            _.extend(response, txInfo);
+            response.nextContractSequenceId = response.contractSequenceId;
+            return response;
+        }
+        // sign the transaction
+        txBuilder
+            .transfer()
+            .coin((_b = this.staticsCoin) === null || _b === void 0 ? void 0 : _b.name)
+            .key(new lib_1.KeyPair({ prv: userKey }).getKeys().prv);
+        txBuilder.sign({ key: backupSigningKey });
+        const signedTx = await txBuilder.build();
+        return {
+            id: signedTx.toJson().id,
+            tx: signedTx.toBroadcastFormat(),
+        };
+    }
     getTransactionBuilder() {
         return new lib_1.TransactionBuilder(statics_1.coins.get(this.getBaseChain()));
     }
+    /**
+     * Query explorer for the balance of an address
+     * @param {String} address - the ETHLike address
+     * @returns {BigNumber} address balance
+     */
+    async queryAddressBalance(address) {
+        const result = await this.recoveryBlockchainExplorerQuery({
+            module: 'account',
+            action: 'balance',
+            address: address,
+        });
+        // throw if the result does not exist or the result is not a valid number
+        if (!result || !result.result || (typeof result.result === 'number' && isNaN(result.result))) {
+            throw new Error(`Could not obtain address balance for ${address} from the explorer, got: ${result.result}`);
+        }
+        return new abstract_eth_1.optionalDeps.ethUtil.BN(result.result, 10);
+    }
+    /**
+     * Make a query to Arbiscan for information such as balance, token balance, solidity calls
+     * @param {Object} query key-value pairs of parameters to append after /api
+     * @returns {Promise<Object>} response from Arbiscan
+     */
+    async recoveryBlockchainExplorerQuery(query) {
+        // const apiToken = common.Environments[this.bitgo.getEnv()].arbiscanApiToken;
+        const explorerUrl = sdk_core_1.common.Environments[this.bitgo.getEnv()].etcNodeUrl;
+        return await (0, abstract_eth_1.recoveryBlockchainExplorerQuery)(query, explorerUrl);
+    }
+    /**
+     * Method to validate recovery params
+     * @param {RecoverOptions} params
+     * @returns {void}
+     */
+    validateRecoveryParams(params) {
+        if (_.isUndefined(params.userKey)) {
+            throw new Error('missing userKey');
+        }
+        if (_.isUndefined(params.backupKey)) {
+            throw new Error('missing backupKey');
+        }
+        if (_.isUndefined(params.walletPassphrase) && !params.userKey.startsWith('xpub') && !params.isTss) {
+            throw new Error('missing wallet passphrase');
+        }
+        if (_.isUndefined(params.walletContractAddress) || !this.isValidAddress(params.walletContractAddress)) {
+            throw new Error('invalid walletContractAddress');
+        }
+        if (_.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+    }
+    /**
+     * Queries public block explorer to get the next ETHLike coin's nonce that should be used for the given ETH address
+     * @param {string} address
+     * @returns {Promise<number>}
+     */
+    async getAddressNonce(address) {
+        // Get nonce for backup key (should be 0)
+        let nonce = 0;
+        const result = await this.recoveryBlockchainExplorerQuery({
+            module: 'account',
+            action: 'txlist',
+            address,
+        });
+        if (!result || !Array.isArray(result.result)) {
+            throw new Error('Unable to find next nonce from Etherscan, got: ' + JSON.stringify(result));
+        }
+        const backupKeyTxList = result.result;
+        if (backupKeyTxList.length > 0) {
+            // Calculate last nonce used
+            const outgoingTxs = backupKeyTxList.filter((tx) => tx.from === address);
+            nonce = outgoingTxs.length;
+        }
+        return nonce;
+    }
+    /**
+     * Queries the contract (via explorer API) for the next sequence ID
+     * @param {String} address - address of the contract
+     * @returns {Promise<Number>} sequence ID
+     */
+    async querySequenceId(address) {
+        // Get sequence ID using contract call
+        const sequenceIdMethodSignature = abstract_eth_1.optionalDeps.ethAbi.methodID('getNextSequenceId', []);
+        const sequenceIdArgs = abstract_eth_1.optionalDeps.ethAbi.rawEncode([], []);
+        const sequenceIdData = Buffer.concat([sequenceIdMethodSignature, sequenceIdArgs]).toString('hex');
+        const result = await this.recoveryBlockchainExplorerQuery({
+            module: 'proxy',
+            action: 'eth_call',
+            to: address,
+            data: sequenceIdData,
+            tag: 'latest',
+        });
+        if (!result || !result.result) {
+            throw new Error('Could not obtain sequence ID from explorer, got: ' + result.result);
+        }
+        const sequenceIdHex = result.result;
+        if (typeof sequenceIdHex === 'string') {
+            return new abstract_eth_1.optionalDeps.ethUtil.BN(sequenceIdHex.slice(2), 16).toNumber();
+        }
+        else {
+            throw new Error('Expected sequenceIdHex to be a string');
+        }
+    }
+    /**
+     * Check whether the gas price passed in by user are within our max and min bounds
+     * If they are not set, set them to the defaults
+     * @param {number} userGasPrice - user defined gas price
+     * @returns {number} the gas price to use for this transaction
+     */
+    setGasPrice(userGasPrice) {
+        if (!userGasPrice) {
+            return statics_1.ethGasConfigs.defaultGasPrice;
+        }
+        const gasPriceMax = statics_1.ethGasConfigs.maximumGasPrice;
+        const gasPriceMin = statics_1.ethGasConfigs.minimumGasPrice;
+        if (userGasPrice < gasPriceMin || userGasPrice > gasPriceMax) {
+            throw new Error(`Gas price must be between ${gasPriceMin} and ${gasPriceMax}`);
+        }
+        return userGasPrice;
+    }
+    /**
+     * Check whether gas limit passed in by user are within our max and min bounds
+     * If they are not set, set them to the defaults
+     * @param {number} userGasLimit user defined gas limit
+     * @returns {number} the gas limit to use for this transaction
+     */
+    setGasLimit(userGasLimit) {
+        if (!userGasLimit) {
+            return statics_1.ethGasConfigs.defaultGasLimit;
+        }
+        const gasLimitMax = statics_1.ethGasConfigs.maximumGasLimit;
+        const gasLimitMin = statics_1.ethGasConfigs.minimumGasLimit;
+        if (userGasLimit < gasLimitMin || userGasLimit > gasLimitMax) {
+            throw new Error(`Gas limit must be between ${gasLimitMin} and ${gasLimitMax}`);
+        }
+        return userGasLimit;
+    }
+    /**
+     * @param {Recipient[]} recipients - the recipients of the transaction
+     * @param {number} expireTime - the expire time of the transaction
+     * @param {number} contractSequenceId - the contract sequence id of the transaction
+     * @returns {string}
+     */
+    getOperationSha3ForExecuteAndConfirm(recipients, expireTime, contractSequenceId) {
+        if (!recipients || !Array.isArray(recipients)) {
+            throw new Error('expecting array of recipients');
+        }
+        // Right now we only support 1 recipient
+        if (recipients.length !== 1) {
+            throw new Error('must send to exactly 1 recipient');
+        }
+        if (!_.isNumber(expireTime)) {
+            throw new Error('expireTime must be number of seconds since epoch');
+        }
+        if (!_.isNumber(contractSequenceId)) {
+            throw new Error('contractSequenceId must be number');
+        }
+        // Check inputs
+        recipients.forEach(function (recipient) {
+            if (!_.isString(recipient.address) ||
+                !abstract_eth_1.optionalDeps.ethUtil.isValidAddress(abstract_eth_1.optionalDeps.ethUtil.addHexPrefix(recipient.address))) {
+                throw new Error('Invalid address: ' + recipient.address);
+            }
+            let amount;
+            try {
+                amount = new bignumber_js_1.BigNumber(recipient.amount);
+            }
+            catch (e) {
+                throw new Error('Invalid amount for: ' + recipient.address + ' - should be numeric');
+            }
+            recipient.amount = amount.toFixed(0);
+            if (recipient.data && !_.isString(recipient.data)) {
+                throw new Error('Data for recipient ' + recipient.address + ' - should be of type hex string');
+            }
+        });
+        const recipient = recipients[0];
+        return abstract_eth_1.optionalDeps.ethUtil.bufferToHex(abstract_eth_1.optionalDeps.ethAbi.soliditySHA3(...this.getOperation(recipient, expireTime, contractSequenceId)));
+    }
+    /**
+     * Get transfer operation for coin
+     * @param {Recipient} recipient - recipient info
+     * @param {number} expireTime - expiry time
+     * @param {number} contractSequenceId - sequence id
+     * @returns {Array} operation array
+     */
+    getOperation(recipient, expireTime, contractSequenceId) {
+        const network = this.getNetwork();
+        return [
+            ['string', 'address', 'uint', 'bytes', 'uint', 'uint'],
+            [
+                network.nativeCoinOperationHashPrefix,
+                new abstract_eth_1.optionalDeps.ethUtil.BN(abstract_eth_1.optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),
+                recipient.amount,
+                Buffer.from(abstract_eth_1.optionalDeps.ethUtil.stripHexPrefix(abstract_eth_1.optionalDeps.ethUtil.padToEven(recipient.data || '')), 'hex'),
+                expireTime,
+                contractSequenceId,
+            ],
+        ];
+    }
+    /**
+     * Method to return the coin's network object
+     * @returns {EthLikeNetwork | undefined}
+     */
+    getNetwork() {
+        var _a;
+        return (_a = this.staticsCoin) === null || _a === void 0 ? void 0 : _a.network;
+    }
 }
 exports.Etc = Etc;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"etc.js","sourceRoot":"","sources":["../../src/etc.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport {\n  AbstractEthLikeCoin,\n  getDefaultExpireTime,\n  OfflineVaultTxInfo,\n  optionalDeps,\n  RecoverOptions,\n  recoveryBlockchainExplorerQuery,\n  RecoveryInfo,\n} from '@bitgo-beta/abstract-eth';\nimport { BaseCoin, BitGoBase, common, getIsUnsignedSweep, Util, Recipient } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as StaticsBaseCoin, coins, EthereumNetwork as EthLikeNetwork, ethGasConfigs } from '@bitgo-beta/statics';\nimport { TransactionBuilder, KeyPair as KeyPairLib, TransferBuilder } from './lib';\nimport * as _ from 'lodash';\nimport { bip32 } from '@bitgo-beta/utxo-lib';\nimport { BigNumber } from 'bignumber.js';\n\nexport class Etc extends AbstractEthLikeCoin {\n  readonly staticsCoin?: Readonly<StaticsBaseCoin>;\n  protected readonly sendMethodName: 'sendMultiSig' | 'sendMultiSigToken';\n\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo, staticsCoin);\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this.staticsCoin = staticsCoin;\n    this.sendMethodName = 'sendMultiSig';\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Etc(bitgo, staticsCoin);\n  }\n\n  isValidPub(pub: string): boolean {\n    let valid = true;\n    try {\n      new KeyPairLib({ pub });\n    } catch (e) {\n      valid = false;\n    }\n    return valid;\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param params\n   * @param {string} params.userKey - [encrypted] xprv\n   * @param {string} params.backupKey - [encrypted] xprv or xpub if the xprv is held by a KRS provider\n   * @param {string} params.walletPassphrase - used to decrypt userKey and backupKey\n   * @param {string} params.walletContractAddress - the ETH address of the wallet contract\n   * @param {string} params.krsProvider - necessary if backup key is held by KRS\n   * @param {string} params.recoveryDestination - target address to send recovered funds to\n   * @param {string} params.bitgoFeeAddress - wrong chain wallet fee address for evm based cross chain recovery txn\n   * @param {string} params.bitgoDestinationAddress - target bitgo address where fee will be sent for evm based cross chain recovery txn\n   */\n  async recover(params: RecoverOptions): Promise<RecoveryInfo | OfflineVaultTxInfo> {\n    this.validateRecoveryParams(params);\n    const isUnsignedSweep = getIsUnsignedSweep(params);\n\n    // Clean up whitespace from entered values\n    let userKey = params.userKey.replace(/\\s/g, '');\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n    const gasLimit = new optionalDeps.ethUtil.BN(this.setGasLimit(params.gasLimit));\n    const gasPrice = params.eip1559\n      ? new optionalDeps.ethUtil.BN(params.eip1559.maxFeePerGas)\n      : new optionalDeps.ethUtil.BN(this.setGasPrice(params.gasPrice));\n\n    if (!userKey.startsWith('xpub') && !userKey.startsWith('xprv')) {\n      try {\n        userKey = this.bitgo.decrypt({\n          input: userKey,\n          password: params.walletPassphrase,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting user keychain: ${e.message}`);\n      }\n    }\n    let backupKeyAddress;\n    let backupSigningKey;\n    if (isUnsignedSweep) {\n      const backupHDNode = bip32.fromBase58(backupKey);\n      backupSigningKey = backupHDNode.publicKey;\n      backupKeyAddress = `0x${optionalDeps.ethUtil.publicToAddress(backupSigningKey, true).toString('hex')}`;\n    } else {\n      // Decrypt backup private key and get address\n      let backupPrv;\n\n      try {\n        backupPrv = this.bitgo.decrypt({\n          input: backupKey,\n          password: params.walletPassphrase,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting backup keychain: ${e.message}`);\n      }\n\n      const keyPair = new KeyPairLib({ prv: backupPrv });\n      backupSigningKey = keyPair.getKeys().prv;\n      if (!backupSigningKey) {\n        throw new Error('no private key');\n      }\n      backupKeyAddress = keyPair.getAddress();\n    }\n\n    const backupKeyNonce = await this.getAddressNonce(backupKeyAddress);\n    // get balance of backupKey to ensure funds are available to pay fees\n    const backupKeyBalance = await this.queryAddressBalance(backupKeyAddress);\n    const totalGasNeeded = gasPrice.mul(gasLimit);\n\n    const weiToGwei = 10 ** 9;\n    if (backupKeyBalance.lt(totalGasNeeded)) {\n      throw new Error(\n        `Backup key address ${backupKeyAddress} has balance ${(backupKeyBalance / weiToGwei).toString()} Gwei.` +\n          `This address must have a balance of at least ${(totalGasNeeded / weiToGwei).toString()}` +\n          ` Gwei to perform recoveries. Try sending some funds to this address then retry.`\n      );\n    }\n\n    // get balance of wallet\n    const txAmount = await this.queryAddressBalance(params.walletContractAddress);\n    if (new BigNumber(txAmount).isLessThanOrEqualTo(0)) {\n      throw new Error('Wallet does not have enough funds to recover');\n    }\n\n    // build recipients object\n    const recipients = [\n      {\n        address: params.recoveryDestination,\n        amount: txAmount.toString(10),\n      },\n    ];\n\n    // Get sequence ID using contract call\n    // we need to wait between making two explorer api calls to avoid getting banned\n    await new Promise((resolve) => setTimeout(resolve, 1000));\n    const sequenceId = await this.querySequenceId(params.walletContractAddress);\n\n    let operationHash, signature;\n    // Get operation hash and sign it\n    if (!isUnsignedSweep) {\n      operationHash = this.getOperationSha3ForExecuteAndConfirm(recipients, getDefaultExpireTime(), sequenceId);\n      signature = Util.ethSignMsgHash(operationHash, Util.xprvToEthPrivateKey(userKey));\n\n      try {\n        Util.ecRecoverEthAddress(operationHash, signature);\n      } catch (e) {\n        throw new Error('Invalid signature');\n      }\n    }\n\n    // Build unsigned transaction\n    const txInfo = {\n      recipient: recipients[0],\n      expireTime: getDefaultExpireTime(),\n      contractSequenceId: sequenceId,\n      operationHash: operationHash,\n      signature: signature,\n      gasLimit: gasLimit.toString(10),\n    };\n\n    const txBuilder = this.getTransactionBuilder() as TransactionBuilder;\n    txBuilder.counter(backupKeyNonce);\n    txBuilder.contract(params.walletContractAddress);\n    let txFee;\n    if (params.eip1559) {\n      txFee = {\n        eip1559: {\n          maxPriorityFeePerGas: params.eip1559.maxPriorityFeePerGas,\n          maxFeePerGas: params.eip1559.maxFeePerGas,\n        },\n      };\n    } else {\n      txFee = { fee: gasPrice.toString() };\n    }\n    txBuilder.fee({\n      ...txFee,\n      gasLimit: gasLimit.toString(),\n    });\n    const transferBuilder = txBuilder.transfer() as TransferBuilder;\n    transferBuilder\n      .coin(this.staticsCoin?.name as string)\n      .amount(recipients[0].amount)\n      .contractSequenceId(sequenceId)\n      .expirationTime(getDefaultExpireTime())\n      .to(params.recoveryDestination);\n\n    const tx = await txBuilder.build();\n    if (isUnsignedSweep) {\n      const response: OfflineVaultTxInfo = {\n        txHex: tx.toBroadcastFormat(),\n        userKey,\n        backupKey,\n        coin: this.getChain(),\n        gasPrice: optionalDeps.ethUtil.bufferToInt(gasPrice).toFixed(),\n        gasLimit,\n        recipients: [txInfo.recipient],\n        walletContractAddress: tx.toJson().to,\n        amount: txInfo.recipient.amount,\n        backupKeyNonce,\n        eip1559: params.eip1559,\n      };\n      _.extend(response, txInfo);\n      response.nextContractSequenceId = response.contractSequenceId;\n      return response;\n    }\n\n    // sign the transaction\n    txBuilder\n      .transfer()\n      .coin(this.staticsCoin?.name as string)\n      .key(new KeyPairLib({ prv: userKey }).getKeys().prv as string);\n    txBuilder.sign({ key: backupSigningKey });\n\n    const signedTx = await txBuilder.build();\n\n    return {\n      id: signedTx.toJson().id,\n      tx: signedTx.toBroadcastFormat(),\n    };\n  }\n\n  protected getTransactionBuilder(): TransactionBuilder {\n    return new TransactionBuilder(coins.get(this.getBaseChain()));\n  }\n\n  /**\n   * Query explorer for the balance of an address\n   * @param {String} address - the ETHLike address\n   * @returns {BigNumber} address balance\n   */\n  async queryAddressBalance(address: string): Promise<any> {\n    const result = await this.recoveryBlockchainExplorerQuery({\n      module: 'account',\n      action: 'balance',\n      address: address,\n    });\n    // throw if the result does not exist or the result is not a valid number\n    if (!result || !result.result || (typeof result.result === 'number' && isNaN(result.result))) {\n      throw new Error(`Could not obtain address balance for ${address} from the explorer, got: ${result.result}`);\n    }\n    return new optionalDeps.ethUtil.BN(result.result, 10);\n  }\n  /**\n   * Make a query to Arbiscan for information such as balance, token balance, solidity calls\n   * @param {Object} query key-value pairs of parameters to append after /api\n   * @returns {Promise<Object>} response from Arbiscan\n   */\n  async recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<Record<string, unknown>> {\n    // const apiToken = common.Environments[this.bitgo.getEnv()].arbiscanApiToken;\n    const explorerUrl = common.Environments[this.bitgo.getEnv()].etcNodeUrl;\n    return await recoveryBlockchainExplorerQuery(query, explorerUrl as string);\n  }\n\n  /**\n   * Method to validate recovery params\n   * @param {RecoverOptions} params\n   * @returns {void}\n   */\n  validateRecoveryParams(params: RecoverOptions): void {\n    if (_.isUndefined(params.userKey)) {\n      throw new Error('missing userKey');\n    }\n\n    if (_.isUndefined(params.backupKey)) {\n      throw new Error('missing backupKey');\n    }\n\n    if (_.isUndefined(params.walletPassphrase) && !params.userKey.startsWith('xpub') && !params.isTss) {\n      throw new Error('missing wallet passphrase');\n    }\n\n    if (_.isUndefined(params.walletContractAddress) || !this.isValidAddress(params.walletContractAddress)) {\n      throw new Error('invalid walletContractAddress');\n    }\n\n    if (_.isUndefined(params.recoveryDestination) || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination');\n    }\n  }\n\n  /**\n   * Queries public block explorer to get the next ETHLike coin's nonce that should be used for the given ETH address\n   * @param {string} address\n   * @returns {Promise<number>}\n   */\n  async getAddressNonce(address: string): Promise<number> {\n    // Get nonce for backup key (should be 0)\n    let nonce = 0;\n\n    const result = await this.recoveryBlockchainExplorerQuery({\n      module: 'account',\n      action: 'txlist',\n      address,\n    });\n    if (!result || !Array.isArray(result.result)) {\n      throw new Error('Unable to find next nonce from Etherscan, got: ' + JSON.stringify(result));\n    }\n    const backupKeyTxList = result.result;\n    if (backupKeyTxList.length > 0) {\n      // Calculate last nonce used\n      const outgoingTxs = backupKeyTxList.filter((tx) => tx.from === address);\n      nonce = outgoingTxs.length;\n    }\n    return nonce;\n  }\n\n  /**\n   * Queries the contract (via explorer API) for the next sequence ID\n   * @param {String} address - address of the contract\n   * @returns {Promise<Number>} sequence ID\n   */\n  async querySequenceId(address: string): Promise<number> {\n    // Get sequence ID using contract call\n    const sequenceIdMethodSignature = optionalDeps.ethAbi.methodID('getNextSequenceId', []);\n    const sequenceIdArgs = optionalDeps.ethAbi.rawEncode([], []);\n    const sequenceIdData = Buffer.concat([sequenceIdMethodSignature, sequenceIdArgs]).toString('hex');\n    const result = await this.recoveryBlockchainExplorerQuery({\n      module: 'proxy',\n      action: 'eth_call',\n      to: address,\n      data: sequenceIdData,\n      tag: 'latest',\n    });\n    if (!result || !result.result) {\n      throw new Error('Could not obtain sequence ID from explorer, got: ' + result.result);\n    }\n    const sequenceIdHex = result.result;\n    if (typeof sequenceIdHex === 'string') {\n      return new optionalDeps.ethUtil.BN(sequenceIdHex.slice(2), 16).toNumber();\n    } else {\n      throw new Error('Expected sequenceIdHex to be a string');\n    }\n  }\n\n  /**\n   * Check whether the gas price passed in by user are within our max and min bounds\n   * If they are not set, set them to the defaults\n   * @param {number} userGasPrice - user defined gas price\n   * @returns {number} the gas price to use for this transaction\n   */\n  setGasPrice(userGasPrice?: number): number {\n    if (!userGasPrice) {\n      return ethGasConfigs.defaultGasPrice;\n    }\n\n    const gasPriceMax = ethGasConfigs.maximumGasPrice;\n    const gasPriceMin = ethGasConfigs.minimumGasPrice;\n    if (userGasPrice < gasPriceMin || userGasPrice > gasPriceMax) {\n      throw new Error(`Gas price must be between ${gasPriceMin} and ${gasPriceMax}`);\n    }\n    return userGasPrice;\n  }\n  /**\n   * Check whether gas limit passed in by user are within our max and min bounds\n   * If they are not set, set them to the defaults\n   * @param {number} userGasLimit user defined gas limit\n   * @returns {number} the gas limit to use for this transaction\n   */\n  setGasLimit(userGasLimit?: number): number {\n    if (!userGasLimit) {\n      return ethGasConfigs.defaultGasLimit;\n    }\n    const gasLimitMax = ethGasConfigs.maximumGasLimit;\n    const gasLimitMin = ethGasConfigs.minimumGasLimit;\n    if (userGasLimit < gasLimitMin || userGasLimit > gasLimitMax) {\n      throw new Error(`Gas limit must be between ${gasLimitMin} and ${gasLimitMax}`);\n    }\n    return userGasLimit;\n  }\n\n  /**\n   * @param {Recipient[]} recipients - the recipients of the transaction\n   * @param {number} expireTime - the expire time of the transaction\n   * @param {number} contractSequenceId - the contract sequence id of the transaction\n   * @returns {string}\n   */\n  getOperationSha3ForExecuteAndConfirm(\n    recipients: Recipient[],\n    expireTime: number,\n    contractSequenceId: number\n  ): string {\n    if (!recipients || !Array.isArray(recipients)) {\n      throw new Error('expecting array of recipients');\n    }\n\n    // Right now we only support 1 recipient\n    if (recipients.length !== 1) {\n      throw new Error('must send to exactly 1 recipient');\n    }\n\n    if (!_.isNumber(expireTime)) {\n      throw new Error('expireTime must be number of seconds since epoch');\n    }\n\n    if (!_.isNumber(contractSequenceId)) {\n      throw new Error('contractSequenceId must be number');\n    }\n\n    // Check inputs\n    recipients.forEach(function (recipient) {\n      if (\n        !_.isString(recipient.address) ||\n        !optionalDeps.ethUtil.isValidAddress(optionalDeps.ethUtil.addHexPrefix(recipient.address))\n      ) {\n        throw new Error('Invalid address: ' + recipient.address);\n      }\n\n      let amount: BigNumber;\n      try {\n        amount = new BigNumber(recipient.amount);\n      } catch (e) {\n        throw new Error('Invalid amount for: ' + recipient.address + ' - should be numeric');\n      }\n\n      recipient.amount = amount.toFixed(0);\n\n      if (recipient.data && !_.isString(recipient.data)) {\n        throw new Error('Data for recipient ' + recipient.address + ' - should be of type hex string');\n      }\n    });\n\n    const recipient = recipients[0];\n    return optionalDeps.ethUtil.bufferToHex(\n      optionalDeps.ethAbi.soliditySHA3(...this.getOperation(recipient, expireTime, contractSequenceId))\n    );\n  }\n\n  /**\n   * Get transfer operation for coin\n   * @param {Recipient} recipient - recipient info\n   * @param {number} expireTime - expiry time\n   * @param {number} contractSequenceId - sequence id\n   * @returns {Array} operation array\n   */\n  getOperation(recipient: Recipient, expireTime: number, contractSequenceId: number): (string | Buffer)[][] {\n    const network = this.getNetwork() as EthLikeNetwork;\n    return [\n      ['string', 'address', 'uint', 'bytes', 'uint', 'uint'],\n      [\n        network.nativeCoinOperationHashPrefix,\n        new optionalDeps.ethUtil.BN(optionalDeps.ethUtil.stripHexPrefix(recipient.address), 16),\n        recipient.amount,\n        Buffer.from(optionalDeps.ethUtil.stripHexPrefix(optionalDeps.ethUtil.padToEven(recipient.data || '')), 'hex'),\n        expireTime,\n        contractSequenceId,\n      ],\n    ];\n  }\n\n  /**\n   * Method to return the coin's network object\n   * @returns {EthLikeNetwork | undefined}\n   */\n  getNetwork(): EthLikeNetwork | undefined {\n    return this.staticsCoin?.network as EthLikeNetwork;\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo-beta/sdk-coin-etc",
-  "version": "1.2.3-alpha.171",
+  "version": "1.2.3-alpha.172",
   "description": "BitGo SDK coin library for Ethereum classic",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -40,16 +40,16 @@
     ]
   },
   "dependencies": {
-    "@bitgo-beta/abstract-eth": "1.2.3-alpha.173",
-    "@bitgo-beta/sdk-coin-eth": "2.4.1-alpha.173",
-    "@bitgo-beta/sdk-core": "2.4.1-alpha.173",
-    "@bitgo-beta/statics": "10.0.1-alpha.173",
+    "@bitgo-beta/abstract-eth": "1.2.3-alpha.174",
+    "@bitgo-beta/sdk-coin-eth": "2.4.1-alpha.174",
+    "@bitgo-beta/sdk-core": "2.4.1-alpha.174",
+    "@bitgo-beta/statics": "10.0.1-alpha.174",
     "@ethereumjs/common": "^2.6.5",
     "ethereumjs-abi": "^0.6.5"
   },
   "devDependencies": {
-    "@bitgo-beta/sdk-api": "1.6.1-alpha.173",
-    "@bitgo-beta/sdk-test": "^8.0.34"
+    "@bitgo-beta/sdk-api": "1.6.1-alpha.174",
+    "@bitgo-beta/sdk-test": "^8.0.33"
   },
-  "gitHead": "6ec669fe7cec9f4fd489bed3dcecdffbf49a0a92"
+  "gitHead": "846fef1839ddb34490d7e22a421c14b5e1b995b1"
 }