@bitgo/sdk-coin-eos 1.0.1-rc.0

package/dist/src/eos.js

@@ -0,0 +1,872 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.Eos = void 0;
+/**
+ * @prettier
+ */
+const bignumber_js_1 = require("bignumber.js");
+const bip32 = __importStar(require("bip32"));
+const crypto_1 = require("crypto");
+const eosjs_1 = require("eosjs");
+const ecc = __importStar(require("eosjs-ecc"));
+const _ = __importStar(require("lodash"));
+const querystring = __importStar(require("querystring"));
+const request = __importStar(require("superagent"));
+const url = __importStar(require("url"));
+const eosabiprovider_1 = require("./eosutil/eosabiprovider");
+const utils_1 = require("./lib/utils");
+const sdk_core_1 = require("@bitgo/sdk-core");
+class NoopJsonRpc extends eosjs_1.JsonRpc {
+    constructor() {
+        super('');
+    }
+}
+class NoopSignatureProvider {
+    async getAvailableKeys() {
+        throw new Error('noop signature provider implementation has no available keys');
+    }
+    async sign(args) {
+        throw new Error('noop implementation is unable to sign');
+    }
+}
+class Eos extends sdk_core_1.BaseCoin {
+    static createInstance(bitgo) {
+        return new Eos(bitgo);
+    }
+    getChainId() {
+        return 'aca376f206b8fc25a6ed44dbdc66547c36c6c33e3a119ffbeaef943642f0e906'; // mainnet chain id
+    }
+    getChain() {
+        return 'eos';
+    }
+    getFamily() {
+        return 'eos';
+    }
+    getFullName() {
+        return 'EOS';
+    }
+    getBaseFactor() {
+        return 1e4;
+    }
+    /**
+     * Flag for sending value of 0
+     * @returns {boolean} True if okay to send 0 value, false otherwise
+     */
+    valuelessTransferAllowed() {
+        return true;
+    }
+    /**
+     * Get URLs of some active public nodes
+     */
+    getPublicNodeUrls() {
+        return sdk_core_1.Environments[this.bitgo.getEnv()].eosNodeUrls;
+    }
+    /**
+     * Generate secp256k1 key pair
+     *
+     * @param seed - Seed from which the new keypair should be generated, otherwise a random seed is used
+     */
+    generateKeyPair(seed) {
+        if (!seed) {
+            // An extended private key has both a normal 256 bit private key and a 256
+            // bit chain code, both of which must be random. 512 bits is therefore the
+            // maximum entropy and gives us maximum security against cracking.
+            seed = crypto_1.randomBytes(512 / 8);
+        }
+        const extendedKey = bip32.fromSeed(seed);
+        const xpub = extendedKey.neutered().toBase58();
+        return {
+            pub: xpub,
+            prv: extendedKey.toBase58(),
+        };
+    }
+    /**
+     * Return boolean indicating whether input is valid public key for the coin.
+     *
+     * @param pub - the pub to be checked
+     */
+    isValidPub(pub) {
+        try {
+            return bip32.fromBase58(pub).isNeutered();
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Return boolean indicating whether input is valid seed for the coin
+     *
+     * @param prv - the prv to be checked
+     */
+    isValidPrv(prv) {
+        try {
+            return !bip32.fromBase58(prv).isNeutered();
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Evaluates whether a memo is valid
+     *
+     * @param value - the memo to be checked
+     */
+    isValidMemo({ value }) {
+        return _.isString(value) && value.length <= 256;
+    }
+    /**
+     * Return boolean indicating whether a memo id is valid
+     *
+     * @param memoId - the memo id to be checked
+     */
+    isValidMemoId(memoId) {
+        return this.isValidMemo({ value: memoId });
+    }
+    /**
+     * Process address into address and memo id
+     * @param address - the address
+     */
+    getAddressDetails(address) {
+        const destinationDetails = url.parse(address);
+        const destinationAddress = destinationDetails.pathname;
+        if (!destinationAddress) {
+            throw new sdk_core_1.InvalidAddressError(`failed to parse address: ${address}`);
+        }
+        // EOS addresses have to be "human readable", which means up to 12 characters and only a-z1-5., i.e.mtoda1.bitgo
+        // source: https://developers.eos.io/eosio-cpp/docs/naming-conventions
+        if (!/^[a-z1-5.]*$/.test(destinationAddress) || destinationAddress.length > Eos.ADDRESS_LENGTH) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
+        }
+        // address doesn't have a memo id
+        if (destinationDetails.pathname === address) {
+            return {
+                address: address,
+                memoId: undefined,
+            };
+        }
+        if (!destinationDetails.query) {
+            throw new sdk_core_1.InvalidAddressError(`failed to parse query string: ${address}`);
+        }
+        const queryDetails = querystring.parse(destinationDetails.query);
+        if (!queryDetails.memoId) {
+            // if there are more properties, the query details need to contain the memoId property
+            throw new sdk_core_1.InvalidAddressError(`invalid property in address: ${address}`);
+        }
+        if (Array.isArray(queryDetails.memoId) && queryDetails.memoId.length !== 1) {
+            // valid addresses can only contain one memo id
+            throw new sdk_core_1.InvalidAddressError(`invalid address '${address}', must contain exactly one memoId`);
+        }
+        const [memoId] = _.castArray(queryDetails.memoId);
+        if (!this.isValidMemoId(memoId)) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: '${address}', memoId is not valid`);
+        }
+        return {
+            address: destinationAddress,
+            memoId,
+        };
+    }
+    /**
+     * Convert a currency amount represented in base units (satoshi, wei, atoms, drops, stroops)
+     * to big units (btc, eth, xrp, xlm)
+     */
+    baseUnitsToBigUnits(baseUnits) {
+        const dividend = this.getBaseFactor();
+        const bigNumber = new bignumber_js_1.BigNumber(baseUnits).dividedBy(dividend);
+        // set the format so commas aren't added to large coin amounts
+        return bigNumber.toFormat(4, null, { groupSeparator: '', decimalSeparator: '.' });
+    }
+    /**
+     * Validate and return address with appended memo id
+     *
+     * @param address
+     * @param memoId
+     */
+    normalizeAddress({ address, memoId }) {
+        if (memoId && this.isValidMemoId(memoId)) {
+            return `${address}?memoId=${memoId}`;
+        }
+        return address;
+    }
+    /**
+     * Return boolean indicating whether input is valid public key for the coin
+     *
+     * @param address - the address to be checked
+     */
+    isValidAddress(address) {
+        try {
+            const addressDetails = this.getAddressDetails(address);
+            return address === this.normalizeAddress(addressDetails);
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * @param address - the address to verify
+     * @param rootAddress - the wallet's root address
+     * @return true iff address is a wallet address (based on rootAddress)
+     */
+    isWalletAddress({ address, rootAddress }) {
+        if (!rootAddress || !_.isString(rootAddress)) {
+            throw new Error('missing required string rootAddress');
+        }
+        if (!this.isValidAddress(address)) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
+        }
+        const addressDetails = this.getAddressDetails(address);
+        const rootAddressDetails = this.getAddressDetails(rootAddress);
+        if (!addressDetails || !rootAddressDetails) {
+            return false;
+        }
+        if (addressDetails.address !== rootAddressDetails.address) {
+            throw new sdk_core_1.UnexpectedAddressError(`address validation failure: ${addressDetails.address} vs ${rootAddressDetails.address}`);
+        }
+        return true;
+    }
+    /**
+     * Assemble keychain and half-sign prebuilt transaction
+     *
+     * @param params
+     * @param params.txPrebuild {Object} prebuild object returned by platform
+     * @param params.prv {String} user prv
+     * @returns {Promise<EosSignedTransaction>}
+     */
+    async signTransaction(params) {
+        const prv = params.prv;
+        const txHex = params.txPrebuild.txHex;
+        const transaction = params.txPrebuild.transaction;
+        const signBuffer = Buffer.from(txHex, 'hex');
+        const privateKeyBuffer = bip32.fromBase58(prv).privateKey;
+        if (!privateKeyBuffer) {
+            throw new Error('no privateKey');
+        }
+        const signature = ecc.Signature.sign(signBuffer, privateKeyBuffer).toString();
+        transaction.signatures.push(signature);
+        const txParams = {
+            transaction,
+            txHex,
+            recipients: params.txPrebuild.recipients,
+            headers: params.txPrebuild.headers,
+            txid: params.txPrebuild.txid,
+        };
+        return { halfSigned: txParams };
+    }
+    validateStakeActionData(stakeActionData) {
+        if (stakeActionData.from !== stakeActionData.receiver) {
+            throw new Error(`staker (${stakeActionData.from}) and receiver (${stakeActionData.receiver}) must be the same`);
+        }
+        if (stakeActionData.transfer !== 0) {
+            throw new Error('cannot transfer funds as part of delegatebw action');
+        }
+        // stake_cpu_quantity is used as the amount because the BitGo platform only stakes cpu for voting transactions
+        return {
+            address: stakeActionData.from,
+            amount: this.bigUnitsToBaseUnits(stakeActionData.stake_cpu_quantity.split(' ')[0]),
+        };
+    }
+    validateUnstakeActionData(unstakeActionData) {
+        if (unstakeActionData.from !== unstakeActionData.receiver) {
+            throw new Error(`unstaker (${unstakeActionData.from}) and receiver (${unstakeActionData.receiver}) must be the same`);
+        }
+        const cpuAmount = new bignumber_js_1.BigNumber(unstakeActionData.unstake_cpu_quantity.split(' ')[0]);
+        const netAmount = new bignumber_js_1.BigNumber(unstakeActionData.unstake_net_quantity.split(' ')[0]);
+        const totalAmount = cpuAmount.plus(netAmount).toNumber();
+        return {
+            address: unstakeActionData.receiver,
+            amount: this.bigUnitsToBaseUnits(totalAmount),
+        };
+    }
+    static validateVoteActionData(voteActionData) {
+        const proxyIsEmpty = _.isEmpty(voteActionData.proxy);
+        const producersIsEmpty = _.isEmpty(voteActionData.producers);
+        if ((proxyIsEmpty && producersIsEmpty) || (!proxyIsEmpty && !producersIsEmpty)) {
+            throw new Error('voting transactions must specify either producers or proxy to vote for');
+        }
+        return {
+            address: voteActionData.voter,
+            proxy: voteActionData.proxy,
+            producers: voteActionData.producers,
+        };
+    }
+    static createTransactionIdHex(serializedTransactionBuffer) {
+        return crypto_1.createHash('sha256').update(serializedTransactionBuffer).digest().toString('hex');
+    }
+    /**
+     * Deserialize a transaction
+     * @param transaction
+     * @param headers
+     */
+    async deserializeTransaction({ transaction, headers, }) {
+        // create an eosjs API client
+        const api = new eosjs_1.Api({
+            abiProvider: new eosabiprovider_1.OfflineAbiProvider(),
+            rpc: new NoopJsonRpc(),
+            signatureProvider: new NoopSignatureProvider(),
+            chainId: this.getChainId(),
+            // Use a custom TextDecoder as the global TextDecoder leads to crashes in OVC / Electron.
+            textDecoder: new utils_1.StringTextDecoder(),
+            textEncoder: new TextEncoder(),
+        });
+        // type guards
+        const isTransferActionData = (txActionData) => {
+            return (txActionData.from !== undefined &&
+                txActionData.to !== undefined &&
+                txActionData.quantity !== undefined);
+        };
+        const isStakeActionData = (txActionData) => {
+            return (txActionData.from !== undefined &&
+                txActionData.receiver !== undefined &&
+                txActionData.transfer !== undefined &&
+                txActionData.stake_cpu_quantity !== undefined);
+        };
+        const isUnstakeActionData = (txActionData) => {
+            return (txActionData.from !== undefined &&
+                txActionData.receiver !== undefined &&
+                txActionData.unstake_cpu_quantity !== undefined &&
+                txActionData.unstake_net_quantity !== undefined);
+        };
+        const isVoteActionData = (txActionData) => {
+            return txActionData.voter !== undefined;
+        };
+        const isRefundActionData = (txActionData) => {
+            return txActionData.owner !== undefined;
+        };
+        // deserializeTransaction
+        const serializedTxBuffer = Buffer.from(transaction.packed_trx, 'hex');
+        const deserializedTxJsonFromPackedTrx = await api.deserializeTransactionWithActions(serializedTxBuffer);
+        if (!deserializedTxJsonFromPackedTrx) {
+            throw new Error('could not process transaction from txHex');
+        }
+        const tx = deserializedTxJsonFromPackedTrx;
+        // validate context free actions
+        if (tx.context_free_actions.length !== 0) {
+            if (tx.context_free_actions.length !== 1) {
+                throw new Error('number of context free actions must be 1');
+            }
+            if (!_.isEqual(_.pick(tx.context_free_actions[0], ['account', 'authorization', 'name']), {
+                account: 'eosio.null',
+                authorization: [],
+                name: 'nonce',
+            }) ||
+                _.isEmpty(tx.context_free_actions[0].data)) {
+                throw new Error('the context free action is invalid');
+            }
+        }
+        // Only support transactions with one (transfer | voteproducer) or two (delegatebw & voteproducer) actions
+        if (tx.actions.length !== 1 && tx.actions.length !== 2) {
+            throw new Error(`invalid number of actions: ${tx.actions.length}`);
+        }
+        const txAction = tx.actions[0];
+        if (!txAction) {
+            throw new Error('missing transaction action');
+        }
+        if (txAction.name === 'transfer') {
+            // Transfers should only have 1 action
+            if (tx.actions.length !== 1) {
+                throw new Error(`transfers should only have 1 action: ${tx.actions.length} given`);
+            }
+            if (!isTransferActionData(txAction.data)) {
+                throw new Error('Invalid or incomplete transfer action data');
+            }
+            const transferActionData = txAction.data;
+            tx.address = transferActionData.to;
+            tx.amount = this.bigUnitsToBaseUnits(transferActionData.quantity.split(' ')[0]);
+            tx.memo = transferActionData.memo;
+        }
+        else if (txAction.name === 'delegatebw') {
+            // The delegatebw action should only be part of voting transactions
+            if (tx.actions.length !== 2) {
+                throw new Error(`staking transactions that include the delegatebw action should have 2 actions: ${tx.actions.length} given`);
+            }
+            const txAction2 = tx.actions[1];
+            if (txAction2.name !== 'voteproducer') {
+                throw new Error(`invalid staking transaction action: ${txAction2.name}, expecting: voteproducer`);
+            }
+            if (!isStakeActionData(txAction.data) || !isVoteActionData(txAction2.data)) {
+                throw new Error('Invalid or incomplete stake or vote action data');
+            }
+            const stakeActionData = txAction.data;
+            const voteActionData = txAction2.data;
+            const deserializedStakeAction = this.validateStakeActionData(stakeActionData);
+            const deserializedVoteAction = Eos.validateVoteActionData(voteActionData);
+            if (deserializedStakeAction.address !== deserializedVoteAction.address) {
+                throw new Error(`staker (${deserializedStakeAction.address}) and voter (${deserializedVoteAction.address}) must be the same`);
+            }
+            tx.amount = deserializedStakeAction.amount;
+            tx.proxy = deserializedVoteAction.proxy;
+            tx.producers = deserializedVoteAction.producers;
+        }
+        else if (txAction.name === 'voteproducer') {
+            if (tx.actions.length > 2) {
+                throw new Error('voting transactions should not have more than 2 actions');
+            }
+            let deserializedStakeAction;
+            if (tx.actions.length === 2) {
+                const txAction2 = tx.actions[1];
+                if (txAction2.name !== 'delegatebw') {
+                    throw new Error(`invalid staking transaction action: ${txAction2.name}, expecting: delegatebw`);
+                }
+                if (!isStakeActionData(txAction.data)) {
+                    throw new Error('Invalid or incomplete stake action data');
+                }
+                const stakeActionData = txAction.data;
+                deserializedStakeAction = this.validateStakeActionData(stakeActionData);
+            }
+            if (!isVoteActionData(txAction.data)) {
+                throw new Error('Invalid or incomplete vote action data');
+            }
+            const voteActionData = txAction.data;
+            const deserializedVoteAction = Eos.validateVoteActionData(voteActionData);
+            if (!!deserializedStakeAction && deserializedStakeAction.address !== deserializedVoteAction.address) {
+                throw new Error(`staker (${deserializedStakeAction.address}) and voter (${deserializedVoteAction.address}) must be the same`);
+            }
+            tx.amount = !!deserializedStakeAction ? deserializedStakeAction.amount : '0';
+            tx.proxy = deserializedVoteAction.proxy;
+            tx.producers = deserializedVoteAction.producers;
+        }
+        else if (txAction.name === 'undelegatebw') {
+            if (tx.actions.length !== 1) {
+                throw new Error(`unstake should only have 1 action: ${tx.actions.length} given`);
+            }
+            if (!isUnstakeActionData(txAction.data)) {
+                throw new Error('Invalid or incomplete unstake action data');
+            }
+            const unstakeActionData = txAction.data;
+            const deserializedUnstakeAction = this.validateUnstakeActionData(unstakeActionData);
+            tx.amount = deserializedUnstakeAction.amount;
+            tx.address = deserializedUnstakeAction.address;
+        }
+        else if (txAction.name === 'refund') {
+            if (tx.actions.length !== 1) {
+                throw new Error(`refund should only have 1 action: ${tx.actions.length} given`);
+            }
+            if (!isRefundActionData(txAction.data)) {
+                throw new Error('Invalid or incomplete refund action data');
+            }
+            const refundActionData = txAction.data;
+            tx.address = refundActionData.owner;
+            tx.amount = '0';
+        }
+        else {
+            throw new Error(`invalid action: ${txAction.name}`);
+        }
+        // Get the tx id if tx headers were provided
+        if (headers) {
+            let rebuiltTransaction;
+            try {
+                // remove Z at the end
+                if (headers.expiration.endsWith('Z')) {
+                    headers.expiration = headers.expiration.slice(0, -1);
+                }
+                rebuiltTransaction = await api.transact({ ...tx, ...headers }, { sign: false, broadcast: false });
+            }
+            catch (e) {
+                throw new Error('Could not build transaction to get transaction_id. Please check transaction or headers format.');
+            }
+            tx.transaction_id = Eos.createTransactionIdHex(rebuiltTransaction.serializedTransaction);
+        }
+        return tx;
+    }
+    /**
+     * Explain/parse transaction
+     * @param params - ExplainTransactionOptions
+     */
+    async explainTransaction(params) {
+        let transaction;
+        try {
+            transaction = await this.deserializeTransaction(params);
+        }
+        catch (e) {
+            throw new Error('invalid EOS transaction or headers: ' + e.toString());
+        }
+        return {
+            displayOrder: [
+                'id',
+                'outputAmount',
+                'changeAmount',
+                'outputs',
+                'changeOutputs',
+                'fee',
+                'memo',
+                'proxy',
+                'producers',
+            ],
+            id: transaction.transaction_id,
+            changeOutputs: [],
+            outputAmount: transaction.amount,
+            changeAmount: 0,
+            outputs: !!transaction.address ? [{ address: transaction.address, amount: transaction.amount }] : [],
+            fee: {},
+            memo: transaction.memo,
+            proxy: transaction.proxy,
+            producers: transaction.producers,
+        };
+    }
+    /**
+     * @deprecated
+     */
+    initiateRecovery(params) {
+        throw new Error('deprecated method');
+    }
+    /**
+     * Make a request to one of the public EOS nodes available
+     * @param params.endpoint
+     * @param params.payload
+     */
+    async getDataFromNode(params) {
+        const nodeUrls = this.getPublicNodeUrls();
+        for (const nodeUrl of nodeUrls) {
+            try {
+                return await request.post(nodeUrl + params.endpoint).send(params.payload);
+            }
+            catch (e) {
+                // let's hope another call succeeds
+            }
+        }
+        throw new Error(`Unable to call endpoint: ${params.endpoint} from nodes: ${_.join(nodeUrls, ', ')}`);
+    }
+    /**
+     * Get EOS chain info from a public node
+     */
+    async getChainInfoFromNode() {
+        const response = await this.getDataFromNode({ endpoint: '/v1/chain/get_info' });
+        if (response.status !== 200) {
+            throw new Error('Unable to fetch chain info');
+        }
+        return response.body;
+    }
+    /**
+     * Get data specific to an account from a public node
+     * @param address
+     */
+    async getAccountFromNode({ address }) {
+        const response = await this.getDataFromNode({
+            endpoint: '/v1/chain/get_account',
+            payload: { account_name: address },
+        });
+        if (response.status !== 200) {
+            throw new Error('Account not found');
+        }
+        return response.body;
+    }
+    /**
+     * Get block data from a public node using its block number or block id
+     * @param blockNumOrId
+     */
+    async getBlockFromNode({ blockNumOrId }) {
+        const response = await this.getDataFromNode({
+            endpoint: '/v1/chain/get_block',
+            payload: { block_num_or_id: blockNumOrId },
+        });
+        if (response.status !== 200) {
+            throw new Error('Block not found');
+        }
+        return response.body;
+    }
+    /**
+     * Get headers for an EOS tx from a public node
+     */
+    async getTransactionHeadersFromNode() {
+        const chainInfo = await this.getChainInfoFromNode();
+        const headBlockInfoResult = await this.getBlockFromNode({ blockNumOrId: chainInfo.head_block_num });
+        const expireSeconds = 28800; // maximum tx expire time of 8h
+        const chainDate = new Date(chainInfo.head_block_time + 'Z').getTime();
+        const expirationDate = new Date(chainDate + expireSeconds * 1000);
+        return {
+            expiration: expirationDate.toISOString(),
+            ref_block_num: chainInfo.head_block_num & 0xffff,
+            ref_block_prefix: headBlockInfoResult.ref_block_prefix,
+        };
+    }
+    getTransferAction({ recipient, sender, amount, memo }) {
+        return {
+            account: 'eosio.token',
+            name: 'transfer',
+            authorization: [
+                {
+                    actor: sender,
+                    permission: 'active',
+                },
+            ],
+            data: {
+                from: sender,
+                to: recipient,
+                quantity: `${this.baseUnitsToBigUnits(amount)} EOS`,
+                memo: !_.isNil(memo) ? memo : '', // Memo must be defined, set it to empty string if it is not
+            },
+        };
+    }
+    /**
+     * Sign a transaction with a key
+     * @param signableTx
+     * @param signingKey
+     */
+    signTx(signableTx, signingKey) {
+        const signBuffer = Buffer.from(signableTx, 'hex');
+        const privateKeyBuffer = signingKey.privateKey;
+        return ecc.Signature.sign(signBuffer, privateKeyBuffer).toString();
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param params
+     */
+    async recover(params) {
+        if (!params.rootAddress) {
+            throw new Error('missing required string rootAddress');
+        }
+        const isKrsRecovery = sdk_core_1.getIsKrsRecovery(params);
+        const isUnsignedSweep = sdk_core_1.getIsUnsignedSweep(params);
+        const { krsProvider } = params;
+        if (sdk_core_1.getIsKrsRecovery(params)) {
+            sdk_core_1.checkKrsProvider(this, krsProvider);
+        }
+        if (!this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('Invalid destination address!');
+        }
+        const keys = sdk_core_1.getBip32Keys(this.bitgo, params, { requireBitGoXpub: false });
+        const rootAddressDetails = this.getAddressDetails(params.rootAddress);
+        const account = await this.getAccountFromNode({ address: rootAddressDetails.address });
+        if (!account.core_liquid_balance) {
+            throw new Error('Could not find any balance to recovery for ' + params.rootAddress);
+        }
+        if (!account.permissions) {
+            throw new Error('Could not find permissions for ' + params.rootAddress);
+        }
+        const userPub = ecc.PublicKey.fromBuffer(keys[0].publicKey).toString();
+        const backupPub = ecc.PublicKey.fromBuffer(keys[1].publicKey).toString();
+        const activePermission = _.find(account.permissions, { perm_name: 'active' });
+        const requiredAuth = _.get(activePermission, 'required_auth');
+        if (!requiredAuth) {
+            throw new Error('Required auth for active permission not found in account');
+        }
+        if (requiredAuth.threshold !== 2) {
+            throw new Error('Unexpected active permission threshold');
+        }
+        const foundPubs = {};
+        const requiredAuthKeys = requiredAuth.keys;
+        for (const signer of requiredAuthKeys) {
+            if (signer.weight !== 1) {
+                throw new Error('invalid signer weight');
+            }
+            // if it's a dupe of a pub we already know, block
+            if (foundPubs[signer.key]) {
+                throw new Error('duplicate signer key');
+            }
+            foundPubs[signer.key] = (foundPubs[signer.key] || 0) + 1;
+        }
+        if (foundPubs[userPub] !== 1 || foundPubs[backupPub] !== 1) {
+            throw new Error('unexpected incidence frequency of user signer key');
+        }
+        const accountBalance = account.core_liquid_balance.split(' ')[0];
+        const recoveryAmount = this.bigUnitsToBaseUnits(new bignumber_js_1.BigNumber(accountBalance).toFixed());
+        const destinationAddress = params.recoveryDestination;
+        const destinationAddressDetails = this.getAddressDetails(destinationAddress);
+        const destinationAccount = await this.getAccountFromNode({ address: destinationAddressDetails.address });
+        if (!destinationAccount) {
+            throw new Error('Destination account not found');
+        }
+        const transactionHeaders = await this.getTransactionHeadersFromNode();
+        if (!transactionHeaders) {
+            throw new Error('Could not get transaction headers from node');
+        }
+        const headers = transactionHeaders;
+        const nativeDate = new Date(headers.expiration);
+        // drop milliseconds and trailing Z from expiration
+        nativeDate.setMilliseconds(0);
+        const expiration = nativeDate.toISOString();
+        if (expiration.endsWith('Z')) {
+            headers.expiration = expiration.slice(0, -1);
+        }
+        // create an offline eosjs API client
+        const api = new eosjs_1.Api({
+            rpc: new NoopJsonRpc(),
+            signatureProvider: new NoopSignatureProvider(),
+            abiProvider: new eosabiprovider_1.OfflineAbiProvider(),
+            chainId: this.getChainId(),
+            textDecoder: new TextDecoder(),
+            textEncoder: new TextEncoder(),
+        });
+        const transferAction = this.getTransferAction({
+            recipient: destinationAddressDetails.address,
+            sender: rootAddressDetails.address,
+            amount: new bignumber_js_1.BigNumber(recoveryAmount),
+            memo: destinationAddressDetails.memoId,
+        });
+        let serializedTransaction;
+        const tx = { actions: [transferAction] };
+        try {
+            serializedTransaction = await api.transact({ ...tx, ...headers }, { sign: false, broadcast: false });
+        }
+        catch (e) {
+            throw new Error('Eos API error: Could not build transaction');
+        }
+        // create transaction object
+        const serializedTransactionHex = Buffer.from(serializedTransaction.serializedTransaction).toString('hex');
+        const transactionId = Eos.createTransactionIdHex(serializedTransaction.serializedTransaction);
+        const txObject = {
+            transaction: {
+                compression: 'none',
+                packed_trx: serializedTransactionHex,
+                signatures: [],
+            },
+            txid: transactionId,
+            recoveryAmount: accountBalance,
+            coin: this.getChain(),
+            txHex: '',
+        };
+        const signableTx = Buffer.concat([
+            Buffer.from(this.getChainId(), 'hex'),
+            Buffer.from(serializedTransaction.serializedTransaction),
+            Buffer.from(new Uint8Array(32)), // Some padding
+        ]).toString('hex');
+        if (isUnsignedSweep) {
+            txObject.txHex = signableTx;
+            return txObject;
+        }
+        const userSignature = this.signTx(signableTx, keys[0]);
+        txObject.transaction.signatures.push(userSignature);
+        if (!isKrsRecovery) {
+            const backupSignature = this.signTx(signableTx, keys[1]);
+            txObject.transaction.signatures.push(backupSignature);
+        }
+        return txObject;
+    }
+    async parseTransaction(params) {
+        return {};
+    }
+    /**
+     * Verify that a transaction prebuild complies with the original intention
+     *
+     * @param params
+     * @param params.txParams params used to build the transaction
+     * @param params.txPrebuild the prebuilt transaction
+     */
+    async verifyTransaction(params) {
+        var _a;
+        const { txParams: txParams, txPrebuild: txPrebuild } = params;
+        // check if the transaction has a txHex
+        if (!txPrebuild.txHex) {
+            throw new Error('missing required tx prebuild property txHex');
+        }
+        // construct transaction from txHex
+        const txFromHex = Buffer.from(txPrebuild.txHex, 'hex');
+        const txDataWithPadding = txFromHex.slice(32);
+        const txData = txDataWithPadding.slice(0, txDataWithPadding.length - 32);
+        const deserializedTxJson = await this.deserializeTransaction({
+            transaction: { packed_trx: txData.toString('hex') },
+            headers: txPrebuild.headers,
+        });
+        if (!deserializedTxJson) {
+            throw new Error('could not process transaction from txHex');
+        }
+        const txJsonFromHex = deserializedTxJson;
+        // check that if txParams has a txPrebuild, it should be the same as txPrebuild
+        if (txParams.txPrebuild && !_.isEqual(txParams.txPrebuild, txPrebuild)) {
+            throw new Error('inputs txParams.txPrebuild and txPrebuild expected to be equal but were not');
+        }
+        // check if prebuild has a transaction
+        if (!txPrebuild.transaction) {
+            throw new Error('missing required transaction in txPrebuild');
+        }
+        // check if transaction has a packed_trx
+        if (!((_a = txPrebuild.transaction) === null || _a === void 0 ? void 0 : _a.packed_trx)) {
+            throw new Error('missing required transaction.packed_trx in txPrebuild');
+        }
+        // construct transaction using packed_trx
+        const deserializedTxJsonFromPackedTrx = await this.deserializeTransaction({
+            transaction: { packed_trx: txPrebuild.transaction.packed_trx },
+            headers: txPrebuild.headers,
+        });
+        if (!deserializedTxJsonFromPackedTrx) {
+            throw new Error('could not process transaction from packed_trx');
+        }
+        const txJsonFromPackedTrx = deserializedTxJsonFromPackedTrx;
+        // deep check of object from packed_trx and txHex
+        if (!_.isEqual(txJsonFromPackedTrx, txJsonFromHex)) {
+            throw new Error('unpacked packed_trx and unpacked txHex are not equal');
+        }
+        if (txParams.recipients.length > 1) {
+            throw new Error('only 0 or 1 recipients are supported');
+        }
+        // check the amounts, recipient, and coin name for transfers
+        if (txParams.recipients.length === 1) {
+            const expectedOutput = txParams.recipients[0];
+            // check output address and memoId
+            const expectedOutputAddressAndMemoId = this.getAddressDetails(expectedOutput.address);
+            const txHexAction = txJsonFromHex.actions[0];
+            const txHexTransferAction = txHexAction.data;
+            if (txHexTransferAction.to !== expectedOutputAddressAndMemoId.address) {
+                throw new Error('txHex receive address does not match expected recipient address');
+            }
+            // check if txaction memoid is equal to address memo id only if address also has memoid present
+            if (!_.isUndefined(expectedOutputAddressAndMemoId.memoId)) {
+                if (txHexTransferAction.memo !== expectedOutputAddressAndMemoId.memoId) {
+                    throw new Error('txHex receive memoId does not match expected recipient memoId');
+                }
+            }
+            // check amount and coin
+            const expectedOutputAmount = expectedOutput.amount;
+            const actualAmountAndCoin = txHexTransferAction.quantity.split(' ');
+            const actualOutputAmount = this.bigUnitsToBaseUnits(actualAmountAndCoin[0]);
+            if (expectedOutputAmount !== actualOutputAmount) {
+                throw new Error('txHex receive amount does not match expected recipient amount');
+            }
+            if (txPrebuild.coin === 'eos' || txPrebuild.coin === 'teos') {
+                const expectedSymbol = _.isNil(txPrebuild.token) ? 'EOS' : txPrebuild.token.split(':')[1];
+                if (actualAmountAndCoin[1] !== expectedSymbol) {
+                    throw new Error('txHex receive symbol does not match expected recipient symbol');
+                }
+            }
+            else {
+                // this should never happen
+                throw new Error('txHex coin name does not match expected coin name');
+            }
+        }
+        return true;
+    }
+    /**
+     * Generate a random EOS address.
+     *
+     * This is just a random string which abides by the EOS adddress constraints,
+     * and is not actually checked for availability on the EOS blockchain.
+     *
+     * Current EOS address constraints are:
+     * * Address must be exactly 12 characters
+     * * Address must only contain lowercase letters and numbers 1-5
+     * @returns a validly formatted EOS address, which may or may not actually be available on chain.
+     */
+    generateRandomAddress(params) {
+        const address = [];
+        while (address.length < 12) {
+            const char = _.sample(Eos.VALID_ADDRESS_CHARS);
+            if (!char) {
+                throw new Error('failed to sample valid EOS address characters');
+            }
+            address.push(char);
+        }
+        return address.join('');
+    }
+}
+exports.Eos = Eos;
+Eos.VALID_ADDRESS_CHARS = '12345abcdefghijklmnopqrstuvwxyz'.split('');
+Eos.ADDRESS_LENGTH = 12;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eos.js","sourceRoot":"","sources":["../../src/eos.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport { BigNumber } from 'bignumber.js';\nimport * as bip32 from 'bip32';\nimport { createHash, randomBytes } from 'crypto';\nimport { Api, ApiInterfaces, JsonRpc, RpcInterfaces } from 'eosjs';\nimport * as ecc from 'eosjs-ecc';\nimport * as _ from 'lodash';\nimport * as querystring from 'querystring';\nimport * as request from 'superagent';\nimport * as url from 'url';\n\nimport { OfflineAbiProvider } from './eosutil/eosabiprovider';\nimport { StringTextDecoder } from './lib/utils';\nimport {\n  BaseCoin,\n  BitGoBase,\n  checkKrsProvider,\n  Environments,\n  getBip32Keys,\n  getIsKrsRecovery,\n  getIsUnsignedSweep,\n  HalfSignedAccountTransaction as BaseHalfSignedTransaction,\n  InvalidAddressError,\n  KeyPair,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  RequestTracer,\n  SignTransactionOptions as BaseSignTransactionOptions,\n  TransactionExplanation,\n  UnexpectedAddressError,\n  VerificationOptions,\n  VerifyAddressOptions as BaseVerifyAddressOptions,\n  VerifyTransactionOptions as BaseVerifyTransactionOptions,\n  Wallet,\n} from '@bitgo/sdk-core';\n\ninterface AddressDetails {\n  address: string;\n  memoId?: string;\n}\n\nexport interface EosTx {\n  signatures: string[];\n  packed_trx: string;\n  compression: string;\n}\n\nexport interface Recipient {\n  address: string;\n  amount: string;\n}\n\ninterface EosTransactionHeaders {\n  ref_block_prefix: number;\n  ref_block_num: number;\n  expiration?: string;\n}\n\ninterface EosTransactionAction {\n  account: string;\n  name: string;\n  authorization: [{ actor: string; permission: string }];\n  data: TransferActionData | StakeActionData | VoteActionData;\n}\n\ninterface EosTransactionPrebuild {\n  recipients: Recipient[];\n  headers: EosTransactionHeaders;\n  txHex: string; // The signable tx hex string\n  transaction: EosTx;\n  txid: string;\n  coin: string;\n  // full token name with the format, [t]eos:SYMBOL. This will only be present for token transactions. e.g. teos:CHEX.\n  token?: string;\n}\n\nexport interface EosSignTransactionParams extends BaseSignTransactionOptions {\n  prv: string;\n  txPrebuild: EosTransactionPrebuild;\n  recipients: Recipient[];\n}\n\nexport interface EosVerifyTransactionOptions extends BaseVerifyTransactionOptions {\n  txPrebuild: EosTransactionPrebuild;\n  txParams: EosSignTransactionParams;\n  wallet: Wallet;\n  verification?: VerificationOptions;\n  reqId?: RequestTracer;\n}\n\nexport interface EosHalfSigned {\n  recipients: Recipient[];\n  headers: EosTransactionHeaders;\n  txHex: string; // The signable tx hex string\n  transaction: EosTx;\n  txid: string;\n}\n\nexport interface EosSignedTransaction extends BaseHalfSignedTransaction {\n  halfSigned: EosHalfSigned;\n}\n\ninterface DeserializedEosTransaction {\n  expiration: string;\n  ref_block_num: string;\n  ref_block_prefix: string;\n  max_net_usage_words: number;\n  max_cpu_usage_ms: number;\n  delay_sec: number;\n  context_free_actions: EosTransactionAction[];\n  actions: EosTransactionAction[];\n  transaction_extensions: Record<string, unknown>[];\n  address: string;\n  amount: string;\n  transaction_id: string;\n  memo?: string;\n  proxy?: string;\n  producers?: string[];\n}\n\ninterface TransferActionData {\n  from: string;\n  to: string;\n  quantity: string;\n  memo?: string;\n}\n\ninterface StakeActionData {\n  address: string;\n  amount: string;\n  from: string;\n  receiver: string;\n  transfer: number;\n  stake_cpu_quantity: string;\n}\n\ninterface UnstakeActionData {\n  address: string;\n  amount: string;\n  from: string;\n  receiver: string;\n  unstake_cpu_quantity: string;\n  unstake_net_quantity: string;\n}\n\ninterface RefundActionData {\n  address: string;\n  owner: string;\n}\n\ninterface VoteActionData {\n  address: string;\n  proxy: string;\n  producers: string[];\n  voter: string;\n}\n\ninterface ExplainTransactionOptions {\n  transaction: { packed_trx: string };\n  headers: EosTransactionHeaders;\n}\n\ninterface RecoveryTransaction {\n  transaction: EosTx;\n  txid: string;\n  recoveryAmount: number;\n}\n\ninterface RecoveryOptions {\n  userKey: string; // Box A\n  backupKey: string; // Box B\n  bitgoKey?: string; // Box C\n  recoveryDestination: string;\n  krsProvider?: string;\n  walletPassphrase?: string;\n  rootAddress?: string;\n}\n\ninterface VerifyAddressOptions extends BaseVerifyAddressOptions {\n  rootAddress: string;\n}\n\nclass NoopJsonRpc extends JsonRpc {\n  constructor() {\n    super('');\n  }\n}\n\nclass NoopSignatureProvider implements ApiInterfaces.SignatureProvider {\n  async getAvailableKeys(): Promise<string[]> {\n    throw new Error('noop signature provider implementation has no available keys');\n  }\n\n  async sign(args: ApiInterfaces.SignatureProviderArgs): Promise<RpcInterfaces.PushTransactionArgs> {\n    throw new Error('noop implementation is unable to sign');\n  }\n}\n\nexport class Eos extends BaseCoin {\n  public static VALID_ADDRESS_CHARS = '12345abcdefghijklmnopqrstuvwxyz'.split('');\n  public static ADDRESS_LENGTH = 12;\n\n  static createInstance(bitgo: BitGoBase): BaseCoin {\n    return new Eos(bitgo);\n  }\n\n  getChainId(): string {\n    return 'aca376f206b8fc25a6ed44dbdc66547c36c6c33e3a119ffbeaef943642f0e906'; // mainnet chain id\n  }\n\n  getChain(): string {\n    return 'eos';\n  }\n\n  getFamily(): string {\n    return 'eos';\n  }\n\n  getFullName(): string {\n    return 'EOS';\n  }\n\n  getBaseFactor(): number {\n    return 1e4;\n  }\n\n  /**\n   * Flag for sending value of 0\n   * @returns {boolean} True if okay to send 0 value, false otherwise\n   */\n  valuelessTransferAllowed(): boolean {\n    return true;\n  }\n\n  /**\n   * Get URLs of some active public nodes\n   */\n  getPublicNodeUrls(): string[] {\n    return Environments[this.bitgo.getEnv()].eosNodeUrls;\n  }\n  /**\n   * Generate secp256k1 key pair\n   *\n   * @param seed - Seed from which the new keypair should be generated, otherwise a random seed is used\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    if (!seed) {\n      // An extended private key has both a normal 256 bit private key and a 256\n      // bit chain code, both of which must be random. 512 bits is therefore the\n      // maximum entropy and gives us maximum security against cracking.\n      seed = randomBytes(512 / 8);\n    }\n    const extendedKey = bip32.fromSeed(seed);\n    const xpub = extendedKey.neutered().toBase58();\n    return {\n      pub: xpub,\n      prv: extendedKey.toBase58(),\n    };\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin.\n   *\n   * @param pub - the pub to be checked\n   */\n  isValidPub(pub: string): boolean {\n    try {\n      return bip32.fromBase58(pub).isNeutered();\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Return boolean indicating whether input is valid seed for the coin\n   *\n   * @param prv - the prv to be checked\n   */\n  isValidPrv(prv: string): boolean {\n    try {\n      return !bip32.fromBase58(prv).isNeutered();\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Evaluates whether a memo is valid\n   *\n   * @param value - the memo to be checked\n   */\n  isValidMemo({ value }: { value: string }): boolean {\n    return _.isString(value) && value.length <= 256;\n  }\n\n  /**\n   * Return boolean indicating whether a memo id is valid\n   *\n   * @param memoId - the memo id to be checked\n   */\n  isValidMemoId(memoId: string): boolean {\n    return this.isValidMemo({ value: memoId });\n  }\n\n  /**\n   * Process address into address and memo id\n   * @param address - the address\n   */\n  getAddressDetails(address: string): AddressDetails {\n    const destinationDetails = url.parse(address);\n    const destinationAddress = destinationDetails.pathname;\n\n    if (!destinationAddress) {\n      throw new InvalidAddressError(`failed to parse address: ${address}`);\n    }\n\n    // EOS addresses have to be \"human readable\", which means up to 12 characters and only a-z1-5., i.e.mtoda1.bitgo\n    // source: https://developers.eos.io/eosio-cpp/docs/naming-conventions\n    if (!/^[a-z1-5.]*$/.test(destinationAddress) || destinationAddress.length > Eos.ADDRESS_LENGTH) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    // address doesn't have a memo id\n    if (destinationDetails.pathname === address) {\n      return {\n        address: address,\n        memoId: undefined,\n      };\n    }\n\n    if (!destinationDetails.query) {\n      throw new InvalidAddressError(`failed to parse query string: ${address}`);\n    }\n\n    const queryDetails = querystring.parse(destinationDetails.query);\n    if (!queryDetails.memoId) {\n      // if there are more properties, the query details need to contain the memoId property\n      throw new InvalidAddressError(`invalid property in address: ${address}`);\n    }\n\n    if (Array.isArray(queryDetails.memoId) && queryDetails.memoId.length !== 1) {\n      // valid addresses can only contain one memo id\n      throw new InvalidAddressError(`invalid address '${address}', must contain exactly one memoId`);\n    }\n\n    const [memoId] = _.castArray(queryDetails.memoId);\n    if (!this.isValidMemoId(memoId)) {\n      throw new InvalidAddressError(`invalid address: '${address}', memoId is not valid`);\n    }\n\n    return {\n      address: destinationAddress,\n      memoId,\n    };\n  }\n\n  /**\n   * Convert a currency amount represented in base units (satoshi, wei, atoms, drops, stroops)\n   * to big units (btc, eth, xrp, xlm)\n   */\n  baseUnitsToBigUnits(baseUnits: string | number): string {\n    const dividend = this.getBaseFactor();\n    const bigNumber = new BigNumber(baseUnits).dividedBy(dividend);\n    // set the format so commas aren't added to large coin amounts\n    return bigNumber.toFormat(4, null as any, { groupSeparator: '', decimalSeparator: '.' });\n  }\n\n  /**\n   * Validate and return address with appended memo id\n   *\n   * @param address\n   * @param memoId\n   */\n  normalizeAddress({ address, memoId }: AddressDetails): string {\n    if (memoId && this.isValidMemoId(memoId)) {\n      return `${address}?memoId=${memoId}`;\n    }\n    return address;\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin\n   *\n   * @param address - the address to be checked\n   */\n  isValidAddress(address: string): boolean {\n    try {\n      const addressDetails = this.getAddressDetails(address);\n      return address === this.normalizeAddress(addressDetails);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * @param address - the address to verify\n   * @param rootAddress - the wallet's root address\n   * @return true iff address is a wallet address (based on rootAddress)\n   */\n  isWalletAddress({ address, rootAddress }: VerifyAddressOptions): boolean {\n    if (!rootAddress || !_.isString(rootAddress)) {\n      throw new Error('missing required string rootAddress');\n    }\n\n    if (!this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    const addressDetails = this.getAddressDetails(address);\n    const rootAddressDetails = this.getAddressDetails(rootAddress);\n\n    if (!addressDetails || !rootAddressDetails) {\n      return false;\n    }\n\n    if (addressDetails.address !== rootAddressDetails.address) {\n      throw new UnexpectedAddressError(\n        `address validation failure: ${addressDetails.address} vs ${rootAddressDetails.address}`\n      );\n    }\n\n    return true;\n  }\n\n  /**\n   * Assemble keychain and half-sign prebuilt transaction\n   *\n   * @param params\n   * @param params.txPrebuild {Object} prebuild object returned by platform\n   * @param params.prv {String} user prv\n   * @returns {Promise<EosSignedTransaction>}\n   */\n  async signTransaction(params: EosSignTransactionParams): Promise<EosSignedTransaction> {\n    const prv: string = params.prv;\n    const txHex: string = params.txPrebuild.txHex;\n    const transaction: EosTx = params.txPrebuild.transaction;\n\n    const signBuffer: Buffer = Buffer.from(txHex, 'hex');\n    const privateKeyBuffer = bip32.fromBase58(prv).privateKey;\n    if (!privateKeyBuffer) {\n      throw new Error('no privateKey');\n    }\n    const signature: string = ecc.Signature.sign(signBuffer, privateKeyBuffer).toString();\n\n    transaction.signatures.push(signature);\n\n    const txParams = {\n      transaction,\n      txHex,\n      recipients: params.txPrebuild.recipients,\n      headers: params.txPrebuild.headers,\n      txid: params.txPrebuild.txid,\n    };\n    return { halfSigned: txParams };\n  }\n\n  private validateStakeActionData(stakeActionData: StakeActionData): any {\n    if (stakeActionData.from !== stakeActionData.receiver) {\n      throw new Error(`staker (${stakeActionData.from}) and receiver (${stakeActionData.receiver}) must be the same`);\n    }\n\n    if (stakeActionData.transfer !== 0) {\n      throw new Error('cannot transfer funds as part of delegatebw action');\n    }\n\n    // stake_cpu_quantity is used as the amount because the BitGo platform only stakes cpu for voting transactions\n    return {\n      address: stakeActionData.from,\n      amount: this.bigUnitsToBaseUnits(stakeActionData.stake_cpu_quantity.split(' ')[0]),\n    };\n  }\n\n  private validateUnstakeActionData(unstakeActionData: UnstakeActionData): any {\n    if (unstakeActionData.from !== unstakeActionData.receiver) {\n      throw new Error(\n        `unstaker (${unstakeActionData.from}) and receiver (${unstakeActionData.receiver}) must be the same`\n      );\n    }\n    const cpuAmount = new BigNumber(unstakeActionData.unstake_cpu_quantity.split(' ')[0]);\n    const netAmount = new BigNumber(unstakeActionData.unstake_net_quantity.split(' ')[0]);\n    const totalAmount = cpuAmount.plus(netAmount).toNumber();\n\n    return {\n      address: unstakeActionData.receiver,\n      amount: this.bigUnitsToBaseUnits(totalAmount),\n    };\n  }\n\n  private static validateVoteActionData(voteActionData: VoteActionData) {\n    const proxyIsEmpty = _.isEmpty(voteActionData.proxy);\n    const producersIsEmpty = _.isEmpty(voteActionData.producers);\n    if ((proxyIsEmpty && producersIsEmpty) || (!proxyIsEmpty && !producersIsEmpty)) {\n      throw new Error('voting transactions must specify either producers or proxy to vote for');\n    }\n\n    return {\n      address: voteActionData.voter,\n      proxy: voteActionData.proxy,\n      producers: voteActionData.producers,\n    };\n  }\n\n  private static createTransactionIdHex(serializedTransactionBuffer: Buffer): string {\n    return createHash('sha256').update(serializedTransactionBuffer).digest().toString('hex');\n  }\n\n  /**\n   * Deserialize a transaction\n   * @param transaction\n   * @param headers\n   */\n  private async deserializeTransaction({\n    transaction,\n    headers,\n  }: ExplainTransactionOptions): Promise<DeserializedEosTransaction> {\n    // create an eosjs API client\n    const api = new Api({\n      abiProvider: new OfflineAbiProvider(),\n      rpc: new NoopJsonRpc(),\n      signatureProvider: new NoopSignatureProvider(),\n      chainId: this.getChainId(),\n      // Use a custom TextDecoder as the global TextDecoder leads to crashes in OVC / Electron.\n      textDecoder: new StringTextDecoder(),\n      textEncoder: new TextEncoder(),\n    });\n\n    // type guards\n    const isTransferActionData = (txActionData: any): txActionData is TransferActionData => {\n      return (\n        (txActionData as TransferActionData).from !== undefined &&\n        (txActionData as TransferActionData).to !== undefined &&\n        (txActionData as TransferActionData).quantity !== undefined\n      );\n    };\n    const isStakeActionData = (txActionData: any): txActionData is StakeActionData => {\n      return (\n        (txActionData as StakeActionData).from !== undefined &&\n        (txActionData as StakeActionData).receiver !== undefined &&\n        (txActionData as StakeActionData).transfer !== undefined &&\n        (txActionData as StakeActionData).stake_cpu_quantity !== undefined\n      );\n    };\n    const isUnstakeActionData = (txActionData: any): txActionData is UnstakeActionData => {\n      return (\n        (txActionData as UnstakeActionData).from !== undefined &&\n        (txActionData as UnstakeActionData).receiver !== undefined &&\n        (txActionData as UnstakeActionData).unstake_cpu_quantity !== undefined &&\n        (txActionData as UnstakeActionData).unstake_net_quantity !== undefined\n      );\n    };\n    const isVoteActionData = (txActionData: any): txActionData is VoteActionData => {\n      return (txActionData as VoteActionData).voter !== undefined;\n    };\n    const isRefundActionData = (txActionData: any): txActionData is RefundActionData => {\n      return (txActionData as RefundActionData).owner !== undefined;\n    };\n\n    // deserializeTransaction\n    const serializedTxBuffer = Buffer.from(transaction.packed_trx, 'hex');\n    const deserializedTxJsonFromPackedTrx = await api.deserializeTransactionWithActions(serializedTxBuffer);\n\n    if (!deserializedTxJsonFromPackedTrx) {\n      throw new Error('could not process transaction from txHex');\n    }\n    const tx: DeserializedEosTransaction = deserializedTxJsonFromPackedTrx;\n\n    // validate context free actions\n    if (tx.context_free_actions.length !== 0) {\n      if (tx.context_free_actions.length !== 1) {\n        throw new Error('number of context free actions must be 1');\n      }\n\n      if (\n        !_.isEqual(_.pick(tx.context_free_actions[0], ['account', 'authorization', 'name']), {\n          account: 'eosio.null',\n          authorization: [],\n          name: 'nonce',\n        }) ||\n        _.isEmpty(tx.context_free_actions[0].data)\n      ) {\n        throw new Error('the context free action is invalid');\n      }\n    }\n\n    // Only support transactions with one (transfer | voteproducer) or two (delegatebw & voteproducer) actions\n    if (tx.actions.length !== 1 && tx.actions.length !== 2) {\n      throw new Error(`invalid number of actions: ${tx.actions.length}`);\n    }\n\n    const txAction = tx.actions[0];\n    if (!txAction) {\n      throw new Error('missing transaction action');\n    }\n    if (txAction.name === 'transfer') {\n      // Transfers should only have 1 action\n      if (tx.actions.length !== 1) {\n        throw new Error(`transfers should only have 1 action: ${tx.actions.length} given`);\n      }\n\n      if (!isTransferActionData(txAction.data)) {\n        throw new Error('Invalid or incomplete transfer action data');\n      }\n      const transferActionData = txAction.data;\n\n      tx.address = transferActionData.to;\n      tx.amount = this.bigUnitsToBaseUnits(transferActionData.quantity.split(' ')[0]);\n      tx.memo = transferActionData.memo;\n    } else if (txAction.name === 'delegatebw') {\n      // The delegatebw action should only be part of voting transactions\n      if (tx.actions.length !== 2) {\n        throw new Error(\n          `staking transactions that include the delegatebw action should have 2 actions: ${tx.actions.length} given`\n        );\n      }\n\n      const txAction2 = tx.actions[1];\n      if (txAction2.name !== 'voteproducer') {\n        throw new Error(`invalid staking transaction action: ${txAction2.name}, expecting: voteproducer`);\n      }\n\n      if (!isStakeActionData(txAction.data) || !isVoteActionData(txAction2.data)) {\n        throw new Error('Invalid or incomplete stake or vote action data');\n      }\n      const stakeActionData = txAction.data;\n      const voteActionData = txAction2.data;\n\n      const deserializedStakeAction = this.validateStakeActionData(stakeActionData);\n      const deserializedVoteAction = Eos.validateVoteActionData(voteActionData);\n      if (deserializedStakeAction.address !== deserializedVoteAction.address) {\n        throw new Error(\n          `staker (${deserializedStakeAction.address}) and voter (${deserializedVoteAction.address}) must be the same`\n        );\n      }\n\n      tx.amount = deserializedStakeAction.amount;\n      tx.proxy = deserializedVoteAction.proxy;\n      tx.producers = deserializedVoteAction.producers;\n    } else if (txAction.name === 'voteproducer') {\n      if (tx.actions.length > 2) {\n        throw new Error('voting transactions should not have more than 2 actions');\n      }\n\n      let deserializedStakeAction;\n      if (tx.actions.length === 2) {\n        const txAction2 = tx.actions[1];\n        if (txAction2.name !== 'delegatebw') {\n          throw new Error(`invalid staking transaction action: ${txAction2.name}, expecting: delegatebw`);\n        }\n        if (!isStakeActionData(txAction.data)) {\n          throw new Error('Invalid or incomplete stake action data');\n        }\n        const stakeActionData = txAction.data;\n        deserializedStakeAction = this.validateStakeActionData(stakeActionData);\n      }\n\n      if (!isVoteActionData(txAction.data)) {\n        throw new Error('Invalid or incomplete vote action data');\n      }\n      const voteActionData = txAction.data;\n      const deserializedVoteAction = Eos.validateVoteActionData(voteActionData);\n\n      if (!!deserializedStakeAction && deserializedStakeAction.address !== deserializedVoteAction.address) {\n        throw new Error(\n          `staker (${deserializedStakeAction.address}) and voter (${deserializedVoteAction.address}) must be the same`\n        );\n      }\n\n      tx.amount = !!deserializedStakeAction ? deserializedStakeAction.amount : '0';\n      tx.proxy = deserializedVoteAction.proxy;\n      tx.producers = deserializedVoteAction.producers;\n    } else if (txAction.name === 'undelegatebw') {\n      if (tx.actions.length !== 1) {\n        throw new Error(`unstake should only have 1 action: ${tx.actions.length} given`);\n      }\n\n      if (!isUnstakeActionData(txAction.data)) {\n        throw new Error('Invalid or incomplete unstake action data');\n      }\n      const unstakeActionData = txAction.data;\n      const deserializedUnstakeAction = this.validateUnstakeActionData(unstakeActionData);\n\n      tx.amount = deserializedUnstakeAction.amount;\n      tx.address = deserializedUnstakeAction.address;\n    } else if (txAction.name === 'refund') {\n      if (tx.actions.length !== 1) {\n        throw new Error(`refund should only have 1 action: ${tx.actions.length} given`);\n      }\n\n      if (!isRefundActionData(txAction.data)) {\n        throw new Error('Invalid or incomplete refund action data');\n      }\n\n      const refundActionData = txAction.data;\n      tx.address = refundActionData.owner;\n      tx.amount = '0';\n    } else {\n      throw new Error(`invalid action: ${txAction.name}`);\n    }\n\n    // Get the tx id if tx headers were provided\n    if (headers) {\n      let rebuiltTransaction;\n      try {\n        // remove Z at the end\n        if ((headers.expiration as string).endsWith('Z')) {\n          headers.expiration = (headers.expiration as string).slice(0, -1);\n        }\n        rebuiltTransaction = await api.transact({ ...tx, ...headers }, { sign: false, broadcast: false });\n      } catch (e) {\n        throw new Error(\n          'Could not build transaction to get transaction_id. Please check transaction or headers format.'\n        );\n      }\n\n      tx.transaction_id = Eos.createTransactionIdHex((rebuiltTransaction as any).serializedTransaction);\n    }\n\n    return tx;\n  }\n\n  /**\n   * Explain/parse transaction\n   * @param params - ExplainTransactionOptions\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation> {\n    let transaction;\n    try {\n      transaction = await this.deserializeTransaction(params);\n    } catch (e) {\n      throw new Error('invalid EOS transaction or headers: ' + e.toString());\n    }\n    return {\n      displayOrder: [\n        'id',\n        'outputAmount',\n        'changeAmount',\n        'outputs',\n        'changeOutputs',\n        'fee',\n        'memo',\n        'proxy',\n        'producers',\n      ],\n      id: transaction.transaction_id,\n      changeOutputs: [],\n      outputAmount: transaction.amount,\n      changeAmount: 0,\n      outputs: !!transaction.address ? [{ address: transaction.address, amount: transaction.amount }] : [],\n      fee: {},\n      memo: transaction.memo,\n      proxy: transaction.proxy,\n      producers: transaction.producers,\n    } as any;\n  }\n\n  /**\n   * @deprecated\n   */\n  initiateRecovery(params: RecoveryOptions): never {\n    throw new Error('deprecated method');\n  }\n\n  /**\n   * Make a request to one of the public EOS nodes available\n   * @param params.endpoint\n   * @param params.payload\n   */\n  protected async getDataFromNode(params: {\n    endpoint: string;\n    payload?: Record<string, unknown>;\n  }): Promise<request.Response> {\n    const nodeUrls = this.getPublicNodeUrls();\n    for (const nodeUrl of nodeUrls) {\n      try {\n        return await request.post(nodeUrl + params.endpoint).send(params.payload);\n      } catch (e) {\n        // let's hope another call succeeds\n      }\n    }\n    throw new Error(`Unable to call endpoint: ${params.endpoint} from nodes: ${_.join(nodeUrls, ', ')}`);\n  }\n\n  /**\n   * Get EOS chain info from a public node\n   */\n  protected async getChainInfoFromNode(): Promise<any> {\n    const response = await this.getDataFromNode({ endpoint: '/v1/chain/get_info' });\n    if (response.status !== 200) {\n      throw new Error('Unable to fetch chain info');\n    }\n    return response.body;\n  }\n\n  /**\n   * Get data specific to an account from a public node\n   * @param address\n   */\n  protected async getAccountFromNode({ address }: { address: string }): Promise<any> {\n    const response = await this.getDataFromNode({\n      endpoint: '/v1/chain/get_account',\n      payload: { account_name: address },\n    });\n    if (response.status !== 200) {\n      throw new Error('Account not found');\n    }\n    return response.body;\n  }\n\n  /**\n   * Get block data from a public node using its block number or block id\n   * @param blockNumOrId\n   */\n  protected async getBlockFromNode({ blockNumOrId }: { blockNumOrId: string }): Promise<any> {\n    const response = await this.getDataFromNode({\n      endpoint: '/v1/chain/get_block',\n      payload: { block_num_or_id: blockNumOrId },\n    });\n    if (response.status !== 200) {\n      throw new Error('Block not found');\n    }\n    return response.body;\n  }\n\n  /**\n   * Get headers for an EOS tx from a public node\n   */\n  protected async getTransactionHeadersFromNode(): Promise<any> {\n    const chainInfo = await this.getChainInfoFromNode();\n    const headBlockInfoResult = await this.getBlockFromNode({ blockNumOrId: chainInfo.head_block_num });\n    const expireSeconds = 28800; // maximum tx expire time of 8h\n    const chainDate = new Date(chainInfo.head_block_time + 'Z').getTime();\n    const expirationDate = new Date(chainDate + expireSeconds * 1000);\n\n    return {\n      expiration: expirationDate.toISOString(),\n      ref_block_num: chainInfo.head_block_num & 0xffff,\n      ref_block_prefix: headBlockInfoResult.ref_block_prefix,\n    };\n  }\n\n  protected getTransferAction({ recipient, sender, amount, memo }: any): EosTransactionAction {\n    return {\n      account: 'eosio.token',\n      name: 'transfer',\n      authorization: [\n        {\n          actor: sender,\n          permission: 'active',\n        },\n      ],\n      data: {\n        from: sender,\n        to: recipient,\n        quantity: `${this.baseUnitsToBigUnits(amount)} EOS`,\n        memo: !_.isNil(memo) ? memo : '', // Memo must be defined, set it to empty string if it is not\n      },\n    };\n  }\n\n  /**\n   * Sign a transaction with a key\n   * @param signableTx\n   * @param signingKey\n   */\n  signTx(signableTx: string, signingKey: bip32.BIP32Interface): string {\n    const signBuffer = Buffer.from(signableTx, 'hex');\n    const privateKeyBuffer = signingKey.privateKey;\n    return ecc.Signature.sign(signBuffer, privateKeyBuffer).toString();\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param params\n   */\n  async recover(params: RecoveryOptions): Promise<RecoveryTransaction> {\n    if (!params.rootAddress) {\n      throw new Error('missing required string rootAddress');\n    }\n\n    const isKrsRecovery = getIsKrsRecovery(params);\n    const isUnsignedSweep = getIsUnsignedSweep(params);\n\n    const { krsProvider } = params;\n    if (getIsKrsRecovery(params)) {\n      checkKrsProvider(this, krsProvider);\n    }\n\n    if (!this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('Invalid destination address!');\n    }\n\n    const keys = getBip32Keys(this.bitgo, params, { requireBitGoXpub: false });\n\n    const rootAddressDetails = this.getAddressDetails(params.rootAddress);\n    const account = await this.getAccountFromNode({ address: rootAddressDetails.address });\n\n    if (!account.core_liquid_balance) {\n      throw new Error('Could not find any balance to recovery for ' + params.rootAddress);\n    }\n\n    if (!account.permissions) {\n      throw new Error('Could not find permissions for ' + params.rootAddress);\n    }\n    const userPub = ecc.PublicKey.fromBuffer(keys[0].publicKey).toString();\n    const backupPub = ecc.PublicKey.fromBuffer(keys[1].publicKey).toString();\n\n    const activePermission = _.find(account.permissions, { perm_name: 'active' });\n    const requiredAuth = _.get(activePermission, 'required_auth');\n    if (!requiredAuth) {\n      throw new Error('Required auth for active permission not found in account');\n    }\n    if (requiredAuth.threshold !== 2) {\n      throw new Error('Unexpected active permission threshold');\n    }\n\n    const foundPubs = {};\n    const requiredAuthKeys = requiredAuth.keys;\n    for (const signer of requiredAuthKeys) {\n      if (signer.weight !== 1) {\n        throw new Error('invalid signer weight');\n      }\n      // if it's a dupe of a pub we already know, block\n      if (foundPubs[signer.key]) {\n        throw new Error('duplicate signer key');\n      }\n      foundPubs[signer.key] = (foundPubs[signer.key] || 0) + 1;\n    }\n    if (foundPubs[userPub] !== 1 || foundPubs[backupPub] !== 1) {\n      throw new Error('unexpected incidence frequency of user signer key');\n    }\n\n    const accountBalance = account.core_liquid_balance.split(' ')[0];\n    const recoveryAmount = this.bigUnitsToBaseUnits(new BigNumber(accountBalance).toFixed());\n\n    const destinationAddress = params.recoveryDestination;\n    const destinationAddressDetails = this.getAddressDetails(destinationAddress);\n    const destinationAccount = await this.getAccountFromNode({ address: destinationAddressDetails.address });\n    if (!destinationAccount) {\n      throw new Error('Destination account not found');\n    }\n\n    const transactionHeaders = await this.getTransactionHeadersFromNode();\n    if (!transactionHeaders) {\n      throw new Error('Could not get transaction headers from node');\n    }\n    const headers: EosTransactionHeaders = transactionHeaders;\n    const nativeDate = new Date(headers.expiration as string);\n    // drop milliseconds and trailing Z from expiration\n    nativeDate.setMilliseconds(0);\n    const expiration = nativeDate.toISOString();\n    if (expiration.endsWith('Z')) {\n      headers.expiration = expiration.slice(0, -1);\n    }\n\n    // create an offline eosjs API client\n    const api = new Api({\n      rpc: new NoopJsonRpc(),\n      signatureProvider: new NoopSignatureProvider(),\n      abiProvider: new OfflineAbiProvider(),\n      chainId: this.getChainId(),\n      textDecoder: new TextDecoder(),\n      textEncoder: new TextEncoder(),\n    });\n\n    const transferAction = this.getTransferAction({\n      recipient: destinationAddressDetails.address,\n      sender: rootAddressDetails.address,\n      amount: new BigNumber(recoveryAmount),\n      memo: destinationAddressDetails.memoId,\n    });\n\n    let serializedTransaction;\n    const tx = { actions: [transferAction] };\n    try {\n      serializedTransaction = await api.transact({ ...tx, ...headers }, { sign: false, broadcast: false });\n    } catch (e) {\n      throw new Error('Eos API error: Could not build transaction');\n    }\n\n    // create transaction object\n    const serializedTransactionHex = Buffer.from(serializedTransaction.serializedTransaction).toString('hex');\n    const transactionId = Eos.createTransactionIdHex(serializedTransaction.serializedTransaction);\n    const txObject = {\n      transaction: {\n        compression: 'none',\n        packed_trx: serializedTransactionHex,\n        signatures: [] as string[],\n      },\n      txid: transactionId,\n      recoveryAmount: accountBalance,\n      coin: this.getChain(),\n      txHex: '',\n    };\n\n    const signableTx = Buffer.concat([\n      Buffer.from(this.getChainId(), 'hex'), // The ChainID representing the chain that we are on\n      Buffer.from(serializedTransaction.serializedTransaction), // The serialized unsigned tx\n      Buffer.from(new Uint8Array(32)), // Some padding\n    ]).toString('hex');\n\n    if (isUnsignedSweep) {\n      txObject.txHex = signableTx;\n      return txObject;\n    }\n\n    const userSignature = this.signTx(signableTx, keys[0]);\n    txObject.transaction.signatures.push(userSignature);\n\n    if (!isKrsRecovery) {\n      const backupSignature = this.signTx(signableTx, keys[1]);\n      txObject.transaction.signatures.push(backupSignature);\n    }\n\n    return txObject;\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  /**\n   * Verify that a transaction prebuild complies with the original intention\n   *\n   * @param params\n   * @param params.txParams params used to build the transaction\n   * @param params.txPrebuild the prebuilt transaction\n   */\n  async verifyTransaction(params: EosVerifyTransactionOptions): Promise<any> {\n    const { txParams: txParams, txPrebuild: txPrebuild } = params;\n\n    // check if the transaction has a txHex\n    if (!txPrebuild.txHex) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n\n    // construct transaction from txHex\n    const txFromHex = Buffer.from(txPrebuild.txHex, 'hex');\n    const txDataWithPadding = txFromHex.slice(32);\n    const txData = txDataWithPadding.slice(0, txDataWithPadding.length - 32);\n    const deserializedTxJson = await this.deserializeTransaction({\n      transaction: { packed_trx: txData.toString('hex') },\n      headers: txPrebuild.headers,\n    });\n    if (!deserializedTxJson) {\n      throw new Error('could not process transaction from txHex');\n    }\n    const txJsonFromHex: DeserializedEosTransaction = deserializedTxJson;\n\n    // check that if txParams has a txPrebuild, it should be the same as txPrebuild\n    if (txParams.txPrebuild && !_.isEqual(txParams.txPrebuild, txPrebuild)) {\n      throw new Error('inputs txParams.txPrebuild and txPrebuild expected to be equal but were not');\n    }\n\n    // check if prebuild has a transaction\n    if (!txPrebuild.transaction) {\n      throw new Error('missing required transaction in txPrebuild');\n    }\n\n    // check if transaction has a packed_trx\n    if (!txPrebuild.transaction?.packed_trx) {\n      throw new Error('missing required transaction.packed_trx in txPrebuild');\n    }\n\n    // construct transaction using packed_trx\n    const deserializedTxJsonFromPackedTrx = await this.deserializeTransaction({\n      transaction: { packed_trx: txPrebuild.transaction.packed_trx },\n      headers: txPrebuild.headers,\n    });\n    if (!deserializedTxJsonFromPackedTrx) {\n      throw new Error('could not process transaction from packed_trx');\n    }\n    const txJsonFromPackedTrx: DeserializedEosTransaction = deserializedTxJsonFromPackedTrx;\n\n    // deep check of object from packed_trx and txHex\n    if (!_.isEqual(txJsonFromPackedTrx, txJsonFromHex)) {\n      throw new Error('unpacked packed_trx and unpacked txHex are not equal');\n    }\n\n    if (txParams.recipients.length > 1) {\n      throw new Error('only 0 or 1 recipients are supported');\n    }\n\n    // check the amounts, recipient, and coin name for transfers\n    if (txParams.recipients.length === 1) {\n      const expectedOutput = txParams.recipients[0];\n\n      // check output address and memoId\n      const expectedOutputAddressAndMemoId = this.getAddressDetails(expectedOutput.address);\n      const txHexAction = txJsonFromHex.actions[0];\n      const txHexTransferAction = txHexAction.data as TransferActionData;\n\n      if (txHexTransferAction.to !== expectedOutputAddressAndMemoId.address) {\n        throw new Error('txHex receive address does not match expected recipient address');\n      }\n      // check if txaction memoid is equal to address memo id only if address also has memoid present\n      if (!_.isUndefined(expectedOutputAddressAndMemoId.memoId)) {\n        if (txHexTransferAction.memo !== expectedOutputAddressAndMemoId.memoId) {\n          throw new Error('txHex receive memoId does not match expected recipient memoId');\n        }\n      }\n\n      // check amount and coin\n      const expectedOutputAmount = expectedOutput.amount;\n      const actualAmountAndCoin = txHexTransferAction.quantity.split(' ');\n      const actualOutputAmount = this.bigUnitsToBaseUnits(actualAmountAndCoin[0]);\n      if (expectedOutputAmount !== actualOutputAmount) {\n        throw new Error('txHex receive amount does not match expected recipient amount');\n      }\n\n      if (txPrebuild.coin === 'eos' || txPrebuild.coin === 'teos') {\n        const expectedSymbol = _.isNil(txPrebuild.token) ? 'EOS' : txPrebuild.token.split(':')[1];\n\n        if (actualAmountAndCoin[1] !== expectedSymbol) {\n          throw new Error('txHex receive symbol does not match expected recipient symbol');\n        }\n      } else {\n        // this should never happen\n        throw new Error('txHex coin name does not match expected coin name');\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Generate a random EOS address.\n   *\n   * This is just a random string which abides by the EOS adddress constraints,\n   * and is not actually checked for availability on the EOS blockchain.\n   *\n   * Current EOS address constraints are:\n   * * Address must be exactly 12 characters\n   * * Address must only contain lowercase letters and numbers 1-5\n   * @returns a validly formatted EOS address, which may or may not actually be available on chain.\n   */\n  generateRandomAddress(params: Record<string, never>): string {\n    const address: string[] = [];\n    while (address.length < 12) {\n      const char = _.sample(Eos.VALID_ADDRESS_CHARS);\n      if (!char) {\n        throw new Error('failed to sample valid EOS address characters');\n      }\n      address.push(char);\n    }\n    return address.join('');\n  }\n}\n"]}