@bitgo-beta/abstract-eth 1.0.2-beta.51 → 1.0.2-beta.511

package/dist/src/lib/utils.js

@@ -0,0 +1,650 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoveryBlockchainExplorerQuery = exports.decodeForwarderCreationData = exports.getCreateForwarderParamsAndTypes = exports.getAddressInitDataAllForwarderVersions = exports.getV1AddressInitializationData = exports.getV1WalletInitializationData = exports.getToken = exports.getBufferedByteCode = exports.getRawDecoded = exports.hasSignature = exports.toStringSig = exports.getProxyInitcode = exports.calculateForwarderV1Address = exports.calculateForwarderAddress = exports.hexStringToNumber = exports.numberToHexString = exports.classifyTransaction = exports.decodeFlushTokensData = exports.decodeNativeTransferData = exports.decodeERC1155TransferData = exports.decodeERC721TransferData = exports.decodeTokenTransferData = exports.decodeTransferData = exports.decodeWalletCreationData = exports.isValidAmount = exports.isValidEthAddress = exports.getAddressInitializationData = exports.flushCoinsData = exports.flushTokensData = exports.sendMultiSigTokenData = exports.sendMultiSigData = exports.sign = exports.signInternal = exports.getCommon = void 0;
+const buffer_1 = require("buffer");
+const superagent_1 = __importDefault(require("superagent"));
+const assert_1 = __importDefault(require("assert"));
+const ethereumjs_util_1 = require("ethereumjs-util");
+const statics_1 = require("@bitgo-beta/statics");
+const ethereumjs_abi_1 = __importDefault(require("ethereumjs-abi"));
+const common_1 = __importDefault(require("@ethereumjs/common"));
+const bn_js_1 = __importDefault(require("bn.js"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const walletUtil_1 = require("./walletUtil");
+const types_1 = require("./types");
+/**
+ * @param network
+ */
+function getCommon(network) {
+    return common_1.default.forCustomChain(
+    // use the mainnet config as a base, override chain ids and network name
+    'mainnet', {
+        name: network.type,
+        networkId: network.chainId,
+        chainId: network.chainId,
+    }, 'london');
+}
+exports.getCommon = getCommon;
+/**
+ * Signs the transaction using the appropriate algorithm
+ * and the provided common for the blockchain
+ *
+ * @param {TxData} transactionData the transaction data to sign
+ * @param {KeyPair} keyPair the signer's keypair
+ * @param {EthereumCommon} customCommon the network's custom common
+ * @returns {string} the transaction signed and encoded
+ */
+async function signInternal(transactionData, keyPair, customCommon) {
+    if (!keyPair.getKeys().prv) {
+        throw new sdk_core_1.SigningError('Missing private key');
+    }
+    const ethTx = types_1.EthTransactionData.fromJson(transactionData, customCommon);
+    ethTx.sign(keyPair);
+    return ethTx.toSerialized();
+}
+exports.signInternal = signInternal;
+/**
+ * Signs the transaction using the appropriate algorithm
+ *
+ * @param {TxData} transactionData the transaction data to sign
+ * @param {KeyPair} keyPair the signer's keypair
+ * @returns {string} the transaction signed and encoded
+ */
+async function sign(transactionData, keyPair) {
+    return signInternal(transactionData, keyPair, getCommon(statics_1.coins.get('teth').network));
+}
+exports.sign = sign;
+/**
+ * Returns the contract method encoded data
+ *
+ * @param {string} to destination address
+ * @param {number} value Amount to tranfer
+ * @param {string} data aditional method call data
+ * @param {number} expireTime expiration time for the transaction in seconds
+ * @param {number} sequenceId sequence id
+ * @param {string} signature signature of the call
+ * @returns {string} -- the contract method encoded data
+ */
+function sendMultiSigData(to, value, data, expireTime, sequenceId, signature) {
+    const params = [to, value, ethereumjs_util_1.toBuffer(data), expireTime, sequenceId, ethereumjs_util_1.toBuffer(signature)];
+    const method = ethereumjs_abi_1.default.methodID('sendMultiSig', walletUtil_1.sendMultiSigTypes);
+    const args = ethereumjs_abi_1.default.rawEncode(walletUtil_1.sendMultiSigTypes, params);
+    return ethereumjs_util_1.addHexPrefix(buffer_1.Buffer.concat([method, args]).toString('hex'));
+}
+exports.sendMultiSigData = sendMultiSigData;
+/**
+ * Returns the contract method encoded data
+ *
+ * @param {string} to destination address
+ * @param {number} value Amount to tranfer
+ * @param {string} tokenContractAddress the address of the erc20 token contract
+ * @param {number} expireTime expiration time for the transaction in seconds
+ * @param {number} sequenceId sequence id
+ * @param {string} signature signature of the call
+ * @returns {string} -- the contract method encoded data
+ */
+function sendMultiSigTokenData(to, value, tokenContractAddress, expireTime, sequenceId, signature) {
+    const params = [to, value, tokenContractAddress, expireTime, sequenceId, ethereumjs_util_1.toBuffer(signature)];
+    const method = ethereumjs_abi_1.default.methodID('sendMultiSigToken', walletUtil_1.sendMultiSigTokenTypes);
+    const args = ethereumjs_abi_1.default.rawEncode(walletUtil_1.sendMultiSigTokenTypes, params);
+    return ethereumjs_util_1.addHexPrefix(buffer_1.Buffer.concat([method, args]).toString('hex'));
+}
+exports.sendMultiSigTokenData = sendMultiSigTokenData;
+/**
+ * Get the data required to make a flush tokens contract call
+ *
+ * @param forwarderAddress The forwarder address to flush
+ * @param tokenAddress The token address to flush from
+ */
+function flushTokensData(forwarderAddress, tokenAddress) {
+    const params = [forwarderAddress, tokenAddress];
+    const method = ethereumjs_abi_1.default.methodID('flushForwarderTokens', walletUtil_1.flushTokensTypes);
+    const args = ethereumjs_abi_1.default.rawEncode(walletUtil_1.flushTokensTypes, params);
+    return ethereumjs_util_1.addHexPrefix(buffer_1.Buffer.concat([method, args]).toString('hex'));
+}
+exports.flushTokensData = flushTokensData;
+/**
+ * Get the data required to make a flush native coins contract call
+ */
+function flushCoinsData() {
+    const params = [];
+    const method = ethereumjs_abi_1.default.methodID('flush', walletUtil_1.flushCoinsTypes);
+    const args = ethereumjs_abi_1.default.rawEncode(walletUtil_1.flushCoinsTypes, params);
+    return ethereumjs_util_1.addHexPrefix(buffer_1.Buffer.concat([method, args]).toString('hex'));
+}
+exports.flushCoinsData = flushCoinsData;
+/**
+ * Returns the create forwarder method calling data
+ *
+ * @returns {string} - the createForwarder method encoded
+ */
+function getAddressInitializationData() {
+    return walletUtil_1.createForwarderMethodId;
+}
+exports.getAddressInitializationData = getAddressInitializationData;
+/**
+ * Returns whether or not the string is a valid Eth address
+ *
+ * @param {string} address - the tx hash to validate
+ * @returns {boolean} - the validation result
+ */
+function isValidEthAddress(address) {
+    return ethereumjs_util_1.isValidAddress(address);
+}
+exports.isValidEthAddress = isValidEthAddress;
+/**
+ * Returns whether or not the string is a valid amount number
+ *
+ * @param {string} amount - the string to validate
+ * @returns {boolean} - the validation result
+ */
+function isValidAmount(amount) {
+    const bigNumberAmount = new bignumber_js_1.default(amount);
+    return bigNumberAmount.isInteger() && bigNumberAmount.isGreaterThanOrEqualTo(0);
+}
+exports.isValidAmount = isValidAmount;
+/**
+ * Returns the smart contract encoded data
+ *
+ * @param {string} data The wallet creation data to decode
+ * @returns {string[]} - The list of signer addresses
+ */
+function decodeWalletCreationData(data) {
+    if (!(data.startsWith(walletUtil_1.walletInitializationFirstBytes) || data.startsWith(walletUtil_1.v1CreateWalletMethodId))) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid wallet bytecode: ${data}`);
+    }
+    if (data.startsWith(walletUtil_1.walletInitializationFirstBytes)) {
+        const dataBuffer = buffer_1.Buffer.from(data.slice(2), 'hex');
+        // the last 160 bytes contain the serialized address array
+        const serializedSigners = dataBuffer.slice(-160);
+        const resultEncodedParameters = ethereumjs_abi_1.default.rawDecode(walletUtil_1.walletSimpleConstructor, serializedSigners);
+        if (resultEncodedParameters.length !== 1) {
+            throw new sdk_core_1.BuildTransactionError(`Could not decode wallet constructor bytecode: ${resultEncodedParameters}`);
+        }
+        const addresses = resultEncodedParameters[0];
+        if (addresses.length !== 3) {
+            throw new sdk_core_1.BuildTransactionError(`invalid number of addresses in parsed constructor: ${addresses}`);
+        }
+        // sometimes ethereumjs-abi removes 0 padding at the start of addresses,
+        // so we should pad until they are the standard 20 bytes
+        const paddedAddresses = addresses.map((address) => ethereumjs_util_1.stripHexPrefix(address.toString('hex')).padStart(40, '0'));
+        return { owners: paddedAddresses.map((address) => ethereumjs_util_1.addHexPrefix(address)) };
+    }
+    else {
+        const decodedDataForWalletCreation = getRawDecoded(walletUtil_1.createV1WalletTypes, getBufferedByteCode(walletUtil_1.v1CreateWalletMethodId, data));
+        const addresses = decodedDataForWalletCreation[0];
+        const saltBuffer = decodedDataForWalletCreation[1];
+        const salt = ethereumjs_util_1.bufferToHex(saltBuffer);
+        const paddedAddresses = addresses.map((address) => ethereumjs_util_1.stripHexPrefix(address.toString()).padStart(40, '0'));
+        const owners = paddedAddresses.map((address) => ethereumjs_util_1.addHexPrefix(address));
+        return {
+            owners,
+            salt,
+        };
+    }
+}
+exports.decodeWalletCreationData = decodeWalletCreationData;
+/**
+ * Decode the given ABI-encoded transfer data and return parsed fields
+ *
+ * @param data The data to decode
+ * @returns parsed transfer data
+ */
+function decodeTransferData(data) {
+    if (data.startsWith(walletUtil_1.sendMultisigMethodId)) {
+        return decodeNativeTransferData(data);
+    }
+    else if (data.startsWith(walletUtil_1.sendMultisigTokenMethodId)) {
+        return decodeTokenTransferData(data);
+    }
+    else {
+        throw new sdk_core_1.BuildTransactionError(`Invalid transfer bytecode: ${data}`);
+    }
+}
+exports.decodeTransferData = decodeTransferData;
+/**
+ * Decode the given ABI-encoded transfer data for the sendMultisigToken function and return parsed fields
+ *
+ * @param data The data to decode
+ * @returns parsed token transfer data
+ */
+function decodeTokenTransferData(data) {
+    if (!data.startsWith(walletUtil_1.sendMultisigTokenMethodId)) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid transfer bytecode: ${data}`);
+    }
+    const [to, amount, tokenContractAddress, expireTime, sequenceId, signature] = getRawDecoded(walletUtil_1.sendMultiSigTokenTypes, getBufferedByteCode(walletUtil_1.sendMultisigTokenMethodId, data));
+    return {
+        to: ethereumjs_util_1.addHexPrefix(to),
+        amount: new bignumber_js_1.default(ethereumjs_util_1.bufferToHex(amount)).toFixed(),
+        expireTime: ethereumjs_util_1.bufferToInt(expireTime),
+        sequenceId: ethereumjs_util_1.bufferToInt(sequenceId),
+        signature: ethereumjs_util_1.bufferToHex(signature),
+        tokenContractAddress: ethereumjs_util_1.addHexPrefix(tokenContractAddress),
+    };
+}
+exports.decodeTokenTransferData = decodeTokenTransferData;
+function decodeERC721TransferData(data) {
+    if (!data.startsWith(walletUtil_1.sendMultisigMethodId)) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid transfer bytecode: ${data}`);
+    }
+    const [to, amount, internalData, expireTime, sequenceId, signature] = getRawDecoded(walletUtil_1.sendMultiSigTypes, getBufferedByteCode(walletUtil_1.sendMultisigMethodId, data));
+    const internalDataHex = ethereumjs_util_1.bufferToHex(internalData);
+    if (!internalDataHex.startsWith(walletUtil_1.ERC721SafeTransferTypeMethodId)) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid transfer bytecode: ${data}`);
+    }
+    const [from, receiver, tokenId, userSentData] = getRawDecoded(walletUtil_1.ERC721SafeTransferTypes, getBufferedByteCode(walletUtil_1.ERC721SafeTransferTypeMethodId, internalDataHex));
+    return {
+        to: ethereumjs_util_1.addHexPrefix(receiver),
+        from: ethereumjs_util_1.addHexPrefix(from),
+        expireTime: ethereumjs_util_1.bufferToInt(expireTime),
+        amount: new bignumber_js_1.default(ethereumjs_util_1.bufferToHex(amount)).toFixed(),
+        tokenId: new bignumber_js_1.default(ethereumjs_util_1.bufferToHex(tokenId)).toFixed(),
+        sequenceId: ethereumjs_util_1.bufferToInt(sequenceId),
+        signature: ethereumjs_util_1.bufferToHex(signature),
+        tokenContractAddress: ethereumjs_util_1.addHexPrefix(to),
+        userData: ethereumjs_util_1.bufferToHex(userSentData),
+    };
+}
+exports.decodeERC721TransferData = decodeERC721TransferData;
+function decodeERC1155TransferData(data) {
+    let from, receiver, userSentData;
+    let tokenIds;
+    let values;
+    if (!data.startsWith(walletUtil_1.sendMultisigMethodId)) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid transfer bytecode: ${data}`);
+    }
+    const [to, amount, internalData, expireTime, sequenceId, signature] = getRawDecoded(walletUtil_1.sendMultiSigTypes, getBufferedByteCode(walletUtil_1.sendMultisigMethodId, data));
+    const internalDataHex = ethereumjs_util_1.bufferToHex(internalData);
+    if (internalDataHex.startsWith(walletUtil_1.ERC1155SafeTransferTypeMethodId)) {
+        let tokenId;
+        let value;
+        [from, receiver, tokenId, value, userSentData] = getRawDecoded(walletUtil_1.ERC1155SafeTransferTypes, getBufferedByteCode(walletUtil_1.ERC1155SafeTransferTypeMethodId, internalDataHex));
+        tokenIds = [new bignumber_js_1.default(ethereumjs_util_1.bufferToHex(tokenId)).toFixed()];
+        values = [new bignumber_js_1.default(ethereumjs_util_1.bufferToHex(value)).toFixed()];
+    }
+    else if (ethereumjs_util_1.bufferToHex(internalData).startsWith(walletUtil_1.ERC1155BatchTransferTypeMethodId)) {
+        let tempTokenIds, tempValues;
+        [from, receiver, tempTokenIds, tempValues, userSentData] = getRawDecoded(walletUtil_1.ERC1155BatchTransferTypes, getBufferedByteCode(walletUtil_1.ERC1155BatchTransferTypeMethodId, internalDataHex));
+        tokenIds = tempTokenIds.map((x) => new bignumber_js_1.default(ethereumjs_util_1.bufferToHex(x)).toFixed());
+        values = tempValues.map((x) => new bignumber_js_1.default(ethereumjs_util_1.bufferToHex(x)).toFixed());
+    }
+    else {
+        throw new sdk_core_1.BuildTransactionError(`Invalid transfer bytecode: ${data}`);
+    }
+    return {
+        to: ethereumjs_util_1.addHexPrefix(receiver),
+        from: ethereumjs_util_1.addHexPrefix(from),
+        expireTime: ethereumjs_util_1.bufferToInt(expireTime),
+        amount: new bignumber_js_1.default(ethereumjs_util_1.bufferToHex(amount)).toFixed(),
+        tokenIds,
+        values,
+        sequenceId: ethereumjs_util_1.bufferToInt(sequenceId),
+        signature: ethereumjs_util_1.bufferToHex(signature),
+        tokenContractAddress: ethereumjs_util_1.addHexPrefix(to),
+        userData: userSentData,
+    };
+}
+exports.decodeERC1155TransferData = decodeERC1155TransferData;
+/**
+ * Decode the given ABI-encoded transfer data for the sendMultisig function and return parsed fields
+ *
+ * @param data The data to decode
+ * @returns parsed transfer data
+ */
+function decodeNativeTransferData(data) {
+    if (!data.startsWith(walletUtil_1.sendMultisigMethodId)) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid transfer bytecode: ${data}`);
+    }
+    const [to, amount, internalData, expireTime, sequenceId, signature] = getRawDecoded(walletUtil_1.sendMultiSigTypes, getBufferedByteCode(walletUtil_1.sendMultisigMethodId, data));
+    return {
+        to: ethereumjs_util_1.addHexPrefix(to),
+        amount: new bignumber_js_1.default(ethereumjs_util_1.bufferToHex(amount)).toFixed(),
+        expireTime: ethereumjs_util_1.bufferToInt(expireTime),
+        sequenceId: ethereumjs_util_1.bufferToInt(sequenceId),
+        signature: ethereumjs_util_1.bufferToHex(signature),
+        data: ethereumjs_util_1.bufferToHex(internalData),
+    };
+}
+exports.decodeNativeTransferData = decodeNativeTransferData;
+/**
+ * Decode the given ABI-encoded flush tokens data and return parsed fields
+ *
+ * @param data The data to decode
+ * @returns parsed transfer data
+ */
+function decodeFlushTokensData(data) {
+    if (!data.startsWith(walletUtil_1.flushForwarderTokensMethodId)) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid transfer bytecode: ${data}`);
+    }
+    const [forwarderAddress, tokenAddress] = getRawDecoded(walletUtil_1.flushTokensTypes, getBufferedByteCode(walletUtil_1.flushForwarderTokensMethodId, data));
+    return {
+        forwarderAddress: ethereumjs_util_1.addHexPrefix(forwarderAddress),
+        tokenAddress: ethereumjs_util_1.addHexPrefix(tokenAddress),
+    };
+}
+exports.decodeFlushTokensData = decodeFlushTokensData;
+/**
+ * Classify the given transaction data based as a transaction type.
+ * ETH transactions are defined by the first 8 bytes of the transaction data, also known as the method id
+ *
+ * @param {string} data The data to classify the transaction with
+ * @returns {TransactionType} The classified transaction type
+ */
+function classifyTransaction(data) {
+    if (data.length < 10) {
+        // contract calls must have at least 4 bytes (method id) and '0x'
+        // if it doesn't have enough data to be a contract call it must be a single sig send
+        return sdk_core_1.TransactionType.SingleSigSend;
+    }
+    // TODO(STLX-1970): validate if we are going to constraint to some methods allowed
+    let transactionType = transactionTypesMap[data.slice(0, 10).toLowerCase()];
+    if (transactionType === undefined) {
+        transactionType = sdk_core_1.TransactionType.ContractCall;
+    }
+    return transactionType;
+}
+exports.classifyTransaction = classifyTransaction;
+/**
+ * A transaction types map according to the starting part of the encoded data
+ */
+const transactionTypesMap = {
+    [walletUtil_1.walletInitializationFirstBytes]: sdk_core_1.TransactionType.WalletInitialization,
+    [walletUtil_1.recoveryWalletInitializationFirstBytes]: sdk_core_1.TransactionType.RecoveryWalletDeployment,
+    [walletUtil_1.v1CreateWalletMethodId]: sdk_core_1.TransactionType.WalletInitialization,
+    [walletUtil_1.createForwarderMethodId]: sdk_core_1.TransactionType.AddressInitialization,
+    [walletUtil_1.v1CreateForwarderMethodId]: sdk_core_1.TransactionType.AddressInitialization,
+    [walletUtil_1.v4CreateForwarderMethodId]: sdk_core_1.TransactionType.AddressInitialization,
+    [walletUtil_1.sendMultisigMethodId]: sdk_core_1.TransactionType.Send,
+    [walletUtil_1.flushForwarderTokensMethodId]: sdk_core_1.TransactionType.FlushTokens,
+    [walletUtil_1.flushCoinsMethodId]: sdk_core_1.TransactionType.FlushCoins,
+    [walletUtil_1.sendMultisigTokenMethodId]: sdk_core_1.TransactionType.Send,
+    [sdk_core_1.LockMethodId]: sdk_core_1.TransactionType.StakingLock,
+    [sdk_core_1.VoteMethodId]: sdk_core_1.TransactionType.StakingVote,
+    [sdk_core_1.ActivateMethodId]: sdk_core_1.TransactionType.StakingActivate,
+    [sdk_core_1.UnvoteMethodId]: sdk_core_1.TransactionType.StakingUnvote,
+    [sdk_core_1.UnlockMethodId]: sdk_core_1.TransactionType.StakingUnlock,
+    [sdk_core_1.WithdrawMethodId]: sdk_core_1.TransactionType.StakingWithdraw,
+};
+/**
+ *
+ * @param {number} num number to be converted to hex
+ * @returns {string} the hex number
+ */
+function numberToHexString(num) {
+    const hex = num.toString(16);
+    return hex.length % 2 === 0 ? '0x' + hex : '0x0' + hex;
+}
+exports.numberToHexString = numberToHexString;
+/**
+ *
+ * @param {string} hex The hex string to be converted
+ * @returns {number} the resulting number
+ */
+function hexStringToNumber(hex) {
+    return parseInt(hex.slice(2), 16);
+}
+exports.hexStringToNumber = hexStringToNumber;
+/**
+ * Generates an address of the forwarder address to be deployed
+ *
+ * @param {string} contractAddress the address which is creating this new address
+ * @param {number} contractCounter the nonce of the contract address
+ * @returns {string} the calculated forwarder contract address
+ */
+function calculateForwarderAddress(contractAddress, contractCounter) {
+    const forwarderAddress = ethereumjs_util_1.generateAddress(buffer_1.Buffer.from(ethereumjs_util_1.stripHexPrefix(contractAddress), 'hex'), buffer_1.Buffer.from(ethereumjs_util_1.padToEven(ethereumjs_util_1.stripHexPrefix(numberToHexString(contractCounter))), 'hex'));
+    return ethereumjs_util_1.addHexPrefix(forwarderAddress.toString('hex'));
+}
+exports.calculateForwarderAddress = calculateForwarderAddress;
+/**
+ * Calculate the forwarder v1 address that will be generated if `creatorAddress` creates it with salt `salt`
+ * and initcode `inicode using the create2 opcode
+ * @param {string} creatorAddress The address that is sending the tx to create a new address, hex string
+ * @param {string} salt The salt to create the address with using create2, hex string
+ * @param {string} initcode The initcode that will be deployed to the address, hex string
+ * @return {string} The calculated address
+ */
+function calculateForwarderV1Address(creatorAddress, salt, initcode) {
+    const forwarderV1Address = ethereumjs_util_1.generateAddress2(buffer_1.Buffer.from(ethereumjs_util_1.stripHexPrefix(creatorAddress), 'hex'), buffer_1.Buffer.from(ethereumjs_util_1.stripHexPrefix(salt), 'hex'), buffer_1.Buffer.from(ethereumjs_util_1.padToEven(ethereumjs_util_1.stripHexPrefix(initcode)), 'hex'));
+    return ethereumjs_util_1.addHexPrefix(forwarderV1Address.toString('hex'));
+}
+exports.calculateForwarderV1Address = calculateForwarderV1Address;
+/**
+ * Take the implementation address for the proxy contract, and get the binary initcode for the associated proxy
+ * @param {string} implementationAddress The address of the implementation contract for the proxy
+ * @return {string} Binary hex string of the proxy
+ */
+function getProxyInitcode(implementationAddress) {
+    const target = ethereumjs_util_1.stripHexPrefix(implementationAddress.toLowerCase()).padStart(40, '0');
+    // bytecode of the proxy, from:
+    // https://github.com/BitGo/eth-multisig-v4/blob/d546a937f90f93e83b3423a5bf933d1d77c677c3/contracts/CloneFactory.sol#L42-L56
+    return `0x3d602d80600a3d3981f3363d3d373d3d3d363d73${target}5af43d82803e903d91602b57fd5bf3`;
+}
+exports.getProxyInitcode = getProxyInitcode;
+/**
+ * Convert the given signature parts to a string representation
+ *
+ * @param {SignatureParts} sig The signature to convert to string
+ * @returns {string} String representation of the signature
+ */
+function toStringSig(sig) {
+    return ethereumjs_util_1.bufferToHex(buffer_1.Buffer.concat([
+        ethereumjs_util_1.setLengthLeft(buffer_1.Buffer.from(ethereumjs_util_1.stripHexPrefix(sig.r), 'hex'), 32),
+        ethereumjs_util_1.setLengthLeft(buffer_1.Buffer.from(ethereumjs_util_1.stripHexPrefix(sig.s), 'hex'), 32),
+        ethereumjs_util_1.toBuffer(sig.v),
+    ]));
+}
+exports.toStringSig = toStringSig;
+/**
+ * Return whether or not the given tx data has a signature
+ *
+ * @param {TxData} txData The transaction data to check for signature
+ * @returns {boolean} true if the tx has a signature, else false
+ */
+function hasSignature(txData) {
+    return (txData.v !== undefined &&
+        txData.r !== undefined &&
+        txData.s !== undefined &&
+        txData.v.length > 0 &&
+        txData.r.length > 0 &&
+        txData.s.length > 0);
+}
+exports.hasSignature = hasSignature;
+/**
+ * Get the raw data decoded for some types
+ *
+ * @param {string[]} types ABI types definition
+ * @param {Buffer} serializedArgs encoded args
+ * @returns {Buffer[]} the decoded raw
+ */
+function getRawDecoded(types, serializedArgs) {
+    function normalize(v, i) {
+        if (bn_js_1.default.isBN(v)) {
+            return v;
+        }
+        else if (typeof v === 'string' || buffer_1.Buffer.isBuffer(v)) {
+            return v;
+        }
+        else if (Array.isArray(v)) {
+            return v.map(normalize);
+        }
+        else {
+            throw new Error(`For ${types}[${i}] got ${typeof v}`);
+        }
+    }
+    return ethereumjs_abi_1.default.rawDecode(types, serializedArgs).map(normalize);
+}
+exports.getRawDecoded = getRawDecoded;
+/**
+ * Get the buffered bytecode from rawData using a methodId as delimiter
+ *
+ * @param {string} methodId the hex encoded method Id
+ * @param {string} rawData the hex encoded raw data
+ * @returns {Buffer} data buffered bytecode
+ */
+function getBufferedByteCode(methodId, rawData) {
+    const splitBytecode = rawData.split(methodId);
+    if (splitBytecode.length !== 2) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid send bytecode: ${rawData}`);
+    }
+    if (splitBytecode[1].length % 2 !== 0) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid send bytecode: ${rawData} (wrong lenght)`);
+    }
+    return buffer_1.Buffer.from(splitBytecode[1], 'hex');
+}
+exports.getBufferedByteCode = getBufferedByteCode;
+/**
+ * Get the statics coin object matching a given contract address if it exists
+ *
+ * @param tokenContractAddress The contract address to match against
+ * @returns statics BaseCoin object for the matching token
+ */
+function getToken(tokenContractAddress, network) {
+    const tokens = statics_1.coins.filter((coin) => {
+        if (coin instanceof statics_1.ContractAddressDefinedToken) {
+            return (coin.network.type === network.type && coin.contractAddress.toLowerCase() === tokenContractAddress.toLowerCase());
+        }
+        return false;
+    });
+    // if length of tokens is 1, return the first, else return undefined
+    // Can't directly index into tokens, or call `length`, so we use map to get an array
+    const tokensArray = tokens.map((token) => token);
+    if (tokensArray.length >= 1) {
+        // there should never be two tokens with the same contract address, so we assert that here
+        assert_1.default(tokensArray.length === 1);
+        return tokensArray[0];
+    }
+    return undefined;
+}
+exports.getToken = getToken;
+/**
+ * Returns the create wallet method calling data for v1 wallets
+ *
+ * @param {string[]} walletOwners - wallet owner addresses for wallet initialization transactions
+ * @param {string} salt - The salt for wallet initialization transactions
+ * @returns {string} - the createWallet method encoded
+ */
+function getV1WalletInitializationData(walletOwners, salt) {
+    const saltBuffer = ethereumjs_util_1.setLengthLeft(ethereumjs_util_1.toBuffer(salt), 32);
+    const params = [walletOwners, saltBuffer];
+    const method = ethereumjs_abi_1.default.methodID('createWallet', walletUtil_1.createV1WalletTypes);
+    const args = ethereumjs_abi_1.default.rawEncode(walletUtil_1.createV1WalletTypes, params);
+    return ethereumjs_util_1.addHexPrefix(buffer_1.Buffer.concat([method, args]).toString('hex'));
+}
+exports.getV1WalletInitializationData = getV1WalletInitializationData;
+/**
+ * Returns the create address method calling data for v1, v2, v4 forwarders
+ *
+ * @param {string} baseAddress - The address of the wallet contract
+ * @param {string} salt - The salt for address initialization transactions
+ * @param {string} feeAddress - The fee address for the enterprise
+ * @returns {string} - the createForwarder method encoded
+ */
+function getV1AddressInitializationData(baseAddress, salt, feeAddress) {
+    const saltBuffer = ethereumjs_util_1.setLengthLeft(ethereumjs_util_1.toBuffer(salt), 32);
+    const { createForwarderParams, createForwarderTypes } = getCreateForwarderParamsAndTypes(baseAddress, saltBuffer, feeAddress);
+    const method = ethereumjs_abi_1.default.methodID('createForwarder', createForwarderTypes);
+    const args = ethereumjs_abi_1.default.rawEncode(createForwarderTypes, createForwarderParams);
+    return ethereumjs_util_1.addHexPrefix(buffer_1.Buffer.concat([method, args]).toString('hex'));
+}
+exports.getV1AddressInitializationData = getV1AddressInitializationData;
+/**
+ * Returns the create address method calling data for all forwarder versions
+ *
+ * @param {number} forwarderVersion - The version of the forwarder to create
+ * @param {string} baseAddress - The address of the wallet contract
+ * @param {string} salt - The salt for address initialization transactions
+ * @param {string} feeAddress - The fee address for the enterprise
+ * @returns {string} - the createForwarder method encoded
+ *
+ */
+function getAddressInitDataAllForwarderVersions(forwarderVersion, baseAddress, salt, feeAddress) {
+    if (forwarderVersion === walletUtil_1.defaultForwarderVersion) {
+        return getAddressInitializationData();
+    }
+    else {
+        return getV1AddressInitializationData(baseAddress, salt, feeAddress);
+    }
+}
+exports.getAddressInitDataAllForwarderVersions = getAddressInitDataAllForwarderVersions;
+/**
+ * Returns the createForwarderTypes and createForwarderParams for all forwarder versions
+ *
+ * @param {string} baseAddress - The address of the wallet contract
+ * @param {Buffer} saltBuffer - The salt for address initialization transaction
+ * @param {string} feeAddress - The fee address for the enterprise
+ * @returns {createForwarderParams: (string | Buffer)[], createForwarderTypes: string[]}
+ */
+function getCreateForwarderParamsAndTypes(baseAddress, saltBuffer, feeAddress) {
+    let createForwarderParams = [baseAddress, saltBuffer];
+    let createForwarderTypes = walletUtil_1.createV1ForwarderTypes;
+    if (feeAddress) {
+        createForwarderParams = [baseAddress, feeAddress, saltBuffer];
+        createForwarderTypes = walletUtil_1.createV4ForwarderTypes;
+    }
+    return { createForwarderParams, createForwarderTypes };
+}
+exports.getCreateForwarderParamsAndTypes = getCreateForwarderParamsAndTypes;
+/**
+ * Decode the given ABI-encoded create forwarder data and return parsed fields
+ *
+ * @param data The data to decode
+ * @returns parsed transfer data
+ */
+function decodeForwarderCreationData(data) {
+    if (!(data.startsWith(walletUtil_1.v4CreateForwarderMethodId) ||
+        data.startsWith(walletUtil_1.v1CreateForwarderMethodId) ||
+        data.startsWith(walletUtil_1.createForwarderMethodId))) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid address bytecode: ${data}`);
+    }
+    if (data.startsWith(walletUtil_1.createForwarderMethodId)) {
+        return {
+            baseAddress: undefined,
+            addressCreationSalt: undefined,
+            feeAddress: undefined,
+        };
+    }
+    else if (data.startsWith(walletUtil_1.v1CreateForwarderMethodId)) {
+        const [baseAddress, saltBuffer] = getRawDecoded(walletUtil_1.createV1ForwarderTypes, getBufferedByteCode(walletUtil_1.v1CreateForwarderMethodId, data));
+        return {
+            baseAddress: ethereumjs_util_1.addHexPrefix(baseAddress),
+            addressCreationSalt: ethereumjs_util_1.bufferToHex(saltBuffer),
+            feeAddress: undefined,
+        };
+    }
+    else {
+        const [baseAddress, feeAddress, saltBuffer] = getRawDecoded(walletUtil_1.createV4ForwarderTypes, getBufferedByteCode(walletUtil_1.v4CreateForwarderMethodId, data));
+        return {
+            baseAddress: ethereumjs_util_1.addHexPrefix(baseAddress),
+            addressCreationSalt: ethereumjs_util_1.bufferToHex(saltBuffer),
+            feeAddress: ethereumjs_util_1.addHexPrefix(feeAddress),
+        };
+    }
+}
+exports.decodeForwarderCreationData = decodeForwarderCreationData;
+/**
+ * Make a query to explorer for information such as balance, token balance, solidity calls
+ * @param {Object} query key-value pairs of parameters to append after /api
+ * @param {string} token the API token to use for the request
+ * @param {string} explorerUrl the URL of the explorer
+ * @returns {Promise<Object>} response from explorer
+ */
+async function recoveryBlockchainExplorerQuery(query, explorerUrl, token) {
+    if (token) {
+        query.apikey = token;
+    }
+    const response = await superagent_1.default.get(`${explorerUrl}/api`).query(query);
+    if (!response.ok) {
+        throw new Error('could not reach explorer');
+    }
+    if (response.body.status === '0' && response.body.message === 'NOTOK') {
+        throw new Error('Explorer rate limit reached');
+    }
+    return response.body;
+}
+exports.recoveryBlockchainExplorerQuery = recoveryBlockchainExplorerQuery;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Buffer } from 'buffer';\nimport request from 'superagent';\nimport assert from 'assert';\nimport {\n  addHexPrefix,\n  bufferToHex,\n  bufferToInt,\n  generateAddress,\n  isValidAddress,\n  setLengthLeft,\n  stripHexPrefix,\n  toBuffer,\n  generateAddress2,\n  padToEven,\n} from 'ethereumjs-util';\nimport { BaseCoin, BaseNetwork, coins, ContractAddressDefinedToken, EthereumNetwork } from '@bitgo-beta/statics';\nimport EthereumAbi from 'ethereumjs-abi';\nimport EthereumCommon from '@ethereumjs/common';\nimport BN from 'bn.js';\nimport BigNumber from 'bignumber.js';\nimport {\n  ActivateMethodId,\n  BuildTransactionError,\n  LockMethodId,\n  SigningError,\n  TransactionType,\n  UnlockMethodId,\n  UnvoteMethodId,\n  VoteMethodId,\n  WithdrawMethodId,\n} from '@bitgo-beta/sdk-core';\n\nimport {\n  ERC1155TransferData,\n  ERC721TransferData,\n  FlushTokensData,\n  NativeTransferData,\n  SignatureParts,\n  TokenTransferData,\n  TransferData,\n  TxData,\n  WalletInitializationData,\n  ForwarderInitializationData,\n} from './iface';\nimport { KeyPair } from './keyPair';\nimport {\n  createForwarderMethodId,\n  ERC1155BatchTransferTypeMethodId,\n  ERC1155BatchTransferTypes,\n  ERC1155SafeTransferTypeMethodId,\n  ERC1155SafeTransferTypes,\n  ERC721SafeTransferTypeMethodId,\n  ERC721SafeTransferTypes,\n  flushCoinsMethodId,\n  flushCoinsTypes,\n  flushForwarderTokensMethodId,\n  flushTokensTypes,\n  sendMultisigMethodId,\n  sendMultisigTokenMethodId,\n  sendMultiSigTokenTypes,\n  sendMultiSigTypes,\n  walletInitializationFirstBytes,\n  v1CreateForwarderMethodId,\n  walletSimpleConstructor,\n  createV1WalletTypes,\n  v1CreateWalletMethodId,\n  createV1ForwarderTypes,\n  recoveryWalletInitializationFirstBytes,\n  defaultForwarderVersion,\n  createV4ForwarderTypes,\n  v4CreateForwarderMethodId,\n} from './walletUtil';\nimport { EthTransactionData } from './types';\n\n/**\n * @param network\n */\nexport function getCommon(network: EthereumNetwork): EthereumCommon {\n  return EthereumCommon.forCustomChain(\n    // use the mainnet config as a base, override chain ids and network name\n    'mainnet',\n    {\n      name: network.type,\n      networkId: network.chainId,\n      chainId: network.chainId,\n    },\n    'london'\n  );\n}\n\n/**\n * Signs the transaction using the appropriate algorithm\n * and the provided common for the blockchain\n *\n * @param {TxData} transactionData the transaction data to sign\n * @param {KeyPair} keyPair the signer's keypair\n * @param {EthereumCommon} customCommon the network's custom common\n * @returns {string} the transaction signed and encoded\n */\nexport async function signInternal(\n  transactionData: TxData,\n  keyPair: KeyPair,\n  customCommon: EthereumCommon\n): Promise<string> {\n  if (!keyPair.getKeys().prv) {\n    throw new SigningError('Missing private key');\n  }\n  const ethTx = EthTransactionData.fromJson(transactionData, customCommon);\n  ethTx.sign(keyPair);\n  return ethTx.toSerialized();\n}\n\n/**\n * Signs the transaction using the appropriate algorithm\n *\n * @param {TxData} transactionData the transaction data to sign\n * @param {KeyPair} keyPair the signer's keypair\n * @returns {string} the transaction signed and encoded\n */\nexport async function sign(transactionData: TxData, keyPair: KeyPair): Promise<string> {\n  return signInternal(transactionData, keyPair, getCommon(coins.get('teth').network as EthereumNetwork));\n}\n\n/**\n * Returns the contract method encoded data\n *\n * @param {string} to destination address\n * @param {number} value Amount to tranfer\n * @param {string} data aditional method call data\n * @param {number} expireTime expiration time for the transaction in seconds\n * @param {number} sequenceId sequence id\n * @param {string} signature signature of the call\n * @returns {string} -- the contract method encoded data\n */\nexport function sendMultiSigData(\n  to: string,\n  value: string,\n  data: string,\n  expireTime: number,\n  sequenceId: number,\n  signature: string\n): string {\n  const params = [to, value, toBuffer(data), expireTime, sequenceId, toBuffer(signature)];\n  const method = EthereumAbi.methodID('sendMultiSig', sendMultiSigTypes);\n  const args = EthereumAbi.rawEncode(sendMultiSigTypes, params);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Returns the contract method encoded data\n *\n * @param {string} to destination address\n * @param {number} value Amount to tranfer\n * @param {string} tokenContractAddress the address of the erc20 token contract\n * @param {number} expireTime expiration time for the transaction in seconds\n * @param {number} sequenceId sequence id\n * @param {string} signature signature of the call\n * @returns {string} -- the contract method encoded data\n */\nexport function sendMultiSigTokenData(\n  to: string,\n  value: string,\n  tokenContractAddress: string,\n  expireTime: number,\n  sequenceId: number,\n  signature: string\n): string {\n  const params = [to, value, tokenContractAddress, expireTime, sequenceId, toBuffer(signature)];\n\n  const method = EthereumAbi.methodID('sendMultiSigToken', sendMultiSigTokenTypes);\n  const args = EthereumAbi.rawEncode(sendMultiSigTokenTypes, params);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Get the data required to make a flush tokens contract call\n *\n * @param forwarderAddress The forwarder address to flush\n * @param tokenAddress The token address to flush from\n */\nexport function flushTokensData(forwarderAddress: string, tokenAddress: string): string {\n  const params = [forwarderAddress, tokenAddress];\n  const method = EthereumAbi.methodID('flushForwarderTokens', flushTokensTypes);\n  const args = EthereumAbi.rawEncode(flushTokensTypes, params);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Get the data required to make a flush native coins contract call\n */\nexport function flushCoinsData(): string {\n  const params = [];\n  const method = EthereumAbi.methodID('flush', flushCoinsTypes);\n  const args = EthereumAbi.rawEncode(flushCoinsTypes, params);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Returns the create forwarder method calling data\n *\n * @returns {string} - the createForwarder method encoded\n */\nexport function getAddressInitializationData(): string {\n  return createForwarderMethodId;\n}\n\n/**\n * Returns whether or not the string is a valid Eth address\n *\n * @param {string} address - the tx hash to validate\n * @returns {boolean} - the validation result\n */\nexport function isValidEthAddress(address: string): boolean {\n  return isValidAddress(address);\n}\n\n/**\n * Returns whether or not the string is a valid amount number\n *\n * @param {string} amount - the string to validate\n * @returns {boolean} - the validation result\n */\nexport function isValidAmount(amount: string): boolean {\n  const bigNumberAmount = new BigNumber(amount);\n  return bigNumberAmount.isInteger() && bigNumberAmount.isGreaterThanOrEqualTo(0);\n}\n\n/**\n * Returns the smart contract encoded data\n *\n * @param {string} data The wallet creation data to decode\n * @returns {string[]} - The list of signer addresses\n */\nexport function decodeWalletCreationData(data: string): WalletInitializationData {\n  if (!(data.startsWith(walletInitializationFirstBytes) || data.startsWith(v1CreateWalletMethodId))) {\n    throw new BuildTransactionError(`Invalid wallet bytecode: ${data}`);\n  }\n\n  if (data.startsWith(walletInitializationFirstBytes)) {\n    const dataBuffer = Buffer.from(data.slice(2), 'hex');\n\n    // the last 160 bytes contain the serialized address array\n    const serializedSigners = dataBuffer.slice(-160);\n\n    const resultEncodedParameters = EthereumAbi.rawDecode(walletSimpleConstructor, serializedSigners);\n    if (resultEncodedParameters.length !== 1) {\n      throw new BuildTransactionError(`Could not decode wallet constructor bytecode: ${resultEncodedParameters}`);\n    }\n\n    const addresses: BN[] = resultEncodedParameters[0];\n    if (addresses.length !== 3) {\n      throw new BuildTransactionError(`invalid number of addresses in parsed constructor: ${addresses}`);\n    }\n\n    // sometimes ethereumjs-abi removes 0 padding at the start of addresses,\n    // so we should pad until they are the standard 20 bytes\n    const paddedAddresses = addresses.map((address) => stripHexPrefix(address.toString('hex')).padStart(40, '0'));\n\n    return { owners: paddedAddresses.map((address) => addHexPrefix(address)) };\n  } else {\n    const decodedDataForWalletCreation = getRawDecoded(\n      createV1WalletTypes,\n      getBufferedByteCode(v1CreateWalletMethodId, data)\n    );\n    const addresses = decodedDataForWalletCreation[0] as string[];\n    const saltBuffer = decodedDataForWalletCreation[1];\n    const salt = bufferToHex(saltBuffer as Buffer);\n    const paddedAddresses = addresses.map((address) => stripHexPrefix(address.toString()).padStart(40, '0'));\n    const owners = paddedAddresses.map((address) => addHexPrefix(address));\n    return {\n      owners,\n      salt,\n    };\n  }\n}\n\n/**\n * Decode the given ABI-encoded transfer data and return parsed fields\n *\n * @param data The data to decode\n * @returns parsed transfer data\n */\nexport function decodeTransferData(data: string): TransferData {\n  if (data.startsWith(sendMultisigMethodId)) {\n    return decodeNativeTransferData(data);\n  } else if (data.startsWith(sendMultisigTokenMethodId)) {\n    return decodeTokenTransferData(data);\n  } else {\n    throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);\n  }\n}\n\n/**\n * Decode the given ABI-encoded transfer data for the sendMultisigToken function and return parsed fields\n *\n * @param data The data to decode\n * @returns parsed token transfer data\n */\nexport function decodeTokenTransferData(data: string): TokenTransferData {\n  if (!data.startsWith(sendMultisigTokenMethodId)) {\n    throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);\n  }\n\n  const [to, amount, tokenContractAddress, expireTime, sequenceId, signature] = getRawDecoded(\n    sendMultiSigTokenTypes,\n    getBufferedByteCode(sendMultisigTokenMethodId, data)\n  );\n\n  return {\n    to: addHexPrefix(to as string),\n    amount: new BigNumber(bufferToHex(amount as Buffer)).toFixed(),\n    expireTime: bufferToInt(expireTime as Buffer),\n    sequenceId: bufferToInt(sequenceId as Buffer),\n    signature: bufferToHex(signature as Buffer),\n    tokenContractAddress: addHexPrefix(tokenContractAddress as string),\n  };\n}\n\nexport function decodeERC721TransferData(data: string): ERC721TransferData {\n  if (!data.startsWith(sendMultisigMethodId)) {\n    throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);\n  }\n\n  const [to, amount, internalData, expireTime, sequenceId, signature] = getRawDecoded(\n    sendMultiSigTypes,\n    getBufferedByteCode(sendMultisigMethodId, data)\n  );\n\n  const internalDataHex = bufferToHex(internalData as Buffer);\n  if (!internalDataHex.startsWith(ERC721SafeTransferTypeMethodId)) {\n    throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);\n  }\n\n  const [from, receiver, tokenId, userSentData] = getRawDecoded(\n    ERC721SafeTransferTypes,\n    getBufferedByteCode(ERC721SafeTransferTypeMethodId, internalDataHex)\n  );\n\n  return {\n    to: addHexPrefix(receiver as string),\n    from: addHexPrefix(from as string),\n    expireTime: bufferToInt(expireTime as Buffer),\n    amount: new BigNumber(bufferToHex(amount as Buffer)).toFixed(),\n    tokenId: new BigNumber(bufferToHex(tokenId as Buffer)).toFixed(),\n    sequenceId: bufferToInt(sequenceId as Buffer),\n    signature: bufferToHex(signature as Buffer),\n    tokenContractAddress: addHexPrefix(to as string),\n    userData: bufferToHex(userSentData as Buffer),\n  };\n}\n\nexport function decodeERC1155TransferData(data: string): ERC1155TransferData {\n  let from, receiver, userSentData;\n  let tokenIds: string[];\n  let values: string[];\n\n  if (!data.startsWith(sendMultisigMethodId)) {\n    throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);\n  }\n\n  const [to, amount, internalData, expireTime, sequenceId, signature] = getRawDecoded(\n    sendMultiSigTypes,\n    getBufferedByteCode(sendMultisigMethodId, data)\n  );\n\n  const internalDataHex = bufferToHex(internalData as Buffer);\n  if (internalDataHex.startsWith(ERC1155SafeTransferTypeMethodId)) {\n    let tokenId;\n    let value;\n\n    [from, receiver, tokenId, value, userSentData] = getRawDecoded(\n      ERC1155SafeTransferTypes,\n      getBufferedByteCode(ERC1155SafeTransferTypeMethodId, internalDataHex)\n    );\n\n    tokenIds = [new BigNumber(bufferToHex(tokenId)).toFixed()];\n    values = [new BigNumber(bufferToHex(value)).toFixed()];\n  } else if (bufferToHex(internalData as Buffer).startsWith(ERC1155BatchTransferTypeMethodId)) {\n    let tempTokenIds, tempValues;\n    [from, receiver, tempTokenIds, tempValues, userSentData] = getRawDecoded(\n      ERC1155BatchTransferTypes,\n      getBufferedByteCode(ERC1155BatchTransferTypeMethodId, internalDataHex)\n    );\n    tokenIds = tempTokenIds.map((x) => new BigNumber(bufferToHex(x)).toFixed());\n    values = tempValues.map((x) => new BigNumber(bufferToHex(x)).toFixed());\n  } else {\n    throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);\n  }\n\n  return {\n    to: addHexPrefix(receiver),\n    from: addHexPrefix(from),\n    expireTime: bufferToInt(expireTime as Buffer),\n    amount: new BigNumber(bufferToHex(amount as Buffer)).toFixed(),\n    tokenIds,\n    values,\n    sequenceId: bufferToInt(sequenceId as Buffer),\n    signature: bufferToHex(signature as Buffer),\n    tokenContractAddress: addHexPrefix(to as string),\n    userData: userSentData,\n  };\n}\n\n/**\n * Decode the given ABI-encoded transfer data for the sendMultisig function and return parsed fields\n *\n * @param data The data to decode\n * @returns parsed transfer data\n */\nexport function decodeNativeTransferData(data: string): NativeTransferData {\n  if (!data.startsWith(sendMultisigMethodId)) {\n    throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);\n  }\n\n  const [to, amount, internalData, expireTime, sequenceId, signature] = getRawDecoded(\n    sendMultiSigTypes,\n    getBufferedByteCode(sendMultisigMethodId, data)\n  );\n\n  return {\n    to: addHexPrefix(to as string),\n    amount: new BigNumber(bufferToHex(amount as Buffer)).toFixed(),\n    expireTime: bufferToInt(expireTime as Buffer),\n    sequenceId: bufferToInt(sequenceId as Buffer),\n    signature: bufferToHex(signature as Buffer),\n    data: bufferToHex(internalData as Buffer),\n  };\n}\n\n/**\n * Decode the given ABI-encoded flush tokens data and return parsed fields\n *\n * @param data The data to decode\n * @returns parsed transfer data\n */\nexport function decodeFlushTokensData(data: string): FlushTokensData {\n  if (!data.startsWith(flushForwarderTokensMethodId)) {\n    throw new BuildTransactionError(`Invalid transfer bytecode: ${data}`);\n  }\n\n  const [forwarderAddress, tokenAddress] = getRawDecoded(\n    flushTokensTypes,\n    getBufferedByteCode(flushForwarderTokensMethodId, data)\n  );\n\n  return {\n    forwarderAddress: addHexPrefix(forwarderAddress as string),\n    tokenAddress: addHexPrefix(tokenAddress as string),\n  };\n}\n\n/**\n * Classify the given transaction data based as a transaction type.\n * ETH transactions are defined by the first 8 bytes of the transaction data, also known as the method id\n *\n * @param {string} data The data to classify the transaction with\n * @returns {TransactionType} The classified transaction type\n */\nexport function classifyTransaction(data: string): TransactionType {\n  if (data.length < 10) {\n    // contract calls must have at least 4 bytes (method id) and '0x'\n    // if it doesn't have enough data to be a contract call it must be a single sig send\n    return TransactionType.SingleSigSend;\n  }\n\n  // TODO(STLX-1970): validate if we are going to constraint to some methods allowed\n  let transactionType = transactionTypesMap[data.slice(0, 10).toLowerCase()];\n  if (transactionType === undefined) {\n    transactionType = TransactionType.ContractCall;\n  }\n\n  return transactionType;\n}\n\n/**\n * A transaction types map according to the starting part of the encoded data\n */\nconst transactionTypesMap = {\n  [walletInitializationFirstBytes]: TransactionType.WalletInitialization,\n  [recoveryWalletInitializationFirstBytes]: TransactionType.RecoveryWalletDeployment,\n  [v1CreateWalletMethodId]: TransactionType.WalletInitialization,\n  [createForwarderMethodId]: TransactionType.AddressInitialization,\n  [v1CreateForwarderMethodId]: TransactionType.AddressInitialization,\n  [v4CreateForwarderMethodId]: TransactionType.AddressInitialization,\n  [sendMultisigMethodId]: TransactionType.Send,\n  [flushForwarderTokensMethodId]: TransactionType.FlushTokens,\n  [flushCoinsMethodId]: TransactionType.FlushCoins,\n  [sendMultisigTokenMethodId]: TransactionType.Send,\n  [LockMethodId]: TransactionType.StakingLock,\n  [VoteMethodId]: TransactionType.StakingVote,\n  [ActivateMethodId]: TransactionType.StakingActivate,\n  [UnvoteMethodId]: TransactionType.StakingUnvote,\n  [UnlockMethodId]: TransactionType.StakingUnlock,\n  [WithdrawMethodId]: TransactionType.StakingWithdraw,\n};\n\n/**\n *\n * @param {number} num number to be converted to hex\n * @returns {string} the hex number\n */\nexport function numberToHexString(num: number): string {\n  const hex = num.toString(16);\n  return hex.length % 2 === 0 ? '0x' + hex : '0x0' + hex;\n}\n\n/**\n *\n * @param {string} hex The hex string to be converted\n * @returns {number} the resulting number\n */\nexport function hexStringToNumber(hex: string): number {\n  return parseInt(hex.slice(2), 16);\n}\n\n/**\n * Generates an address of the forwarder address to be deployed\n *\n * @param {string} contractAddress the address which is creating this new address\n * @param {number} contractCounter the nonce of the contract address\n * @returns {string} the calculated forwarder contract address\n */\nexport function calculateForwarderAddress(contractAddress: string, contractCounter: number): string {\n  const forwarderAddress = generateAddress(\n    Buffer.from(stripHexPrefix(contractAddress), 'hex'),\n    Buffer.from(padToEven(stripHexPrefix(numberToHexString(contractCounter))), 'hex')\n  );\n  return addHexPrefix(forwarderAddress.toString('hex'));\n}\n\n/**\n * Calculate the forwarder v1 address that will be generated if `creatorAddress` creates it with salt `salt`\n * and initcode `inicode using the create2 opcode\n * @param {string} creatorAddress The address that is sending the tx to create a new address, hex string\n * @param {string} salt The salt to create the address with using create2, hex string\n * @param {string} initcode The initcode that will be deployed to the address, hex string\n * @return {string} The calculated address\n */\nexport function calculateForwarderV1Address(creatorAddress: string, salt: string, initcode: string): string {\n  const forwarderV1Address = generateAddress2(\n    Buffer.from(stripHexPrefix(creatorAddress), 'hex'),\n    Buffer.from(stripHexPrefix(salt), 'hex'),\n    Buffer.from(padToEven(stripHexPrefix(initcode)), 'hex')\n  );\n  return addHexPrefix(forwarderV1Address.toString('hex'));\n}\n\n/**\n * Take the implementation address for the proxy contract, and get the binary initcode for the associated proxy\n * @param {string} implementationAddress The address of the implementation contract for the proxy\n * @return {string} Binary hex string of the proxy\n */\nexport function getProxyInitcode(implementationAddress: string): string {\n  const target = stripHexPrefix(implementationAddress.toLowerCase()).padStart(40, '0');\n\n  // bytecode of the proxy, from:\n  // https://github.com/BitGo/eth-multisig-v4/blob/d546a937f90f93e83b3423a5bf933d1d77c677c3/contracts/CloneFactory.sol#L42-L56\n  return `0x3d602d80600a3d3981f3363d3d373d3d3d363d73${target}5af43d82803e903d91602b57fd5bf3`;\n}\n\n/**\n * Convert the given signature parts to a string representation\n *\n * @param {SignatureParts} sig The signature to convert to string\n * @returns {string} String representation of the signature\n */\nexport function toStringSig(sig: SignatureParts): string {\n  return bufferToHex(\n    Buffer.concat([\n      setLengthLeft(Buffer.from(stripHexPrefix(sig.r), 'hex'), 32),\n      setLengthLeft(Buffer.from(stripHexPrefix(sig.s), 'hex'), 32),\n      toBuffer(sig.v),\n    ])\n  );\n}\n\n/**\n * Return whether or not the given tx data has a signature\n *\n * @param {TxData} txData The transaction data to check for signature\n * @returns {boolean} true if the tx has a signature, else false\n */\nexport function hasSignature(txData: TxData): boolean {\n  return (\n    txData.v !== undefined &&\n    txData.r !== undefined &&\n    txData.s !== undefined &&\n    txData.v.length > 0 &&\n    txData.r.length > 0 &&\n    txData.s.length > 0\n  );\n}\n\ntype RecursiveBufferOrString = string | Buffer | BN | RecursiveBufferOrString[];\n\n/**\n * Get the raw data decoded for some types\n *\n * @param {string[]} types ABI types definition\n * @param {Buffer} serializedArgs encoded args\n * @returns {Buffer[]} the decoded raw\n */\nexport function getRawDecoded(types: string[], serializedArgs: Buffer): RecursiveBufferOrString[] {\n  function normalize(v: unknown, i: number): unknown {\n    if (BN.isBN(v)) {\n      return v;\n    } else if (typeof v === 'string' || Buffer.isBuffer(v)) {\n      return v;\n    } else if (Array.isArray(v)) {\n      return v.map(normalize);\n    } else {\n      throw new Error(`For ${types}[${i}] got ${typeof v}`);\n    }\n  }\n\n  return EthereumAbi.rawDecode(types, serializedArgs).map(normalize);\n}\n\n/**\n * Get the buffered bytecode from rawData using a methodId as delimiter\n *\n * @param {string} methodId the hex encoded method Id\n * @param {string} rawData the hex encoded raw data\n * @returns {Buffer} data buffered bytecode\n */\nexport function getBufferedByteCode(methodId: string, rawData: string): Buffer {\n  const splitBytecode = rawData.split(methodId);\n  if (splitBytecode.length !== 2) {\n    throw new BuildTransactionError(`Invalid send bytecode: ${rawData}`);\n  }\n  if (splitBytecode[1].length % 2 !== 0) {\n    throw new BuildTransactionError(`Invalid send bytecode: ${rawData} (wrong lenght)`);\n  }\n  return Buffer.from(splitBytecode[1], 'hex');\n}\n\n/**\n * Get the statics coin object matching a given contract address if it exists\n *\n * @param tokenContractAddress The contract address to match against\n * @returns statics BaseCoin object for the matching token\n */\nexport function getToken(tokenContractAddress: string, network: BaseNetwork): Readonly<BaseCoin> | undefined {\n  const tokens = coins.filter((coin) => {\n    if (coin instanceof ContractAddressDefinedToken) {\n      return (\n        coin.network.type === network.type && coin.contractAddress.toLowerCase() === tokenContractAddress.toLowerCase()\n      );\n    }\n    return false;\n  });\n\n  // if length of tokens is 1, return the first, else return undefined\n  // Can't directly index into tokens, or call `length`, so we use map to get an array\n  const tokensArray = tokens.map((token) => token);\n  if (tokensArray.length >= 1) {\n    // there should never be two tokens with the same contract address, so we assert that here\n    assert(tokensArray.length === 1);\n    return tokensArray[0];\n  }\n  return undefined;\n}\n\n/**\n * Returns the create wallet method calling data for v1 wallets\n *\n * @param {string[]} walletOwners - wallet owner addresses for wallet initialization transactions\n * @param {string} salt - The salt for wallet initialization transactions\n * @returns {string} - the createWallet method encoded\n */\nexport function getV1WalletInitializationData(walletOwners: string[], salt: string): string {\n  const saltBuffer = setLengthLeft(toBuffer(salt), 32);\n  const params = [walletOwners, saltBuffer];\n  const method = EthereumAbi.methodID('createWallet', createV1WalletTypes);\n  const args = EthereumAbi.rawEncode(createV1WalletTypes, params);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Returns the create address method calling data for v1, v2, v4 forwarders\n *\n * @param {string} baseAddress - The address of the wallet contract\n * @param {string} salt - The salt for address initialization transactions\n * @param {string} feeAddress - The fee address for the enterprise\n * @returns {string} - the createForwarder method encoded\n */\nexport function getV1AddressInitializationData(baseAddress: string, salt: string, feeAddress?: string): string {\n  const saltBuffer = setLengthLeft(toBuffer(salt), 32);\n  const { createForwarderParams, createForwarderTypes } = getCreateForwarderParamsAndTypes(\n    baseAddress,\n    saltBuffer,\n    feeAddress\n  );\n\n  const method = EthereumAbi.methodID('createForwarder', createForwarderTypes);\n  const args = EthereumAbi.rawEncode(createForwarderTypes, createForwarderParams);\n  return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n}\n\n/**\n * Returns the create address method calling data for all forwarder versions\n *\n * @param {number} forwarderVersion - The version of the forwarder to create\n * @param {string} baseAddress - The address of the wallet contract\n * @param {string} salt - The salt for address initialization transactions\n * @param {string} feeAddress - The fee address for the enterprise\n * @returns {string} - the createForwarder method encoded\n *\n */\nexport function getAddressInitDataAllForwarderVersions(\n  forwarderVersion: number,\n  baseAddress: string,\n  salt: string,\n  feeAddress?: string\n): string {\n  if (forwarderVersion === defaultForwarderVersion) {\n    return getAddressInitializationData();\n  } else {\n    return getV1AddressInitializationData(baseAddress, salt, feeAddress);\n  }\n}\n\n/**\n * Returns the createForwarderTypes and createForwarderParams for all forwarder versions\n *\n * @param {string} baseAddress - The address of the wallet contract\n * @param {Buffer} saltBuffer - The salt for address initialization transaction\n * @param {string} feeAddress - The fee address for the enterprise\n * @returns {createForwarderParams: (string | Buffer)[], createForwarderTypes: string[]}\n */\nexport function getCreateForwarderParamsAndTypes(\n  baseAddress: string,\n  saltBuffer: Buffer,\n  feeAddress?: string\n): { createForwarderParams: (string | Buffer)[]; createForwarderTypes: string[] } {\n  let createForwarderParams = [baseAddress, saltBuffer];\n  let createForwarderTypes = createV1ForwarderTypes;\n  if (feeAddress) {\n    createForwarderParams = [baseAddress, feeAddress, saltBuffer];\n    createForwarderTypes = createV4ForwarderTypes;\n  }\n  return { createForwarderParams, createForwarderTypes };\n}\n\n/**\n * Decode the given ABI-encoded create forwarder data and return parsed fields\n *\n * @param data The data to decode\n * @returns parsed transfer data\n */\nexport function decodeForwarderCreationData(data: string): ForwarderInitializationData {\n  if (\n    !(\n      data.startsWith(v4CreateForwarderMethodId) ||\n      data.startsWith(v1CreateForwarderMethodId) ||\n      data.startsWith(createForwarderMethodId)\n    )\n  ) {\n    throw new BuildTransactionError(`Invalid address bytecode: ${data}`);\n  }\n\n  if (data.startsWith(createForwarderMethodId)) {\n    return {\n      baseAddress: undefined,\n      addressCreationSalt: undefined,\n      feeAddress: undefined,\n    };\n  } else if (data.startsWith(v1CreateForwarderMethodId)) {\n    const [baseAddress, saltBuffer] = getRawDecoded(\n      createV1ForwarderTypes,\n      getBufferedByteCode(v1CreateForwarderMethodId, data)\n    );\n\n    return {\n      baseAddress: addHexPrefix(baseAddress as string),\n      addressCreationSalt: bufferToHex(saltBuffer as Buffer),\n      feeAddress: undefined,\n    } as const;\n  } else {\n    const [baseAddress, feeAddress, saltBuffer] = getRawDecoded(\n      createV4ForwarderTypes,\n      getBufferedByteCode(v4CreateForwarderMethodId, data)\n    );\n\n    return {\n      baseAddress: addHexPrefix(baseAddress as string),\n      addressCreationSalt: bufferToHex(saltBuffer as Buffer),\n      feeAddress: addHexPrefix(feeAddress as string),\n    } as const;\n  }\n}\n\n/**\n * Make a query to explorer for information such as balance, token balance, solidity calls\n * @param {Object} query key-value pairs of parameters to append after /api\n * @param {string} token the API token to use for the request\n * @param {string} explorerUrl the URL of the explorer\n * @returns {Promise<Object>} response from explorer\n */\nexport async function recoveryBlockchainExplorerQuery(\n  query: Record<string, string>,\n  explorerUrl: string,\n  token?: string\n): Promise<Record<string, unknown>> {\n  if (token) {\n    query.apikey = token;\n  }\n  const response = await request.get(`${explorerUrl}/api`).query(query);\n\n  if (!response.ok) {\n    throw new Error('could not reach explorer');\n  }\n\n  if (response.body.status === '0' && response.body.message === 'NOTOK') {\n    throw new Error('Explorer rate limit reached');\n  }\n  return response.body;\n}\n"]}