@bitgo-beta/sdk-coin-flr 1.0.1-beta.82 → 1.0.1-beta.821

package/dist/src/flr.js

@@ -7,12 +7,55 @@
  * @coinFullName Flare
  * @coinWebsite https://flare-explorer.flare.network
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Flr = void 0;
+const bignumber_js_1 = require("bignumber.js");
+const secp256k1_1 = require("@bitgo-beta/secp256k1");
+const keccak_1 = __importDefault(require("keccak"));
+const secp256k1 = __importStar(require("secp256k1"));
+const _ = __importStar(require("lodash"));
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
 const statics_1 = require("@bitgo-beta/statics");
 const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
 const lib_1 = require("./lib");
+const sdk_coin_flrp_1 = require("@bitgo-beta/sdk-coin-flrp");
+const ethereumjs_util_1 = require("ethereumjs-util");
 class Flr extends abstract_eth_1.AbstractEthLikeNewCoins {
     constructor(bitgo, staticsCoin) {
         super(bitgo, staticsCoin);
@@ -27,15 +70,433 @@ class Flr extends abstract_eth_1.AbstractEthLikeNewCoins {
     supportsTss() {
         return true;
     }
+    /** inherited doc */
+    getDefaultMultisigType() {
+        return sdk_core_1.multisigTypes.tss;
+    }
     /** @inheritDoc */
     getMPCAlgorithm() {
         return 'ecdsa';
     }
-    async recoveryBlockchainExplorerQuery(query) {
-        const apiToken = sdk_core_1.common.Environments[this.bitgo.getEnv()].flrExplorerApiToken;
+    /** @inheritDoc */
+    supportsMessageSigning() {
+        return true;
+    }
+    /** @inheritDoc */
+    supportsSigningTypedData() {
+        return true;
+    }
+    async buildUnsignedSweepTxnTSS(params) {
+        return this.buildUnsignedSweepTxnMPCv2(params);
+    }
+    /**
+     * Validates if an address is valid for FLR
+     * Also validates P-chain addresses for cross-chain transactions
+     * @param {string} address - address to validate
+     * @returns {boolean} - validation result
+     */
+    isValidAddress(address) {
+        // also validate p-chain address for cross-chain txs
+        return !!address && (super.isValidAddress(address) || sdk_coin_flrp_1.FlrPLib.Utils.isValidAddress(address));
+    }
+    /**
+     * Get the corresponding P-chain coin name
+     * @returns {string} flrp or tflrp depending on mainnet/testnet
+     */
+    getFlrP() {
+        return this.getChain().toString() === 'flr' ? 'flrp' : 'tflrp';
+    }
+    /**
+     * Get the atomic transaction builder factory for cross-chain operations
+     * @returns {FlrPLib.TransactionBuilderFactory} the atomic builder factory
+     */
+    getAtomicBuilder() {
+        return new sdk_coin_flrp_1.FlrPLib.TransactionBuilderFactory(statics_1.coins.get(this.getFlrP()));
+    }
+    /**
+     * Check if this coin is a token
+     * @returns {boolean} false for FLR (base chain)
+     */
+    isToken() {
+        return false;
+    }
+    /**
+     * Explains an atomic transaction using atomic builder.
+     * @param {string} txHex - the transaction hex
+     * @returns {Promise<AtomicTransactionExplanation>} the transaction explanation
+     * @private
+     */
+    async explainAtomicTransaction(txHex) {
+        const txBuilder = this.getAtomicBuilder().from(txHex);
+        const tx = await txBuilder.build();
+        return tx.explainTransaction();
+    }
+    /**
+     * Verify signature for an atomic transaction using atomic builder.
+     * @param {string} txHex - the transaction hex
+     * @returns {Promise<boolean>} true if signature is from the input address
+     * @private
+     */
+    async verifySignatureForAtomicTransaction(txHex) {
+        const txBuilder = this.getAtomicBuilder().from(txHex);
+        const tx = await txBuilder.build();
+        const payload = tx.signablePayload;
+        const signatures = tx.signature.map((s) => Buffer.from(sdk_coin_flrp_1.FlrPLib.Utils.removeHexPrefix(s), 'hex'));
+        const network = _.get(tx, '_network');
+        const recoverPubkey = signatures.map((s) => sdk_coin_flrp_1.FlrPLib.Utils.recoverySignature(network, payload, s));
+        const expectedSenders = recoverPubkey.map((r) => (0, ethereumjs_util_1.pubToAddress)(r, true));
+        const senders = tx.inputs.map((i) => sdk_coin_flrp_1.FlrPLib.Utils.parseAddress(i.address));
+        return expectedSenders.every((e) => senders.some((sender) => e.equals(sender)));
+    }
+    /**
+     * Explain a transaction from txHex, overriding BaseCoins
+     * transaction can be either atomic or eth txn.
+     * @param {ExplainTransactionOptions} params The options with which to explain the transaction
+     * @returns {Promise<TransactionExplanation>} the transaction explanation
+     */
+    async explainTransaction(params) {
+        const txHex = params.txHex || (params.halfSigned && params.halfSigned.txHex);
+        if (!txHex) {
+            throw new Error('missing txHex in explain tx parameters');
+        }
+        if (params.crossChainType) {
+            return this.explainAtomicTransaction(txHex);
+        }
+        if (!params.feeInfo) {
+            throw new Error('missing feeInfo in explain tx parameters');
+        }
+        const txBuilder = this.getTransactionBuilder();
+        txBuilder.from(txHex);
+        const tx = await txBuilder.build();
+        return Object.assign(this.explainEVMTransaction(tx), { fee: params.feeInfo });
+    }
+    /**
+     * Explains an EVM transaction using regular eth txn builder
+     * @param {BaseTransaction} tx - the transaction to explain
+     * @returns {Object} the transaction explanation
+     * @private
+     */
+    explainEVMTransaction(tx) {
+        const outputs = tx.outputs.map((output) => {
+            return {
+                address: output.address,
+                amount: output.value,
+            };
+        });
+        const displayOrder = ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee'];
+        return {
+            displayOrder,
+            id: tx.id,
+            outputs: outputs,
+            outputAmount: outputs
+                .reduce((accumulator, output) => accumulator.plus(output.amount), new bignumber_js_1.BigNumber('0'))
+                .toFixed(0),
+            changeOutputs: [], // account based does not use change outputs
+            changeAmount: '0', // account base does not make change
+        };
+    }
+    /**
+     * Verify that a transaction prebuild complies with the original intention
+     *
+     * @param {VerifyFlrTransactionOptions} params
+     * @param params.txParams params object passed to send
+     * @param params.txPrebuild prebuild object returned by server
+     * @param params.wallet Wallet object to obtain keys to verify against
+     * @returns {Promise<boolean>}
+     */
+    async verifyTransaction(params) {
+        const { txParams, txPrebuild, wallet, walletType } = params;
+        // For TSS wallets, use the parent class's TSS-specific verification
+        if (walletType === 'tss') {
+            return super.verifyTransaction(params);
+        }
+        if (!txParams?.recipients || !txPrebuild?.recipients || !wallet) {
+            throw new Error(`missing params`);
+        }
+        if (txParams.hop && txParams.recipients.length > 1) {
+            throw new Error(`tx cannot be both a batch and hop transaction`);
+        }
+        if (txPrebuild.recipients.length > 1) {
+            throw new Error(`${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`);
+        }
+        if (txParams.hop && txPrebuild.hopTransaction) {
+            // Check recipient amount for hop transaction
+            if (txParams.recipients.length !== 1) {
+                throw new Error(`hop transaction only supports 1 recipient but ${txParams.recipients.length} found`);
+            }
+            // Check tx sends to hop address
+            let expectedHopAddress;
+            if (txPrebuild.hopTransaction.type === 'Export') {
+                const decodedHopTx = await this.explainAtomicTransaction(txPrebuild.hopTransaction.tx);
+                expectedHopAddress = abstract_eth_1.optionalDeps.ethUtil.stripHexPrefix(decodedHopTx.inputs[0].address);
+            }
+            else {
+                const decodedHopTx = abstract_eth_1.optionalDeps.EthTx.TransactionFactory.fromSerializedData(abstract_eth_1.optionalDeps.ethUtil.toBuffer(txPrebuild.hopTransaction.tx));
+                expectedHopAddress = abstract_eth_1.optionalDeps.ethUtil.stripHexPrefix(decodedHopTx.getSenderAddress().toString());
+            }
+            const actualHopAddress = abstract_eth_1.optionalDeps.ethUtil.stripHexPrefix(txPrebuild.recipients[0].address);
+            if (expectedHopAddress.toLowerCase() !== actualHopAddress.toLowerCase()) {
+                throw new Error('recipient address of txPrebuild does not match hop address');
+            }
+            // Convert TransactionRecipient array to Recipient array
+            const recipients = txParams.recipients.map((r) => {
+                return {
+                    address: r.address,
+                    amount: typeof r.amount === 'number' ? r.amount.toString() : r.amount,
+                };
+            });
+            // Check destination address and amount
+            await this.validateHopPrebuild(wallet, txPrebuild.hopTransaction, { recipients });
+        }
+        else if (txParams.recipients.length > 1) {
+            // Check total amount for batch transaction
+            let expectedTotalAmount = new bignumber_js_1.BigNumber(0);
+            for (let i = 0; i < txParams.recipients.length; i++) {
+                expectedTotalAmount = expectedTotalAmount.plus(txParams.recipients[i].amount);
+            }
+            if (!expectedTotalAmount.isEqualTo(txPrebuild.recipients[0].amount)) {
+                throw new Error('batch transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client');
+            }
+        }
+        else {
+            // Check recipient address and amount for normal transaction
+            if (txParams.recipients.length !== 1) {
+                throw new Error(`normal transaction only supports 1 recipient but ${txParams.recipients.length} found`);
+            }
+            const expectedAmount = new bignumber_js_1.BigNumber(txParams.recipients[0].amount);
+            if (!expectedAmount.isEqualTo(txPrebuild.recipients[0].amount)) {
+                throw new Error('normal transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client');
+            }
+            if (Flr.isFLRAddress(txParams.recipients[0].address) &&
+                txParams.recipients[0].address !== txPrebuild.recipients[0].address) {
+                throw new Error('destination address in normal txPrebuild does not match that in txParams supplied by client');
+            }
+        }
+        // Check coin is correct for all transaction types
+        if (!this.verifyCoin(txPrebuild)) {
+            throw new Error(`coin in txPrebuild did not match that in txParams supplied by client`);
+        }
+        return true;
+    }
+    /**
+     * Check if an address is a FLR C-chain address (0x format)
+     * @param {string} address - the address to check
+     * @returns {boolean} true if it's a C-chain address
+     * @private
+     */
+    static isFLRAddress(address) {
+        return !!address.match(/0x[a-fA-F0-9]{40}/);
+    }
+    /**
+     * Verify that the coin matches in the prebuild
+     * @param {TransactionPrebuild} txPrebuild - the transaction prebuild
+     * @returns {boolean} true if coin matches
+     */
+    verifyCoin(txPrebuild) {
+        return txPrebuild.coin === this.getChain();
+    }
+    /**
+     * Coin-specific things done before signing a transaction, i.e. verification
+     * @param {PresignTransactionOptions} params - the presign options
+     * @returns {Promise<PresignTransactionOptions>}
+     */
+    async presignTransaction(params) {
+        if (!_.isUndefined(params.hopTransaction) && !_.isUndefined(params.wallet) && !_.isUndefined(params.buildParams)) {
+            await this.validateHopPrebuild(params.wallet, params.hopTransaction);
+        }
+        return params;
+    }
+    /**
+     * Modify prebuild after receiving it from the server. Add things like nlocktime
+     * @param {TransactionPrebuild} params - the transaction prebuild
+     * @returns {Promise<TransactionPrebuild>}
+     */
+    async postProcessPrebuild(params) {
+        if (!_.isUndefined(params.hopTransaction) && !_.isUndefined(params.wallet) && !_.isUndefined(params.buildParams)) {
+            await this.validateHopPrebuild(params.wallet, params.hopTransaction, params.buildParams);
+        }
+        return params;
+    }
+    /**
+     * Validates that the hop prebuild from the HSM is valid and correct
+     * @param {IWallet} wallet The wallet that the prebuild is for
+     * @param {HopPrebuild} hopPrebuild The prebuild to validate
+     * @param {Object} originalParams The original parameters passed to prebuildTransaction
+     * @returns {Promise<void>}
+     * @throws Error if The prebuild is invalid
+     */
+    async validateHopPrebuild(wallet, hopPrebuild, originalParams) {
+        const { tx, id, signature } = hopPrebuild;
+        // first, validate the HSM signature
+        const serverXpub = sdk_core_1.common.Environments[this.bitgo.getEnv()].hsmXpub;
+        const serverPubkeyBuffer = secp256k1_1.bip32.fromBase58(serverXpub).publicKey;
+        const signatureBuffer = Buffer.from(abstract_eth_1.optionalDeps.ethUtil.stripHexPrefix(signature), 'hex');
+        const messageBuffer = hopPrebuild.type === 'Export' ? Flr.getTxHash(tx) : Buffer.from(abstract_eth_1.optionalDeps.ethUtil.stripHexPrefix(id), 'hex');
+        const sig = new Uint8Array(signatureBuffer.length === 64 ? signatureBuffer : signatureBuffer.slice(1));
+        const isValidSignature = secp256k1.ecdsaVerify(sig, messageBuffer, serverPubkeyBuffer);
+        if (!isValidSignature) {
+            throw new Error(`Hop txid signature invalid`);
+        }
+        if (hopPrebuild.type === 'Export') {
+            const explainHopExportTx = await this.explainAtomicTransaction(tx);
+            // If original params are given, we can check them against the transaction prebuild params
+            if (!_.isNil(originalParams)) {
+                const { recipients } = originalParams;
+                // Then validate that the tx params actually equal the requested params to nano flr plus import tx fee.
+                const originalAmount = new bignumber_js_1.BigNumber(recipients[0].amount).div(1e9).plus(1e6).toFixed(0);
+                const originalDestination = recipients[0].address;
+                const hopAmount = explainHopExportTx.outputAmount;
+                const hopDestination = explainHopExportTx.outputs[0].address;
+                if (originalAmount !== hopAmount) {
+                    throw new Error(`Hop amount: ${hopAmount} does not equal original amount: ${originalAmount}`);
+                }
+                if (originalDestination && hopDestination.toLowerCase() !== originalDestination.toLowerCase()) {
+                    throw new Error(`Hop destination: ${hopDestination} does not equal original recipient: ${originalDestination}`);
+                }
+            }
+            if (!(await this.verifySignatureForAtomicTransaction(tx))) {
+                throw new Error(`Invalid hop transaction signature, txid: ${id}`);
+            }
+        }
+        else {
+            const builtHopTx = abstract_eth_1.optionalDeps.EthTx.TransactionFactory.fromSerializedData(abstract_eth_1.optionalDeps.ethUtil.toBuffer(tx));
+            // If original params are given, we can check them against the transaction prebuild params
+            if (!_.isNil(originalParams)) {
+                const { recipients } = originalParams;
+                // Then validate that the tx params actually equal the requested params
+                const originalAmount = new bignumber_js_1.BigNumber(recipients[0].amount);
+                const originalDestination = recipients[0].address;
+                const hopAmount = new bignumber_js_1.BigNumber(abstract_eth_1.optionalDeps.ethUtil.bufferToHex(builtHopTx.value));
+                if (!builtHopTx.to) {
+                    throw new Error(`Transaction does not have a destination address`);
+                }
+                const hopDestination = builtHopTx.to.toString();
+                if (!hopAmount.eq(originalAmount)) {
+                    throw new Error(`Hop amount: ${hopAmount} does not equal original amount: ${originalAmount}`);
+                }
+                if (hopDestination.toLowerCase() !== originalDestination.toLowerCase()) {
+                    throw new Error(`Hop destination: ${hopDestination} does not equal original recipient: ${originalDestination}`);
+                }
+            }
+            if (!builtHopTx.verifySignature()) {
+                // We don't want to continue at all in this case, at risk of FLR being stuck on the hop address
+                throw new Error(`Invalid hop transaction signature, txid: ${id}`);
+            }
+            if (abstract_eth_1.optionalDeps.ethUtil.addHexPrefix(builtHopTx.hash().toString('hex')) !== id) {
+                throw new Error(`Signed hop txid does not equal actual txid`);
+            }
+        }
+    }
+    /**
+     * Modify prebuild before sending it to the server. Add things like hop transaction params
+     * @param {BuildOptions} buildParams The whitelisted parameters for this prebuild
+     * @param {boolean} buildParams.hop True if this should prebuild a hop tx, else false
+     * @param {Recipient[]} buildParams.recipients The recipients array of this transaction
+     * @param {Wallet} buildParams.wallet The wallet sending this tx
+     * @param {string} buildParams.walletPassphrase the passphrase for this wallet
+     * @returns {Promise<BuildOptions>}
+     */
+    async getExtraPrebuildParams(buildParams) {
+        if (!_.isUndefined(buildParams.hop) &&
+            buildParams.hop &&
+            !_.isUndefined(buildParams.wallet) &&
+            !_.isUndefined(buildParams.recipients)) {
+            if (this.isToken()) {
+                throw new Error(`Hop transactions are not enabled for FLR tokens, nor are they necessary. Please remove the 'hop' parameter and try again.`);
+            }
+            return (await this.createHopTransactionParams({
+                recipients: buildParams.recipients,
+                type: buildParams.type,
+            }));
+        }
+        return {};
+    }
+    /**
+     * Creates the extra parameters needed to build a hop transaction
+     * @param {HopTransactionBuildOptions} params The original build parameters
+     * @returns {Promise<HopParams>} extra parameters object to merge with the original build parameters object and send to the platform
+     */
+    async createHopTransactionParams({ recipients, type }) {
+        if (!recipients || !Array.isArray(recipients)) {
+            throw new Error('expecting array of recipients');
+        }
+        // Right now we only support 1 recipient
+        if (recipients.length !== 1) {
+            throw new Error('must send to exactly 1 recipient');
+        }
+        const recipientAddress = recipients[0].address;
+        const recipientAmount = recipients[0].amount;
+        const feeEstimateParams = {
+            recipient: recipientAddress,
+            amount: recipientAmount,
+            hop: true,
+            type,
+        };
+        const feeEstimate = await this.feeEstimate(feeEstimateParams);
+        const gasLimit = feeEstimate.gasLimitEstimate;
+        // Even if `feeEstimate < gasLimit`, we shouldn't end up with `gasPrice === 0`.
+        const gasPrice = Math.max(Math.round(feeEstimate.feeEstimate / gasLimit), 1);
+        const gasPriceMax = gasPrice * 5;
+        // Payment id is a random number so its different for every tx
+        const paymentId = Math.floor(Math.random() * 10000000000).toString();
+        const userReqSig = '0x';
+        return {
+            hopParams: {
+                userReqSig,
+                gasPriceMax,
+                paymentId,
+                gasLimit,
+            },
+        };
+    }
+    /**
+     * Fetch fee estimate information from the server
+     * @param {FeeEstimateOptions} params The params passed into the function
+     * @param {Boolean} [params.hop] True if we should estimate fee for a hop transaction
+     * @param {String} [params.recipient] The recipient of the transaction to estimate a send to
+     * @param {String} [params.data] The data to estimate a send for
+     * @returns {Promise<FeeEstimate>} The fee info returned from the server
+     */
+    async feeEstimate(params) {
+        const query = {};
+        if (params && params.hop) {
+            query.hop = params.hop;
+        }
+        if (params && params.recipient) {
+            query.recipient = params.recipient;
+        }
+        if (params && params.data) {
+            query.data = params.data;
+        }
+        if (params && params.amount) {
+            query.amount = params.amount;
+        }
+        if (params && params.type) {
+            query.type = params.type;
+        }
+        return await this.bitgo.get(this.url('/tx/fee')).query(query).result();
+    }
+    /**
+     * Calculate tx hash like evm from tx hex.
+     * @param {string} tx - the transaction hex
+     * @returns {Buffer} tx hash
+     */
+    static getTxHash(tx) {
+        const hash = (0, keccak_1.default)('keccak256');
+        hash.update(abstract_eth_1.optionalDeps.ethUtil.stripHexPrefix(tx), 'hex');
+        return hash.digest();
+    }
+    /**
+     * Make a query to Flare explorer for information such as balance, token balance, solidity calls
+     * @param {Object} query key-value pairs of parameters to append after /api
+     * @param {string} apiKey optional API key to use instead of the one from the environment
+     * @returns {Promise<Object>} response from Flare explorer
+     */
+    async recoveryBlockchainExplorerQuery(query, apiKey) {
+        const apiToken = apiKey || sdk_core_1.common.Environments[this.bitgo.getEnv()].flrExplorerApiToken;
         const explorerUrl = sdk_core_1.common.Environments[this.bitgo.getEnv()].flrExplorerBaseUrl;
         return await (0, abstract_eth_1.recoveryBlockchainExplorerQuery)(query, explorerUrl, apiToken);
     }
 }
 exports.Flr = Flr;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flr.js","sourceRoot":"","sources":["../../src/flr.ts"],"names":[],"mappings":"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","sourcesContent":["/***\n * @developerReferences\n * - Developer Hub: https://dev.flare.network/\n * - Doc: https://docs.flare.network/user/wallets/\n *\n * @coinFullName Flare\n * @coinWebsite https://flare-explorer.flare.network\n */\n\nimport { BigNumber } from 'bignumber.js';\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport Keccak from 'keccak';\nimport * as secp256k1 from 'secp256k1';\nimport * as _ from 'lodash';\nimport {\n  BaseCoin,\n  BaseTransaction,\n  BitGoBase,\n  common,\n  FeeEstimateOptions,\n  IWallet,\n  MPCAlgorithm,\n  MultisigType,\n  multisigTypes,\n  Recipient,\n  TransactionExplanation,\n  Entry,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin as StaticsBaseCoin, coins, FlareNetwork } from '@bitgo-beta/statics';\nimport {\n  AbstractEthLikeNewCoins,\n  optionalDeps,\n  recoveryBlockchainExplorerQuery,\n  UnsignedSweepTxMPCv2,\n  RecoverOptions,\n  OfflineVaultTxInfo,\n} from '@bitgo-beta/abstract-eth';\nimport { TransactionBuilder } from './lib';\nimport { FlrPLib } from '@bitgo-beta/sdk-coin-flrp';\nimport { pubToAddress } from 'ethereumjs-util';\nimport {\n  BuildOptions,\n  ExplainTransactionOptions,\n  FeeEstimate,\n  HopParams,\n  HopPrebuild,\n  HopTransactionBuildOptions,\n  PresignTransactionOptions,\n  TransactionPrebuild,\n  VerifyFlrTransactionOptions,\n} from './iface';\n\n/**\n * Extended TransactionExplanation interface with inputs for atomic transactions\n */\ninterface AtomicTransactionExplanation extends TransactionExplanation {\n  inputs: Entry[];\n}\n\nexport class Flr extends AbstractEthLikeNewCoins {\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo, staticsCoin);\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Flr(bitgo, staticsCoin);\n  }\n\n  protected getTransactionBuilder(): TransactionBuilder {\n    return new TransactionBuilder(coins.get(this.getBaseChain()));\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  /** @inheritDoc */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  /** @inheritDoc */\n  supportsMessageSigning(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  supportsSigningTypedData(): boolean {\n    return true;\n  }\n\n  protected async buildUnsignedSweepTxnTSS(params: RecoverOptions): Promise<OfflineVaultTxInfo | UnsignedSweepTxMPCv2> {\n    return this.buildUnsignedSweepTxnMPCv2(params);\n  }\n\n  /**\n   * Validates if an address is valid for FLR\n   * Also validates P-chain addresses for cross-chain transactions\n   * @param {string} address - address to validate\n   * @returns {boolean} - validation result\n   */\n  isValidAddress(address: string): boolean {\n    // also validate p-chain address for cross-chain txs\n    return !!address && (super.isValidAddress(address) || FlrPLib.Utils.isValidAddress(address));\n  }\n\n  /**\n   * Get the corresponding P-chain coin name\n   * @returns {string} flrp or tflrp depending on mainnet/testnet\n   */\n  getFlrP(): string {\n    return this.getChain().toString() === 'flr' ? 'flrp' : 'tflrp';\n  }\n\n  /**\n   * Get the atomic transaction builder factory for cross-chain operations\n   * @returns {FlrPLib.TransactionBuilderFactory} the atomic builder factory\n   */\n  protected getAtomicBuilder(): FlrPLib.TransactionBuilderFactory {\n    return new FlrPLib.TransactionBuilderFactory(coins.get(this.getFlrP()));\n  }\n\n  /**\n   * Check if this coin is a token\n   * @returns {boolean} false for FLR (base chain)\n   */\n  isToken(): boolean {\n    return false;\n  }\n\n  /**\n   * Explains an atomic transaction using atomic builder.\n   * @param {string} txHex - the transaction hex\n   * @returns {Promise<AtomicTransactionExplanation>} the transaction explanation\n   * @private\n   */\n  private async explainAtomicTransaction(txHex: string): Promise<AtomicTransactionExplanation> {\n    const txBuilder = this.getAtomicBuilder().from(txHex);\n    const tx = await txBuilder.build();\n    return tx.explainTransaction() as AtomicTransactionExplanation;\n  }\n\n  /**\n   * Verify signature for an atomic transaction using atomic builder.\n   * @param {string} txHex - the transaction hex\n   * @returns {Promise<boolean>} true if signature is from the input address\n   * @private\n   */\n  private async verifySignatureForAtomicTransaction(txHex: string): Promise<boolean> {\n    const txBuilder = this.getAtomicBuilder().from(txHex);\n    const tx = await txBuilder.build();\n    const payload = tx.signablePayload;\n    const signatures = tx.signature.map((s) => Buffer.from(FlrPLib.Utils.removeHexPrefix(s), 'hex'));\n    const network = _.get(tx, '_network');\n    const recoverPubkey = signatures.map((s) =>\n      FlrPLib.Utils.recoverySignature(network as unknown as FlareNetwork, payload, s)\n    );\n    const expectedSenders = recoverPubkey.map((r) => pubToAddress(r, true));\n    const senders = tx.inputs.map((i) => FlrPLib.Utils.parseAddress(i.address));\n    return expectedSenders.every((e) => senders.some((sender) => e.equals(sender)));\n  }\n\n  /**\n   * Explain a transaction from txHex, overriding BaseCoins\n   * transaction can be either atomic or eth txn.\n   * @param {ExplainTransactionOptions} params The options with which to explain the transaction\n   * @returns {Promise<TransactionExplanation>} the transaction explanation\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation> {\n    const txHex = params.txHex || (params.halfSigned && params.halfSigned.txHex);\n    if (!txHex) {\n      throw new Error('missing txHex in explain tx parameters');\n    }\n    if (params.crossChainType) {\n      return this.explainAtomicTransaction(txHex);\n    }\n    if (!params.feeInfo) {\n      throw new Error('missing feeInfo in explain tx parameters');\n    }\n    const txBuilder = this.getTransactionBuilder();\n    txBuilder.from(txHex);\n    const tx = await txBuilder.build();\n    return Object.assign(this.explainEVMTransaction(tx), { fee: params.feeInfo });\n  }\n\n  /**\n   * Explains an EVM transaction using regular eth txn builder\n   * @param {BaseTransaction} tx - the transaction to explain\n   * @returns {Object} the transaction explanation\n   * @private\n   */\n  private explainEVMTransaction(tx: BaseTransaction) {\n    const outputs = tx.outputs.map((output) => {\n      return {\n        address: output.address,\n        amount: output.value,\n      };\n    });\n    const displayOrder = ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee'];\n    return {\n      displayOrder,\n      id: tx.id,\n      outputs: outputs,\n      outputAmount: outputs\n        .reduce((accumulator, output) => accumulator.plus(output.amount), new BigNumber('0'))\n        .toFixed(0),\n      changeOutputs: [], // account based does not use change outputs\n      changeAmount: '0', // account base does not make change\n    };\n  }\n\n  /**\n   * Verify that a transaction prebuild complies with the original intention\n   *\n   * @param {VerifyFlrTransactionOptions} params\n   * @param params.txParams params object passed to send\n   * @param params.txPrebuild prebuild object returned by server\n   * @param params.wallet Wallet object to obtain keys to verify against\n   * @returns {Promise<boolean>}\n   */\n  async verifyTransaction(params: VerifyFlrTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild, wallet, walletType } = params;\n\n    // For TSS wallets, use the parent class's TSS-specific verification\n    if (walletType === 'tss') {\n      return super.verifyTransaction(params);\n    }\n\n    if (!txParams?.recipients || !txPrebuild?.recipients || !wallet) {\n      throw new Error(`missing params`);\n    }\n    if (txParams.hop && txParams.recipients.length > 1) {\n      throw new Error(`tx cannot be both a batch and hop transaction`);\n    }\n    if (txPrebuild.recipients.length > 1) {\n      throw new Error(\n        `${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`\n      );\n    }\n    if (txParams.hop && txPrebuild.hopTransaction) {\n      // Check recipient amount for hop transaction\n      if (txParams.recipients.length !== 1) {\n        throw new Error(`hop transaction only supports 1 recipient but ${txParams.recipients.length} found`);\n      }\n      // Check tx sends to hop address\n      let expectedHopAddress;\n      if (txPrebuild.hopTransaction.type === 'Export') {\n        const decodedHopTx = await this.explainAtomicTransaction(txPrebuild.hopTransaction.tx);\n        expectedHopAddress = optionalDeps.ethUtil.stripHexPrefix(decodedHopTx.inputs[0].address);\n      } else {\n        const decodedHopTx = optionalDeps.EthTx.TransactionFactory.fromSerializedData(\n          optionalDeps.ethUtil.toBuffer(txPrebuild.hopTransaction.tx)\n        );\n        expectedHopAddress = optionalDeps.ethUtil.stripHexPrefix(decodedHopTx.getSenderAddress().toString());\n      }\n      const actualHopAddress = optionalDeps.ethUtil.stripHexPrefix(txPrebuild.recipients[0].address);\n      if (expectedHopAddress.toLowerCase() !== actualHopAddress.toLowerCase()) {\n        throw new Error('recipient address of txPrebuild does not match hop address');\n      }\n\n      // Convert TransactionRecipient array to Recipient array\n      const recipients: Recipient[] = txParams.recipients.map((r) => {\n        return {\n          address: r.address,\n          amount: typeof r.amount === 'number' ? r.amount.toString() : r.amount,\n        };\n      });\n\n      // Check destination address and amount\n      await this.validateHopPrebuild(wallet, txPrebuild.hopTransaction, { recipients });\n    } else if (txParams.recipients.length > 1) {\n      // Check total amount for batch transaction\n      let expectedTotalAmount = new BigNumber(0);\n      for (let i = 0; i < txParams.recipients.length; i++) {\n        expectedTotalAmount = expectedTotalAmount.plus(txParams.recipients[i].amount);\n      }\n      if (!expectedTotalAmount.isEqualTo(txPrebuild.recipients[0].amount)) {\n        throw new Error(\n          'batch transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client'\n        );\n      }\n    } else {\n      // Check recipient address and amount for normal transaction\n      if (txParams.recipients.length !== 1) {\n        throw new Error(`normal transaction only supports 1 recipient but ${txParams.recipients.length} found`);\n      }\n      const expectedAmount = new BigNumber(txParams.recipients[0].amount);\n      if (!expectedAmount.isEqualTo(txPrebuild.recipients[0].amount)) {\n        throw new Error(\n          'normal transaction amount in txPrebuild received from BitGo servers does not match txParams supplied by client'\n        );\n      }\n      if (\n        Flr.isFLRAddress(txParams.recipients[0].address) &&\n        txParams.recipients[0].address !== txPrebuild.recipients[0].address\n      ) {\n        throw new Error('destination address in normal txPrebuild does not match that in txParams supplied by client');\n      }\n    }\n    // Check coin is correct for all transaction types\n    if (!this.verifyCoin(txPrebuild)) {\n      throw new Error(`coin in txPrebuild did not match that in txParams supplied by client`);\n    }\n    return true;\n  }\n\n  /**\n   * Check if an address is a FLR C-chain address (0x format)\n   * @param {string} address - the address to check\n   * @returns {boolean} true if it's a C-chain address\n   * @private\n   */\n  private static isFLRAddress(address: string): boolean {\n    return !!address.match(/0x[a-fA-F0-9]{40}/);\n  }\n\n  /**\n   * Verify that the coin matches in the prebuild\n   * @param {TransactionPrebuild} txPrebuild - the transaction prebuild\n   * @returns {boolean} true if coin matches\n   */\n  verifyCoin(txPrebuild: TransactionPrebuild): boolean {\n    return txPrebuild.coin === this.getChain();\n  }\n\n  /**\n   * Coin-specific things done before signing a transaction, i.e. verification\n   * @param {PresignTransactionOptions} params - the presign options\n   * @returns {Promise<PresignTransactionOptions>}\n   */\n  async presignTransaction(params: PresignTransactionOptions): Promise<PresignTransactionOptions> {\n    if (!_.isUndefined(params.hopTransaction) && !_.isUndefined(params.wallet) && !_.isUndefined(params.buildParams)) {\n      await this.validateHopPrebuild(params.wallet, params.hopTransaction);\n    }\n    return params;\n  }\n\n  /**\n   * Modify prebuild after receiving it from the server. Add things like nlocktime\n   * @param {TransactionPrebuild} params - the transaction prebuild\n   * @returns {Promise<TransactionPrebuild>}\n   */\n  async postProcessPrebuild(params: TransactionPrebuild): Promise<TransactionPrebuild> {\n    if (!_.isUndefined(params.hopTransaction) && !_.isUndefined(params.wallet) && !_.isUndefined(params.buildParams)) {\n      await this.validateHopPrebuild(params.wallet, params.hopTransaction, params.buildParams);\n    }\n    return params;\n  }\n\n  /**\n   * Validates that the hop prebuild from the HSM is valid and correct\n   * @param {IWallet} wallet The wallet that the prebuild is for\n   * @param {HopPrebuild} hopPrebuild The prebuild to validate\n   * @param {Object} originalParams The original parameters passed to prebuildTransaction\n   * @returns {Promise<void>}\n   * @throws Error if The prebuild is invalid\n   */\n  async validateHopPrebuild(\n    wallet: IWallet,\n    hopPrebuild: HopPrebuild,\n    originalParams?: { recipients: Recipient[] }\n  ): Promise<void> {\n    const { tx, id, signature } = hopPrebuild;\n\n    // first, validate the HSM signature\n    const serverXpub = common.Environments[this.bitgo.getEnv()].hsmXpub;\n    const serverPubkeyBuffer: Buffer = bip32.fromBase58(serverXpub).publicKey;\n    const signatureBuffer: Buffer = Buffer.from(optionalDeps.ethUtil.stripHexPrefix(signature), 'hex');\n    const messageBuffer: Buffer =\n      hopPrebuild.type === 'Export' ? Flr.getTxHash(tx) : Buffer.from(optionalDeps.ethUtil.stripHexPrefix(id), 'hex');\n\n    const sig = new Uint8Array(signatureBuffer.length === 64 ? signatureBuffer : signatureBuffer.slice(1));\n    const isValidSignature: boolean = secp256k1.ecdsaVerify(sig, messageBuffer, serverPubkeyBuffer);\n    if (!isValidSignature) {\n      throw new Error(`Hop txid signature invalid`);\n    }\n\n    if (hopPrebuild.type === 'Export') {\n      const explainHopExportTx = await this.explainAtomicTransaction(tx);\n      // If original params are given, we can check them against the transaction prebuild params\n      if (!_.isNil(originalParams)) {\n        const { recipients } = originalParams;\n\n        // Then validate that the tx params actually equal the requested params to nano flr plus import tx fee.\n        const originalAmount = new BigNumber(recipients[0].amount).div(1e9).plus(1e6).toFixed(0);\n        const originalDestination: string | undefined = recipients[0].address;\n        const hopAmount = explainHopExportTx.outputAmount;\n        const hopDestination = explainHopExportTx.outputs[0].address;\n        if (originalAmount !== hopAmount) {\n          throw new Error(`Hop amount: ${hopAmount} does not equal original amount: ${originalAmount}`);\n        }\n        if (originalDestination && hopDestination.toLowerCase() !== originalDestination.toLowerCase()) {\n          throw new Error(\n            `Hop destination: ${hopDestination} does not equal original recipient: ${originalDestination}`\n          );\n        }\n      }\n      if (!(await this.verifySignatureForAtomicTransaction(tx))) {\n        throw new Error(`Invalid hop transaction signature, txid: ${id}`);\n      }\n    } else {\n      const builtHopTx = optionalDeps.EthTx.TransactionFactory.fromSerializedData(optionalDeps.ethUtil.toBuffer(tx));\n      // If original params are given, we can check them against the transaction prebuild params\n      if (!_.isNil(originalParams)) {\n        const { recipients } = originalParams;\n\n        // Then validate that the tx params actually equal the requested params\n        const originalAmount = new BigNumber(recipients[0].amount);\n        const originalDestination: string = recipients[0].address;\n\n        const hopAmount = new BigNumber(optionalDeps.ethUtil.bufferToHex(builtHopTx.value as unknown as Buffer));\n        if (!builtHopTx.to) {\n          throw new Error(`Transaction does not have a destination address`);\n        }\n        const hopDestination = builtHopTx.to.toString();\n        if (!hopAmount.eq(originalAmount)) {\n          throw new Error(`Hop amount: ${hopAmount} does not equal original amount: ${originalAmount}`);\n        }\n        if (hopDestination.toLowerCase() !== originalDestination.toLowerCase()) {\n          throw new Error(\n            `Hop destination: ${hopDestination} does not equal original recipient: ${originalDestination}`\n          );\n        }\n      }\n\n      if (!builtHopTx.verifySignature()) {\n        // We don't want to continue at all in this case, at risk of FLR being stuck on the hop address\n        throw new Error(`Invalid hop transaction signature, txid: ${id}`);\n      }\n      if (optionalDeps.ethUtil.addHexPrefix(builtHopTx.hash().toString('hex')) !== id) {\n        throw new Error(`Signed hop txid does not equal actual txid`);\n      }\n    }\n  }\n\n  /**\n   * Modify prebuild before sending it to the server. Add things like hop transaction params\n   * @param {BuildOptions} buildParams The whitelisted parameters for this prebuild\n   * @param {boolean} buildParams.hop True if this should prebuild a hop tx, else false\n   * @param {Recipient[]} buildParams.recipients The recipients array of this transaction\n   * @param {Wallet} buildParams.wallet The wallet sending this tx\n   * @param {string} buildParams.walletPassphrase the passphrase for this wallet\n   * @returns {Promise<BuildOptions>}\n   */\n  async getExtraPrebuildParams(buildParams: BuildOptions): Promise<BuildOptions> {\n    if (\n      !_.isUndefined(buildParams.hop) &&\n      buildParams.hop &&\n      !_.isUndefined(buildParams.wallet) &&\n      !_.isUndefined(buildParams.recipients)\n    ) {\n      if (this.isToken()) {\n        throw new Error(\n          `Hop transactions are not enabled for FLR tokens, nor are they necessary. Please remove the 'hop' parameter and try again.`\n        );\n      }\n      return (await this.createHopTransactionParams({\n        recipients: buildParams.recipients,\n        type: buildParams.type as HopTransactionBuildOptions['type'],\n      })) as unknown as BuildOptions;\n    }\n    return {};\n  }\n\n  /**\n   * Creates the extra parameters needed to build a hop transaction\n   * @param {HopTransactionBuildOptions} params The original build parameters\n   * @returns {Promise<HopParams>} extra parameters object to merge with the original build parameters object and send to the platform\n   */\n  async createHopTransactionParams({ recipients, type }: HopTransactionBuildOptions): Promise<HopParams> {\n    if (!recipients || !Array.isArray(recipients)) {\n      throw new Error('expecting array of recipients');\n    }\n\n    // Right now we only support 1 recipient\n    if (recipients.length !== 1) {\n      throw new Error('must send to exactly 1 recipient');\n    }\n    const recipientAddress = recipients[0].address;\n    const recipientAmount = recipients[0].amount;\n    const feeEstimateParams = {\n      recipient: recipientAddress,\n      amount: recipientAmount,\n      hop: true,\n      type,\n    };\n    const feeEstimate: FeeEstimate = await this.feeEstimate(feeEstimateParams);\n\n    const gasLimit = feeEstimate.gasLimitEstimate;\n    // Even if `feeEstimate < gasLimit`, we shouldn't end up with `gasPrice === 0`.\n    const gasPrice = Math.max(Math.round(feeEstimate.feeEstimate / gasLimit), 1);\n    const gasPriceMax = gasPrice * 5;\n    // Payment id is a random number so its different for every tx\n    const paymentId = Math.floor(Math.random() * 10000000000).toString();\n\n    const userReqSig = '0x';\n\n    return {\n      hopParams: {\n        userReqSig,\n        gasPriceMax,\n        paymentId,\n        gasLimit,\n      },\n    };\n  }\n\n  /**\n   * Fetch fee estimate information from the server\n   * @param {FeeEstimateOptions} params The params passed into the function\n   * @param {Boolean} [params.hop] True if we should estimate fee for a hop transaction\n   * @param {String} [params.recipient] The recipient of the transaction to estimate a send to\n   * @param {String} [params.data] The data to estimate a send for\n   * @returns {Promise<FeeEstimate>} The fee info returned from the server\n   */\n  async feeEstimate(params: FeeEstimateOptions): Promise<FeeEstimate> {\n    const query: FeeEstimateOptions = {};\n    if (params && params.hop) {\n      query.hop = params.hop;\n    }\n    if (params && params.recipient) {\n      query.recipient = params.recipient;\n    }\n    if (params && params.data) {\n      query.data = params.data;\n    }\n    if (params && params.amount) {\n      query.amount = params.amount;\n    }\n    if (params && params.type) {\n      query.type = params.type;\n    }\n\n    return await this.bitgo.get(this.url('/tx/fee')).query(query).result();\n  }\n\n  /**\n   * Calculate tx hash like evm from tx hex.\n   * @param {string} tx - the transaction hex\n   * @returns {Buffer} tx hash\n   */\n  static getTxHash(tx: string): Buffer {\n    const hash = Keccak('keccak256');\n    hash.update(optionalDeps.ethUtil.stripHexPrefix(tx), 'hex');\n    return hash.digest();\n  }\n\n  /**\n   * Make a query to Flare 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} apiKey optional API key to use instead of the one from the environment\n   * @returns {Promise<Object>} response from Flare explorer\n   */\n  async recoveryBlockchainExplorerQuery(\n    query: Record<string, string>,\n    apiKey?: string\n  ): Promise<Record<string, unknown>> {\n    const apiToken = apiKey || common.Environments[this.bitgo.getEnv()].flrExplorerApiToken;\n    const explorerUrl = common.Environments[this.bitgo.getEnv()].flrExplorerBaseUrl;\n    return await recoveryBlockchainExplorerQuery(query, explorerUrl as string, apiToken);\n  }\n}\n"]}

package/dist/src/flrToken.d.ts

@@ -0,0 +1,26 @@
+import { EthLikeTokenConfig } from '@bitgo-beta/statics';
+import { BitGoBase, CoinConstructor, MPCAlgorithm, NamedCoinConstructor } from '@bitgo-beta/sdk-core';
+import { CoinNames, EthLikeToken } from '@bitgo-beta/abstract-eth';
+import { TransactionBuilder } from './lib';
+export { EthLikeTokenConfig };
+export declare class FlrToken extends EthLikeToken {
+    readonly tokenConfig: EthLikeTokenConfig;
+    static coinNames: CoinNames;
+    constructor(bitgo: BitGoBase, tokenConfig: EthLikeTokenConfig);
+    static createTokenConstructor(config: EthLikeTokenConfig): CoinConstructor;
+    static createTokenConstructors(): NamedCoinConstructor[];
+    protected getTransactionBuilder(): TransactionBuilder;
+    /** @inheritDoc **/
+    getMPCAlgorithm(): MPCAlgorithm;
+    /** @inheritDoc */
+    supportsTss(): boolean;
+    /**
+     * Make a query to Flare explorer for information such as balance, token balance, solidity calls
+     * @param {Object} query key-value pairs of parameters to append after /api
+     * @param {string} apiKey optional API key to use instead of the one from the environment
+     * @returns {Promise<Object>} response from Flare explorer
+     */
+    recoveryBlockchainExplorerQuery(query: Record<string, string>, apiKey?: string): Promise<Record<string, unknown>>;
+    getFullName(): string;
+}
+//# sourceMappingURL=flrToken.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flrToken.d.ts","sourceRoot":"","sources":["../../src/flrToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,eAAe,EAAU,YAAY,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC9G,OAAO,EAAE,SAAS,EAAE,YAAY,EAAmC,MAAM,0BAA0B,CAAC;AAEpG,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAE3C,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAE9B,qBAAa,QAAS,SAAQ,YAAY;IACxC,SAAgB,WAAW,EAAE,kBAAkB,CAAC;IAChD,MAAM,CAAC,SAAS,EAAE,SAAS,CAGzB;gBACU,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,kBAAkB;IAG7D,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,GAAG,eAAe;IAI1E,MAAM,CAAC,uBAAuB,IAAI,oBAAoB,EAAE;IAIxD,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;IAIrD,mBAAmB;IACnB,eAAe,IAAI,YAAY;IAI/B,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB;;;;;OAKG;IACG,+BAA+B,CACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAMnC,WAAW,IAAI,MAAM;CAGtB"}