@lifi/sdk 2.2.2 → 3.0.0-alpha.1

package/dist/cjs/utils/multicall.js

@@ -1,68 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchDataUsingMulticall = void 0;
-const abi_1 = require("@ethersproject/abi");
-const contracts_1 = require("@ethersproject/contracts");
-const connectors_1 = require("../connectors");
-const utils_1 = require("./utils");
-const multicallAbi_json_1 = __importDefault(require("./multicallAbi.json"));
-const MAX_MULTICALL_SIZE = 100;
-const fetchDataUsingMulticall = async (calls, abi, chainId, multicallAddress, requireSuccess = false) => {
-    // 1. create contract using multicall contract address and abi...
-    const provider = await (0, connectors_1.getRpcProvider)(chainId);
-    const multicallContract = new contracts_1.Contract(multicallAddress, multicallAbi_json_1.default, provider);
-    const abiInterface = new abi_1.Interface(abi);
-    // split up lists into chunks to stay below multicall limit
-    const chunkedList = (0, utils_1.splitListIntoChunks)(calls, MAX_MULTICALL_SIZE);
-    const chunkedResults = await Promise.all(chunkedList.map(async (chunkedCalls) => {
-        const callData = chunkedCalls.map((call) => [
-            call.address.toLowerCase(),
-            abiInterface.encodeFunctionData(call.name, call.params),
-        ]);
-        try {
-            // 3. get bytes array from multicall contract by process aggregate method...
-            const { blockNumber, returnData } = await multicallContract.tryBlockAndAggregate(requireSuccess, callData);
-            // 4. decode bytes array to useful data array...
-            return returnData
-                .map(({ success, returnData }, i) => {
-                if (!success) {
-                    // requested function failed
-                    console.error(`Multicall unsuccessful for address "${chunkedCalls[i].address}", ` +
-                        `function "${chunkedCalls[i].name}", chainId "${chainId}"`);
-                    return [];
-                }
-                if (returnData.toString() === '0x') {
-                    // requested function does probably not exist
-                    console.error(`Multicall no response for address "${chunkedCalls[i].address}", ` +
-                        `function "${chunkedCalls[i].name}", chainId "${chainId}"`);
-                    return [];
-                }
-                try {
-                    return abiInterface.decodeFunctionResult(chunkedCalls[i].name, returnData);
-                }
-                catch (e) {
-                    // requested function returns other data than expected
-                    console.error(`Multicall parsing unsuccessful for address "${chunkedCalls[i].address}", ` +
-                        `function "${chunkedCalls[i].name}", chainId "${chainId}"`);
-                    return [];
-                }
-            })
-                .map((data) => {
-                return {
-                    data: data[0],
-                    blockNumber: blockNumber.toNumber(),
-                };
-            });
-        }
-        catch (e) {
-            // whole rpc call failed, probably an rpc issue
-            console.error(`Multicall failed on chainId "${chainId}"`, chunkedList, e);
-            return [];
-        }
-    }));
-    return chunkedResults.flat();
-};
-exports.fetchDataUsingMulticall = fetchDataUsingMulticall;

package/dist/cjs/utils/multicallAbi.json

