@ledgerhq/coin-evm 2.16.0-nightly.2 → 2.16.0

package/lib/__tests__/coin-tester/indexer.js

@@ -0,0 +1,647 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initMswHandlers = exports.indexBlocks = exports.setBlock = exports.resetIndexer = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const node_1 = require("msw/node");
+const bluebird_1 = __importDefault(require("bluebird"));
+const msw_1 = require("msw");
+const ethers_1 = require("ethers");
+const erc1155_abi_json_1 = __importDefault(require("../../abis/erc1155.abi.json"));
+const erc721_abi_json_1 = __importDefault(require("../../abis/erc721.abi.json"));
+const erc20_abi_json_1 = __importDefault(require("../../abis/erc20.abi.json"));
+const logic_1 = require("../../logic");
+const MAX_BLOCK_RANGE = 1024;
+const ERC20Interface = new ethers_1.utils.Interface(erc20_abi_json_1.default);
+const ERC721Interface = new ethers_1.utils.Interface(erc721_abi_json_1.default);
+const ERC1155Interface = new ethers_1.utils.Interface(erc1155_abi_json_1.default);
+const TRANSFER_EVENTS_TOPICS = {
+    ERC20: ERC20Interface.getEventTopic("Transfer"),
+    ERC721: ERC721Interface.getEventTopic("Transfer"),
+    ERC1155: ERC1155Interface.getEventTopic("TransferSingle"),
+};
+const explorerEtherscanOperationByAddress = {};
+const explorerEtherscanERC20EventsByAddress = {};
+const explorerEtherscanERC721EventsByAddress = {};
+const explorerEtherscanERC1155EventsByAddress = {};
+const explorerEtherscanInternalByAddress = {};
+const explorerLedgerOperationByAddress = {};
+const resetIndexer = () => {
+    (0, exports.setBlock)(0);
+    server?.close();
+    for (const address in explorerEtherscanOperationByAddress) {
+        delete explorerEtherscanOperationByAddress[address];
+    }
+    for (const address in explorerEtherscanERC20EventsByAddress) {
+        delete explorerEtherscanERC20EventsByAddress[address];
+    }
+    for (const address in explorerEtherscanERC721EventsByAddress) {
+        delete explorerEtherscanERC721EventsByAddress[address];
+    }
+    for (const address in explorerEtherscanERC1155EventsByAddress) {
+        delete explorerEtherscanERC1155EventsByAddress[address];
+    }
+    for (const address in explorerEtherscanInternalByAddress) {
+        delete explorerEtherscanInternalByAddress[address];
+    }
+    for (const address in explorerLedgerOperationByAddress) {
+        delete explorerLedgerOperationByAddress[address];
+    }
+};
+exports.resetIndexer = resetIndexer;
+const handleLog = async (log, provider) => {
+    const contractDecimals = await provider
+        .call({ to: log.address, data: ERC20Interface.encodeFunctionData("decimals") })
+        .then(res => (!res || res === "0x" ? false : true));
+    const isERC20 = log.topics[0] === TRANSFER_EVENTS_TOPICS.ERC20 && contractDecimals;
+    const isERC721 = log.topics[0] === TRANSFER_EVENTS_TOPICS.ERC721 && !contractDecimals;
+    const isERC1155 = log.topics[0] === TRANSFER_EVENTS_TOPICS.ERC1155;
+    if (isERC20) {
+        return handleERC20Log(log, provider);
+    }
+    else if (isERC721) {
+        return handleERC721Log(log, provider);
+    }
+    else if (isERC1155) {
+        return handleERC1155Log(log, provider);
+    }
+};
+const handleERC20Log = async (log, provider) => {
+    const [name, ticker, decimals, block, tx, receipt] = await Promise.all([
+        provider
+            .call({ to: log.address, data: ERC20Interface.encodeFunctionData("name") })
+            .then(res => ethers_1.ethers.utils.defaultAbiCoder.decode(["string"], res)[0]),
+        provider
+            .call({ to: log.address, data: ERC20Interface.encodeFunctionData("symbol") })
+            .then(res => ethers_1.ethers.utils.defaultAbiCoder.decode(["string"], res)[0]),
+        provider
+            .call({ to: log.address, data: ERC20Interface.encodeFunctionData("decimals") })
+            .then(res => new bignumber_js_1.default(res).toString()),
+        provider.getBlock(log.blockHash),
+        provider.getTransaction(log.transactionHash),
+        provider.getTransactionReceipt(log.transactionHash),
+    ]);
+    const from = (0, logic_1.safeEncodeEIP55)(ethers_1.ethers.utils.defaultAbiCoder.decode(["address"], log.topics[1])[0]);
+    const to = (0, logic_1.safeEncodeEIP55)(ethers_1.ethers.utils.defaultAbiCoder.decode(["address"], log.topics[2])[0]);
+    const amount = ethers_1.ethers.BigNumber.from(log.data === "0x" ? 0 : log.data).toString();
+    const etherscanErc20Event = {
+        blockNumber: block.number.toString(),
+        timeStamp: block.timestamp.toString(),
+        hash: log.transactionHash,
+        nonce: tx.nonce.toString(),
+        blockHash: block.hash,
+        from,
+        to,
+        value: amount,
+        tokenName: name,
+        tokenSymbol: ticker,
+        tokenDecimal: decimals,
+        transactionIndex: block.transactions.indexOf(log.transactionHash).toString(),
+        gas: tx.gasLimit.toString(),
+        gasPrice: tx.gasPrice?.toString() || "",
+        cumulativeGasUsed: receipt.cumulativeGasUsed.toString(),
+        gasUsed: receipt?.gasUsed?.toString() || "0",
+        input: tx.data,
+        confirmations: tx.confirmations.toString(),
+        contractAddress: tx.to.toLowerCase(),
+    };
+    if (!explorerEtherscanERC20EventsByAddress[from]) {
+        explorerEtherscanERC20EventsByAddress[from] = new Map();
+    }
+    if (!explorerEtherscanERC20EventsByAddress[to]) {
+        explorerEtherscanERC20EventsByAddress[to] = new Map();
+    }
+    explorerEtherscanERC20EventsByAddress[from].set(etherscanErc20Event.hash, etherscanErc20Event);
+    explorerEtherscanERC20EventsByAddress[to].set(etherscanErc20Event.hash, etherscanErc20Event);
+    if (!explorerLedgerOperationByAddress[from]) {
+        explorerLedgerOperationByAddress[from] = new Map();
+    }
+    if (!explorerLedgerOperationByAddress[to]) {
+        explorerLedgerOperationByAddress[to] = new Map();
+    }
+    const alreadyExistingOperation = explorerLedgerOperationByAddress[from].get(tx.hash) ||
+        explorerLedgerOperationByAddress[to].get(tx.hash);
+    const ledgerOperation = alreadyExistingOperation
+        ? {
+            ...alreadyExistingOperation,
+            transfer_events: [
+                {
+                    contract: log.address,
+                    count: amount,
+                    from,
+                    to,
+                },
+            ],
+        }
+        : {
+            hash: log.transactionHash,
+            transaction_type: receipt.type,
+            nonce: "",
+            nonce_value: -1,
+            value: tx.value.toString(),
+            gas: tx.gasLimit.toString(),
+            gas_price: receipt.effectiveGasPrice.toString(),
+            max_fee_per_gas: tx.type === 2 ? tx.maxFeePerGas.toString() : null,
+            max_priority_fee_per_gas: tx.type === 2 ? tx.maxPriorityFeePerGas.toString() : null,
+            from: tx.from,
+            to: tx.to,
+            transfer_events: [
+                {
+                    contract: log.address,
+                    count: amount,
+                    from,
+                    to,
+                },
+            ],
+            erc721_transfer_events: [],
+            erc1155_transfer_events: [],
+            approval_events: [],
+            actions: [],
+            confirmations: tx.confirmations,
+            input: null,
+            gas_used: receipt.gasUsed.toString(),
+            cumulative_gas_used: receipt.cumulativeGasUsed.toString(),
+            status: receipt.status,
+            received_at: new Date(block.timestamp * 1000).toISOString(),
+            block: {
+                hash: log.blockHash,
+                height: log.blockNumber,
+                time: new Date(block.timestamp * 1000).toISOString(),
+            },
+        };
+    explorerLedgerOperationByAddress[from].set(ledgerOperation.hash, ledgerOperation);
+    explorerLedgerOperationByAddress[to].set(ledgerOperation.hash, ledgerOperation);
+};
+const handleERC721Log = async (log, provider) => {
+    const [block, tx, receipt] = await Promise.all([
+        provider.getBlock(log.blockHash),
+        provider.getTransaction(log.transactionHash),
+        provider.getTransactionReceipt(log.transactionHash),
+    ]);
+    const from = (0, logic_1.safeEncodeEIP55)(ethers_1.ethers.utils.defaultAbiCoder.decode(["address"], log.topics[1])[0]);
+    const to = (0, logic_1.safeEncodeEIP55)(ethers_1.ethers.utils.defaultAbiCoder.decode(["address"], log.topics[2])[0]);
+    const tokenID = ethers_1.ethers.utils.defaultAbiCoder.decode(["uint256"], log.topics[3])[0].toString();
+    const erc721Event = {
+        blockNumber: block.number.toString(),
+        timeStamp: block.timestamp.toString(),
+        hash: tx.hash,
+        nonce: tx.nonce.toString(),
+        blockHash: block.hash,
+        from,
+        to,
+        transactionIndex: block.transactions.indexOf(log.transactionHash).toString(),
+        gas: tx.gasLimit.toString(),
+        gasPrice: tx.gasPrice?.toString() || "",
+        cumulativeGasUsed: receipt.cumulativeGasUsed.toString(),
+        gasUsed: receipt?.gasUsed?.toString() || "0",
+        input: tx.data,
+        confirmations: tx.confirmations.toString(),
+        contractAddress: tx.to,
+        tokenID,
+        tokenName: "tokenName",
+        tokenSymbol: "tokenSymbol",
+        tokenDecimal: "0",
+    };
+    if (!explorerEtherscanERC721EventsByAddress[from]) {
+        explorerEtherscanERC721EventsByAddress[from] = new Map();
+    }
+    if (!explorerEtherscanERC721EventsByAddress[to]) {
+        explorerEtherscanERC721EventsByAddress[to] = new Map();
+    }
+    explorerEtherscanERC721EventsByAddress[from].set(erc721Event.hash, erc721Event);
+    explorerEtherscanERC721EventsByAddress[to].set(erc721Event.hash, erc721Event);
+    if (!explorerLedgerOperationByAddress[from]) {
+        explorerLedgerOperationByAddress[from] = new Map();
+    }
+    if (!explorerLedgerOperationByAddress[to]) {
+        explorerLedgerOperationByAddress[to] = new Map();
+    }
+    const alreadyExistingOperation = explorerLedgerOperationByAddress[from].get(tx.hash) ||
+        explorerLedgerOperationByAddress[to].get(tx.hash);
+    const ledgerOperation = alreadyExistingOperation
+        ? {
+            ...alreadyExistingOperation,
+            erc721_transfer_events: [
+                {
+                    contract: log.address,
+                    sender: from,
+                    receiver: to,
+                    token_id: tokenID,
+                },
+            ],
+        }
+        : {
+            hash: log.transactionHash,
+            transaction_type: receipt.type,
+            nonce: "",
+            nonce_value: -1,
+            value: tx.value.toString(),
+            gas: tx.gasLimit.toString(),
+            gas_price: receipt.effectiveGasPrice.toString(),
+            max_fee_per_gas: tx.type === 2 ? tx.maxFeePerGas.toString() : null,
+            max_priority_fee_per_gas: tx.type === 2 ? tx.maxPriorityFeePerGas.toString() : null,
+            from: tx.from,
+            to: tx.to,
+            transfer_events: [],
+            erc721_transfer_events: [
+                {
+                    contract: log.address,
+                    sender: from,
+                    receiver: to,
+                    token_id: tokenID,
+                },
+            ],
+            erc1155_transfer_events: [],
+            approval_events: [],
+            actions: [],
+            confirmations: tx.confirmations,
+            input: null,
+            gas_used: receipt.gasUsed.toString(),
+            cumulative_gas_used: receipt.cumulativeGasUsed.toString(),
+            status: receipt.status,
+            received_at: new Date(block.timestamp * 1000).toISOString(),
+            block: {
+                hash: log.blockHash,
+                height: log.blockNumber,
+                time: new Date(block.timestamp * 1000).toISOString(),
+            },
+        };
+    explorerLedgerOperationByAddress[from].set(ledgerOperation.hash, ledgerOperation);
+    explorerLedgerOperationByAddress[to].set(ledgerOperation.hash, ledgerOperation);
+};
+const handleERC1155Log = async (log, provider) => {
+    const [block, tx, receipt] = await Promise.all([
+        provider.getBlock(log.blockHash),
+        provider.getTransaction(log.transactionHash),
+        provider.getTransactionReceipt(log.transactionHash),
+    ]);
+    const from = (0, logic_1.safeEncodeEIP55)(ethers_1.ethers.utils.defaultAbiCoder.decode(["address"], log.topics[2])[0]);
+    const to = (0, logic_1.safeEncodeEIP55)(ethers_1.ethers.utils.defaultAbiCoder.decode(["address"], log.topics[3])[0]);
+    const operator = (0, logic_1.safeEncodeEIP55)(ethers_1.ethers.utils.defaultAbiCoder.decode(["address"], log.topics[1])[0]);
+    const transfersMap = ethers_1.ethers.utils.defaultAbiCoder
+        .decode(["uint256", "uint256"], log.data)
+        .map((value, index) => [index === 0 ? "id" : "value", value.toString()]);
+    const etherscanERC1155Events = transfersMap.map(([id, value]) => ({
+        blockNumber: block.number.toString(),
+        timeStamp: block.timestamp.toString(),
+        hash: tx.hash,
+        nonce: tx.nonce.toString(),
+        blockHash: block.hash,
+        from,
+        to,
+        transactionIndex: block.transactions.indexOf(log.transactionHash).toString(),
+        gas: tx.gasLimit.toString(),
+        gasPrice: tx.gasPrice?.toString() || "",
+        cumulativeGasUsed: receipt.cumulativeGasUsed.toString(),
+        gasUsed: receipt?.gasUsed?.toString() || "0",
+        input: tx.data,
+        confirmations: tx.confirmations.toString(),
+        contractAddress: tx.to,
+        tokenID: id,
+        tokenValue: value,
+        tokenName: "tokenName",
+        tokenSymbol: "tokenSymbol",
+    }));
+    etherscanERC1155Events.forEach(erc1155Event => {
+        if (!explorerEtherscanERC1155EventsByAddress[from]) {
+            explorerEtherscanERC1155EventsByAddress[from] = new Map();
+        }
+        if (!explorerEtherscanERC1155EventsByAddress[to]) {
+            explorerEtherscanERC1155EventsByAddress[to] = new Map();
+        }
+        explorerEtherscanERC1155EventsByAddress[from].set(erc1155Event.hash, erc1155Event);
+        explorerEtherscanERC1155EventsByAddress[to].set(erc1155Event.hash, erc1155Event);
+    });
+    if (!explorerLedgerOperationByAddress[from]) {
+        explorerLedgerOperationByAddress[from] = new Map();
+    }
+    if (!explorerLedgerOperationByAddress[to]) {
+        explorerLedgerOperationByAddress[to] = new Map();
+    }
+    const alreadyExistingOperation = explorerLedgerOperationByAddress[from].get(tx.hash) ||
+        explorerLedgerOperationByAddress[to].get(tx.hash);
+    const ledgerOperation = alreadyExistingOperation
+        ? {
+            ...alreadyExistingOperation,
+            erc1155_transfer_events: [
+                {
+                    contract: log.address,
+                    sender: from,
+                    receiver: to,
+                    operator,
+                    transfers: [Object.fromEntries(transfersMap)],
+                },
+            ],
+        }
+        : {
+            hash: log.transactionHash,
+            transaction_type: receipt.type,
+            nonce: "",
+            nonce_value: -1,
+            value: tx.value.toString(),
+            gas: tx.gasLimit.toString(),
+            gas_price: receipt.effectiveGasPrice.toString(),
+            max_fee_per_gas: tx.type === 2 ? tx.maxFeePerGas.toString() : null,
+            max_priority_fee_per_gas: tx.type === 2 ? tx.maxPriorityFeePerGas.toString() : null,
+            from: tx.from,
+            to: tx.to,
+            transfer_events: [],
+            erc721_transfer_events: [],
+            erc1155_transfer_events: [
+                {
+                    contract: log.address,
+                    sender: from,
+                    receiver: to,
+                    operator,
+                    transfers: [Object.fromEntries(transfersMap)],
+                },
+            ],
+            approval_events: [],
+            actions: [],
+            confirmations: tx.confirmations,
+            input: null,
+            gas_used: receipt.gasUsed.toString(),
+            cumulative_gas_used: receipt.cumulativeGasUsed.toString(),
+            status: receipt.status,
+            received_at: new Date(block.timestamp * 1000).toISOString(),
+            block: {
+                hash: log.blockHash,
+                height: log.blockNumber,
+                time: new Date(block.timestamp * 1000).toISOString(),
+            },
+        };
+    explorerLedgerOperationByAddress[from].set(ledgerOperation.hash, ledgerOperation);
+    explorerLedgerOperationByAddress[to].set(ledgerOperation.hash, ledgerOperation);
+};
+const handleBlock = async (blockNumber, provider) => {
+    const block = await provider.getBlockWithTransactions(blockNumber);
+    for (const transaction of block?.transactions || []) {
+        const [tx, receipt, traces] = await Promise.all([
+            provider.getTransaction(transaction.hash),
+            provider.getTransactionReceipt(transaction.hash),
+            provider.send("trace_transaction", [transaction.hash]).catch(() => []),
+        ]);
+        const code = transaction.to ? await provider.getCode(transaction.to) : false;
+        const from = (0, logic_1.safeEncodeEIP55)(transaction.from);
+        const to = (0, logic_1.safeEncodeEIP55)(transaction.to || "");
+        const etherscanOperation = {
+            blockNumber: block.number.toString(),
+            timeStamp: block.timestamp.toString(),
+            hash: transaction.hash,
+            nonce: transaction.nonce.toString(),
+            blockHash: block.hash,
+            transactionIndex: block.transactions.indexOf(transaction).toString(),
+            from,
+            to,
+            value: transaction.value.toBigInt().toString(),
+            gas: transaction.gasLimit.toString(),
+            gasPrice: transaction.gasPrice?.toString() || "",
+            isError: receipt.status === 1 ? "0" : "1",
+            txreceipt_status: receipt.status.toString(),
+            input: transaction.data,
+            contractAddress: code === "0x" ? "" : transaction.to,
+            cumulativeGasUsed: receipt.cumulativeGasUsed.toString(),
+            gasUsed: receipt?.gasUsed?.toString() || "0",
+            confirmations: transaction.confirmations.toString(),
+            methodId: transaction.data?.length > 10 ? transaction.data.slice(0, 10) : "",
+            functionName: "",
+        };
+        if (!explorerEtherscanOperationByAddress[from]) {
+            explorerEtherscanOperationByAddress[from] = new Map();
+        }
+        if (!explorerEtherscanOperationByAddress[to]) {
+            explorerEtherscanOperationByAddress[to] = new Map();
+        }
+        explorerEtherscanOperationByAddress[from].set(etherscanOperation.hash, etherscanOperation);
+        explorerEtherscanOperationByAddress[to].set(etherscanOperation.hash, etherscanOperation);
+        if (!explorerLedgerOperationByAddress[from]) {
+            explorerLedgerOperationByAddress[from] = new Map();
+        }
+        if (!explorerLedgerOperationByAddress[to]) {
+            explorerLedgerOperationByAddress[to] = new Map();
+        }
+        const ledgerOperation = {
+            hash: receipt.transactionHash,
+            transaction_type: receipt.type,
+            nonce: "",
+            nonce_value: -1,
+            value: tx.value.toString(),
+            gas: tx.gasLimit.toString(),
+            gas_price: receipt.effectiveGasPrice.toString(),
+            max_fee_per_gas: tx.type === 2 ? tx.maxFeePerGas.toString() : null,
+            max_priority_fee_per_gas: tx.type === 2 ? tx.maxPriorityFeePerGas.toString() : null,
+            from: tx.from,
+            to: tx.to,
+            transfer_events: [],
+            erc721_transfer_events: [],
+            erc1155_transfer_events: [],
+            approval_events: [],
+            actions: [],
+            confirmations: tx.confirmations,
+            input: null,
+            gas_used: receipt.gasUsed.toString(),
+            cumulative_gas_used: receipt.cumulativeGasUsed.toString(),
+            status: receipt.status,
+            received_at: new Date(block.timestamp * 1000).toISOString(),
+            block: {
+                hash: receipt.blockHash,
+                height: receipt.blockNumber,
+                time: new Date(block.timestamp * 1000).toISOString(),
+            },
+        };
+        explorerLedgerOperationByAddress[from].set(ledgerOperation.hash, ledgerOperation);
+        explorerLedgerOperationByAddress[to].set(ledgerOperation.hash, ledgerOperation);
+        for (const { action, result, type, transactionHash, transactionPosition } of traces.filter(trace => trace.type === "call")) {
+            if (action?.callType !== "call")
+                continue;
+            const code = action.to ? await provider.getCode(action.to) : false;
+            const from = (0, logic_1.safeEncodeEIP55)(action.from || "");
+            const to = (0, logic_1.safeEncodeEIP55)(action.to || "");
+            const etherscanInternalTransaction = {
+                blockNumber: blockNumber.toString(),
+                timeStamp: block.timestamp.toString(),
+                hash: transactionHash,
+                from,
+                to,
+                value: ethers_1.ethers.BigNumber.from(action.value).toBigInt().toString(),
+                contractAddress: code === "0x" ? "" : action.to,
+                input: action.input || "0x",
+                type,
+                gas: ethers_1.ethers.BigNumber.from(action.gas).toBigInt().toString(),
+                gasUsed: ethers_1.ethers.BigNumber.from(result?.gasUsed || "0")
+                    .toBigInt()
+                    .toString(),
+                traceId: transactionPosition.toString(),
+                isError: receipt.status === 1 ? "0" : "1",
+                errCode: "",
+            };
+            if (!explorerEtherscanInternalByAddress[from]) {
+                explorerEtherscanInternalByAddress[from] = new Map();
+            }
+            if (!explorerEtherscanInternalByAddress[to]) {
+                explorerEtherscanInternalByAddress[to] = new Map();
+            }
+            explorerEtherscanInternalByAddress[from].set(etherscanInternalTransaction.hash, etherscanInternalTransaction);
+            explorerEtherscanInternalByAddress[to].set(etherscanInternalTransaction.hash, etherscanInternalTransaction);
+            if (!explorerLedgerOperationByAddress[from]) {
+                explorerLedgerOperationByAddress[from] = new Map();
+            }
+            if (!explorerLedgerOperationByAddress[to]) {
+                explorerLedgerOperationByAddress[to] = new Map();
+            }
+            const alreadyExistingOperation = explorerLedgerOperationByAddress[from].get(tx.hash) ||
+                explorerLedgerOperationByAddress[to].get(tx.hash);
+            const ledgerOperation = alreadyExistingOperation
+                ? {
+                    ...alreadyExistingOperation,
+                    actions: [
+                        ...alreadyExistingOperation.actions,
+                        {
+                            from,
+                            to,
+                            input: null,
+                            value: ethers_1.ethers.BigNumber.from(action.value).toBigInt().toString(),
+                            gas: ethers_1.ethers.BigNumber.from(action.gas).toBigInt().toString(),
+                            gas_used: ethers_1.ethers.BigNumber.from(result?.gasUsed || "0")
+                                .toBigInt()
+                                .toString(),
+                            error: null,
+                        },
+                    ],
+                }
+                : {
+                    hash: receipt.transactionHash,
+                    transaction_type: receipt.type,
+                    nonce: "",
+                    nonce_value: -1,
+                    value: tx.value.toString(),
+                    gas: tx.gasLimit.toString(),
+                    gas_price: receipt.effectiveGasPrice.toString(),
+                    max_fee_per_gas: tx.type === 2 ? tx.maxFeePerGas.toString() : null,
+                    max_priority_fee_per_gas: tx.type === 2 ? tx.maxPriorityFeePerGas.toString() : null,
+                    from: tx.from,
+                    to: tx.to,
+                    transfer_events: [],
+                    erc721_transfer_events: [],
+                    erc1155_transfer_events: [],
+                    approval_events: [],
+                    actions: [
+                        {
+                            from,
+                            to,
+                            input: null,
+                            value: ethers_1.ethers.BigNumber.from(action.value).toBigInt().toString(),
+                            gas: ethers_1.ethers.BigNumber.from(action.gas).toBigInt().toString(),
+                            gas_used: ethers_1.ethers.BigNumber.from(result?.gasUsed || "0")
+                                .toBigInt()
+                                .toString(),
+                            error: null,
+                        },
+                    ],
+                    confirmations: tx.confirmations,
+                    input: null,
+                    gas_used: receipt.gasUsed.toString(),
+                    cumulative_gas_used: receipt.cumulativeGasUsed.toString(),
+                    status: receipt.status,
+                    received_at: new Date(block.timestamp * 1000).toISOString(),
+                    block: {
+                        hash: receipt.blockHash,
+                        height: receipt.blockNumber,
+                        time: new Date(block.timestamp * 1000).toISOString(),
+                    },
+                };
+            explorerLedgerOperationByAddress[from].set(ledgerOperation.hash, ledgerOperation);
+        }
+    }
+};
+let fromBlock;
+const setBlock = (blockHeight) => {
+    fromBlock = blockHeight;
+};
+exports.setBlock = setBlock;
+const indexBlocks = async () => {
+    if (!fromBlock) {
+        throw new Error("fromBlock is not set");
+    }
+    const provider = new ethers_1.providers.StaticJsonRpcProvider(process.env.RPC);
+    let latestBlockNumber = await provider.getBlockNumber();
+    const toBlock = Math.min(fromBlock + MAX_BLOCK_RANGE, latestBlockNumber);
+    const rangeSize = toBlock - fromBlock + 1;
+    const blocks = rangeSize > 1
+        ? Array(rangeSize)
+            .fill("")
+            .map((_, index) => fromBlock + index)
+            .sort((a, b) => a - b)
+        : [latestBlockNumber];
+    const logs = await provider.getLogs({
+        fromBlock,
+        toBlock,
+        topics: [
+            [TRANSFER_EVENTS_TOPICS.ERC20, TRANSFER_EVENTS_TOPICS.ERC721, TRANSFER_EVENTS_TOPICS.ERC1155],
+        ],
+    });
+    await bluebird_1.default.map(blocks, async (blockNumber) => Promise.all([
+        handleBlock(blockNumber, provider),
+        new Promise(resolve => setTimeout(resolve, 500)),
+    ]), { concurrency: 10 });
+    await bluebird_1.default.map(logs, async (log) => Promise.all([handleLog(log, provider), new Promise(resolve => setTimeout(resolve, 500))]), { concurrency: 10 });
+    latestBlockNumber = await provider.getBlockNumber();
+    (0, exports.setBlock)(Math.min(toBlock, latestBlockNumber));
+    console.log(`Indexing completed ✓`);
+};
+exports.indexBlocks = indexBlocks;
+let server;
+const initMswHandlers = (currencyConfig) => {
+    const handlers = [];
+    if (currencyConfig.explorer.type === "ledger") {
+        handlers.push(msw_1.http.get("*.ledger.com/blockchain/v4/*/address/*/txs", async ({ request, params }) => {
+            const address = params["2"];
+            const response = await fetch((0, msw_1.bypass)(request)).then(res => res.json());
+            const opsMap = explorerLedgerOperationByAddress[address || ""] || new Map();
+            response.data.push(...opsMap.values());
+            return msw_1.HttpResponse.json(response);
+        }));
+    }
+    else if (currencyConfig.explorer.type !== "none") {
+        handlers.push(msw_1.http.get(currencyConfig.explorer.uri, async ({ request }) => {
+            const uri = new URL(request.url).searchParams;
+            const address = uri.get("address");
+            const action = uri.get("action");
+            const response = await fetch((0, msw_1.bypass)(request)).then(res => res.json());
+            switch (action) {
+                case "txlist": {
+                    const opsMap = explorerEtherscanOperationByAddress[address || ""] || new Map();
+                    response.result.push(...opsMap.values());
+                    break;
+                }
+                case "tokentx": {
+                    const erc20EventsMap = explorerEtherscanERC20EventsByAddress[address || ""] || new Map();
+                    response.result.push(...erc20EventsMap.values());
+                    break;
+                }
+                case "tokennfttx": {
+                    const erc721EventsMap = explorerEtherscanERC721EventsByAddress[address || ""] || new Map();
+                    response.result.push(...erc721EventsMap.values());
+                    break;
+                }
+                case "token1155tx": {
+                    const erc1155EventsMap = explorerEtherscanERC1155EventsByAddress[address || ""] || new Map();
+                    response.result.push(...erc1155EventsMap.values());
+                    break;
+                }
+                case "txlistinternal": {
+                    const internalMap = explorerEtherscanInternalByAddress[address || ""] || new Map();
+                    response.result.push(...internalMap.values());
+                    break;
+                }
+            }
+            return msw_1.HttpResponse.json(response);
+        }));
+    }
+    server = (0, node_1.setupServer)(...handlers);
+    server.listen({ onUnhandledRequest: "bypass" });
+};
+exports.initMswHandlers = initMswHandlers;
+//# sourceMappingURL=indexer.js.map