@@ -1,313 +0,0 @@
-[
-    {
-        "inputs": [
-            {
-                "components": [
-                    {
-                        "internalType": "address",
-                        "name": "target",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "callData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Call[]",
-                "name": "calls",
-                "type": "tuple[]"
-            }
-        ],
-        "name": "aggregate",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "blockNumber",
-                "type": "uint256"
-            },
-            {
-                "internalType": "bytes[]",
-                "name": "returnData",
-                "type": "bytes[]"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "components": [
-                    {
-                        "internalType": "address",
-                        "name": "target",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "callData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Call[]",
-                "name": "calls",
-                "type": "tuple[]"
-            }
-        ],
-        "name": "blockAndAggregate",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "blockNumber",
-                "type": "uint256"
-            },
-            {
-                "internalType": "bytes32",
-                "name": "blockHash",
-                "type": "bytes32"
-            },
-            {
-                "components": [
-                    {
-                        "internalType": "bool",
-                        "name": "success",
-                        "type": "bool"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "returnData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Result[]",
-                "name": "returnData",
-                "type": "tuple[]"
-            }
-        ],
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "uint256",
-                "name": "blockNumber",
-                "type": "uint256"
-            }
-        ],
-        "name": "getBlockHash",
-        "outputs": [
-            {
-                "internalType": "bytes32",
-                "name": "blockHash",
-                "type": "bytes32"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getBlockNumber",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "blockNumber",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getCurrentBlockCoinbase",
-        "outputs": [
-            {
-                "internalType": "address",
-                "name": "coinbase",
-                "type": "address"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getCurrentBlockDifficulty",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "difficulty",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getCurrentBlockGasLimit",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "gaslimit",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getCurrentBlockTimestamp",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "timestamp",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "address",
-                "name": "addr",
-                "type": "address"
-            }
-        ],
-        "name": "getEthBalance",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "balance",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "getLastBlockHash",
-        "outputs": [
-            {
-                "internalType": "bytes32",
-                "name": "blockHash",
-                "type": "bytes32"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "bool",
-                "name": "requireSuccess",
-                "type": "bool"
-            },
-            {
-                "components": [
-                    {
-                        "internalType": "address",
-                        "name": "target",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "callData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Call[]",
-                "name": "calls",
-                "type": "tuple[]"
-            }
-        ],
-        "name": "tryAggregate",
-        "outputs": [
-            {
-                "components": [
-                    {
-                        "internalType": "bool",
-                        "name": "success",
-                        "type": "bool"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "returnData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Result[]",
-                "name": "returnData",
-                "type": "tuple[]"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "bool",
-                "name": "requireSuccess",
-                "type": "bool"
-            },
-            {
-                "components": [
-                    {
-                        "internalType": "address",
-                        "name": "target",
-                        "type": "address"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "callData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Call[]",
-                "name": "calls",
-                "type": "tuple[]"
-            }
-        ],
-        "name": "tryBlockAndAggregate",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "blockNumber",
-                "type": "uint256"
-            },
-            {
-                "internalType": "bytes32",
-                "name": "blockHash",
-                "type": "bytes32"
-            },
-            {
-                "components": [
-                    {
-                        "internalType": "bool",
-                        "name": "success",
-                        "type": "bool"
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "returnData",
-                        "type": "bytes"
-                    }
-                ],
-                "internalType": "struct Multicall2.Result[]",
-                "name": "returnData",
-                "type": "tuple[]"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    }
-]

package/dist/cjs/utils/preRestart.d.ts

@@ -1,3 +0,0 @@
-import { Signer } from 'ethers';
-import { Route } from '../types';
-export declare const handlePreRestart: (route: Route, signer: Signer) => Promise<void>;

package/dist/cjs/utils/preRestart.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handlePreRestart = void 0;
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-const ethers_1 = require("ethers");
-const errors_1 = require("./errors");
-const handlePreRestart = async (route, signer) => {
-    for (let index = 0; index < route.steps.length; index++) {
-        const stepHasFailed = route.steps[index].execution?.status === 'FAILED';
-        if (stepHasFailed) {
-            await handleErrorType(route, index, signer);
-            deleteFailedProcesses(route, index);
-            deleteTransactionData(route, index);
-        }
-    }
-};
-exports.handlePreRestart = handlePreRestart;
-const handleErrorType = async (route, index, signer) => {
-    const isGasLimitError = route.steps[index].execution?.process.some((p) => p.error?.code === errors_1.LifiErrorCode.GasLimitError);
-    const isGasPriceError = route.steps[index].execution?.process.some((p) => p.error?.code === errors_1.LifiErrorCode.TransactionUnderpriced);
-    const { transactionRequest } = route.steps[index];
-    if (isGasLimitError) {
-        if (transactionRequest) {
-            let gasLimit = transactionRequest.gasLimit;
-            try {
-                gasLimit = await signer.estimateGas(transactionRequest);
-            }
-            catch (error) { }
-            if (gasLimit) {
-                transactionRequest.gasLimit = ethers_1.BigNumber.from(`${(BigInt(gasLimit.toString()) * 125n) / 100n}`);
-            }
-        }
-        route.steps[index].estimate.gasCosts?.forEach((gasCost) => (gasCost.limit = `${Math.round(Number(gasCost.limit) * 1.25)}`));
-    }
-    if (isGasPriceError) {
-        if (transactionRequest) {
-            let gasPrice = transactionRequest.gasPrice;
-            try {
-                gasPrice = await signer.getGasPrice();
-            }
-            catch (error) { }
-            if (gasPrice) {
-                transactionRequest.gasPrice = ethers_1.BigNumber.from(`${(BigInt(gasPrice.toString()) * 125n) / 100n}`);
-            }
-        }
-        route.steps[index].estimate.gasCosts?.forEach((gasCost) => (gasCost.price = `${Math.round(Number(gasCost.price) * 1.25)}`));
-    }
-};
-const deleteFailedProcesses = (route, index) => {
-    if (route.steps[index].execution) {
-        route.steps[index].execution.process = route.steps[index].execution.process.filter((process) => process.status === 'DONE');
-    }
-};
-const deleteTransactionData = (route, index) => {
-    route.steps[index].transactionRequest = undefined;
-};

package/dist/types/ERC20.d.ts

@@ -1,22 +0,0 @@
-import { BaseContract, BigNumber, BigNumberish, CallOverrides, ContractTransaction, Overrides } from 'ethers';
-export declare const ERC20_ABI: {
-    name: string;
-    inputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    outputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    stateMutability: string;
-    type: string;
-}[];
-export interface ERC20Contract extends BaseContract {
-    allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
-    approve(spender: string, amount: BigNumberish, overrides?: Overrides & {
-        from?: string | Promise<string>;
-    }): Promise<ContractTransaction>;
-}

package/dist/types/ERC20.js

@@ -1,50 +0,0 @@
-export const ERC20_ABI = [
-    {
-        name: 'approve',
-        inputs: [
-            {
-                internalType: 'address',
-                name: 'spender',
-                type: 'address',
-            },
-            {
-                internalType: 'uint256',
-                name: 'amount',
-                type: 'uint256',
-            },
-        ],
-        outputs: [
-            {
-                internalType: 'bool',
-                name: '',
-                type: 'bool',
-            },
-        ],
-        stateMutability: 'nonpayable',
-        type: 'function',
-    },
-    {
-        name: 'allowance',
-        inputs: [
-            {
-                internalType: 'address',
-                name: 'owner',
-                type: 'address',
-            },
-            {
-                internalType: 'address',
-                name: 'spender',
-                type: 'address',
-            },
-        ],
-        outputs: [
-            {
-                internalType: 'uint256',
-                name: '',
-                type: 'uint256',
-            },
-        ],
-        stateMutability: 'view',
-        type: 'function',
-    },
-];

package/dist/utils/getProvider.d.ts

@@ -1,3 +0,0 @@
-import { Provider } from '@ethersproject/abstract-provider';
-import { Signer } from 'ethers';
-export declare const getProvider: (signer: Signer) => Provider;

package/dist/utils/getProvider.js

@@ -1,7 +0,0 @@
-import { LifiErrorCode, ProviderError } from './errors';
-export const getProvider = (signer) => {
-    if (!signer.provider) {
-        throw new ProviderError(LifiErrorCode.ProviderUnavailable, 'No provider available in signer.');
-    }
-    return signer.provider;
-};

package/dist/utils/multicall.d.ts

@@ -1,10 +0,0 @@
-import { Fragment, JsonFragment } from '@ethersproject/abi';
-export type MultiCallData = {
-    address: string;
-    name: string;
-    params?: any[];
-};
-export declare const fetchDataUsingMulticall: (calls: Array<MultiCallData>, abi: ReadonlyArray<Fragment | JsonFragment | string>, chainId: number, multicallAddress: string, requireSuccess?: boolean) => Promise<{
-    data: unknown;
-    blockNumber: number;
-}[]>;

package/dist/utils/multicall.js

@@ -1,61 +0,0 @@
-import { Interface } from '@ethersproject/abi';
-import { Contract } from '@ethersproject/contracts';
-import { getRpcProvider } from '../connectors';
-import { splitListIntoChunks } from './utils';
-import MULTICALL_ABI from './multicallAbi.json';
-const MAX_MULTICALL_SIZE = 100;
-export const fetchDataUsingMulticall = async (calls, abi, chainId, multicallAddress, requireSuccess = false) => {
-    // 1. create contract using multicall contract address and abi...
-    const provider = await getRpcProvider(chainId);
-    const multicallContract = new Contract(multicallAddress, MULTICALL_ABI, provider);
-    const abiInterface = new Interface(abi);
-    // split up lists into chunks to stay below multicall limit
-    const chunkedList = splitListIntoChunks(calls, MAX_MULTICALL_SIZE);
-    const chunkedResults = await Promise.all(chunkedList.map(async (chunkedCalls) => {
-        const callData = chunkedCalls.map((call) => [
-            call.address.toLowerCase(),
-            abiInterface.encodeFunctionData(call.name, call.params),
-        ]);
-        try {
-            // 3. get bytes array from multicall contract by process aggregate method...
-            const { blockNumber, returnData } = await multicallContract.tryBlockAndAggregate(requireSuccess, callData);
-            // 4. decode bytes array to useful data array...
-            return returnData
-                .map(({ success, returnData }, i) => {
-                if (!success) {
-                    // requested function failed
-                    console.error(`Multicall unsuccessful for address "${chunkedCalls[i].address}", ` +
-                        `function "${chunkedCalls[i].name}", chainId "${chainId}"`);
-                    return [];
-                }
-                if (returnData.toString() === '0x') {
-                    // requested function does probably not exist
-                    console.error(`Multicall no response for address "${chunkedCalls[i].address}", ` +
-                        `function "${chunkedCalls[i].name}", chainId "${chainId}"`);
-                    return [];
-                }
-                try {
-                    return abiInterface.decodeFunctionResult(chunkedCalls[i].name, returnData);
-                }
-                catch (e) {
-                    // requested function returns other data than expected
-                    console.error(`Multicall parsing unsuccessful for address "${chunkedCalls[i].address}", ` +
-                        `function "${chunkedCalls[i].name}", chainId "${chainId}"`);
-                    return [];
-                }
-            })
-                .map((data) => {
-                return {
-                    data: data[0],
-                    blockNumber: blockNumber.toNumber(),
-                };
-            });
-        }
-        catch (e) {
-            // whole rpc call failed, probably an rpc issue
-            console.error(`Multicall failed on chainId "${chainId}"`, chunkedList, e);
-            return [];
-        }
-    }));
-    return chunkedResults.flat();
-};