@lifi/sdk 2.3.1 → 3.0.0-alpha.10

package/package.json

@@ -1,110 +1,52 @@
 {
   "name": "@lifi/sdk",
-  "version": "2.3.1",
   "description": "LI.FI Any-to-Any Cross-Chain-Swap SDK",
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "scripts": {
-    "watch": "tsc -w -p ./tsconfig.json",
-    "build": "yarn clean && tsc --project ./tsconfig.json && tsc --project ./tsconfig.cjs.json",
-    "clean": "node tools/cleanup",
-    "package": "npm run build && npm pack",
-    "test": "vitest --run --dangerouslyIgnoreUnhandledErrors",
-    "test:unit": "yarn test .unit.spec.ts",
-    "test:cov": "yarn test --coverage",
-    "test:e2e": "yarn test -c vitest.e2e.config.ts",
-    "addscope": "node tools/packagejson name @lifi/sdk",
-    "pre-commit": "lint-staged",
-    "pre-push": "yarn types:check && yarn build && yarn test:unit",
-    "lint": "eslint --ext .tsx --ext .ts ./src",
-    "lint:fix": "eslint --ext .tsx --ext .ts ./src --fix",
-    "types:check": "tsc --noEmit",
-    "prettier:fix": "prettier --write ./src/.",
-    "use:npmReadme": "mv 'README.md' 'git.README.md' && mv 'npm.README.md' 'README.md'",
-    "use:gitReadme": "mv 'README.md' 'npm.README.md' && mv 'git.README.md' 'README.md'",
-    "prepublishOnly": "run-s build use:npmReadme && pinst --enable",
-    "postpublish": "npm run use:gitReadme && pinst --enable",
-    "prepare": "husky install",
-    "release": "standard-version -a",
-    "release:beta": "standard-version -a --prerelease beta --skip.changelog"
-  },
-  "standard-version": {
-    "scripts": {
-      "postbump": "node scripts/version.js && git add ."
-    }
-  },
-  "lint-staged": {
-    "src/**/*.{ts,tsx}": [
-      "yarn run lint:fix",
-      "yarn run prettier:fix"
-    ]
+  "dependencies": {
+    "@lifi/types": "^9.0.0-alpha.15",
+    "@solana/web3.js": "^1.78.4",
+    "eth-rpc-errors": "^4.0.3",
+    "viem": "^1.10.4"
   },
+  "version": "3.0.0-alpha.10",
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.tsbuildinfo"
   ],
-  "publishConfig": {
-    "access": "public"
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
   },
-  "author": "Max Klenk <max@li.finance>",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "typings": "./dist/types/index.d.ts",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/lifinance/sdk.git"
+  },
   "keywords": [
-    "sdk",
-    "ethereum",
-    "dapp",
     "bridge",
-    "swap",
-    "web3",
-    "lifi",
-    "ethers",
+    "bridge-aggregation",
     "cross-chain",
-    "defi",
-    "web3-react",
     "cross-chain-applications",
     "cross-chain-bridge",
-    "bridge-aggregation",
+    "dapp",
+    "defi",
+    "ethereum",
+    "ethers",
+    "lifi",
+    "metamask",
     "multi-chain",
-    "metamask"
-  ],
-  "homepage": "https://github.com/lifinance/sdk",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/lifinance/sdk.git"
-  },
-  "bugs": {
-    "url": "https://github.com/lifinance/sdk/issues"
-  },
-  "dependencies": {
-    "@ethersproject/abi": "^5.7.0",
-    "@ethersproject/contracts": "^5.7.0",
-    "@lifi/types": "^8.4.0",
-    "bignumber.js": "^9.1.1",
-    "eth-rpc-errors": "^4.0.3",
-    "ethers": "^5.7.2"
-  },
-  "devDependencies": {
-    "@commitlint/cli": "^17.6.7",
-    "@commitlint/config-conventional": "^17.6.7",
-    "@mswjs/interceptors": "^0.22.16",
-    "@typescript-eslint/eslint-plugin": "^6.1.0",
-    "@typescript-eslint/parser": "^6.1.0",
-    "@vitest/coverage-c8": "^0.33.0",
-    "cross-fetch": "^4.0.0",
-    "eslint": "^8.45.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-prettier": "^5.0.0",
-    "husky": "^8.0.3",
-    "lint-staged": "^13.2.3",
-    "msw": "1.0.1",
-    "npm-run-all": "^4.1.5",
-    "pinst": "^3.0.0",
-    "prettier": "^3.0.0",
-    "standard-version": "^9.5.0",
-    "typescript": "^5.1.6",
-    "vitest": "^0.33.0"
-  },
-  "directories": {
-    "test": "test"
-  },
-  "packageManager": "yarn@3.6.1"
+    "sdk",
+    "swap",
+    "viem",
+    "wagmi",
+    "web3",
+    "web3-react"
+  ]
 }

package/dist/LiFi.d.ts

@@ -1,164 +0,0 @@
-import { FallbackProvider } from '@ethersproject/providers';
-import { ChainId, ChainKey, ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, ExtendedChain, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, RoutesRequest, RoutesResponse, StatusResponse, Token, TokenAmount, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
-import { Signer } from 'ethers';
-import { ApproveTokenRequest, RevokeApprovalRequest } from './allowance';
-import { RouteExecutionManager } from './execution/RouteExecutionManager';
-import { Config, ConfigUpdate, RevokeTokenData } from './types';
-export declare class LiFi extends RouteExecutionManager {
-    private chainsService;
-    constructor(configUpdate: ConfigUpdate);
-    /**
-     * Get the current configuration of the SDK
-     * @return {Config} - The config object
-     */
-    getConfig: () => Config;
-    /**
-     * Get the SDK configuration after all setup calls are finished
-     * @return {Promise<Config>} - The config object
-     */
-    getConfigAsync: () => Promise<Config>;
-    /**
-     * Get an instance of a provider for a specific chain
-     * @param {number} chainId - Id of the chain the provider is for
-     * @param {boolean} archive - Whether to use an archive provider that is based on a default rpc or not. defaults to false
-     * @return {FallbackProvider} The provider for the given chain
-     */
-    getRpcProvider: (chainId: number, archive?: boolean) => Promise<FallbackProvider>;
-    /**
-     * Set a new confuration for the SDK
-     * @param {ConfigUpdate} configUpdate - An object containing the configuration fields that should be updated.
-     * @return {Config} The renewed config object
-     */
-    setConfig: (configUpdate: Partial<ConfigUpdate>) => Config;
-    /**
-     * Get a set of current possibilities based on a request that specifies which chains, exchanges and bridges are preferred or unwanted.
-     * @param {PossibilitiesRequest} request - Object defining preferences regarding chain, exchanges and bridges
-     * @return {Promise<PossibilitiesResponse>} Object listing current possibilities for any-to-any cross-chain-swaps based on the provided preferences.
-     * @throws {LifiError} Throws a LifiError if request fails.
-     * @deprecated We don't want to support this endpoint anymore in the future. /chains, /tools, /connections, and /tokens should be used instead
-     */
-    getPossibilities: (request?: PossibilitiesRequest, options?: RequestOptions) => Promise<PossibilitiesResponse>;
-    /**
-     * Fetch information about a Token
-     * @param {ChainKey | ChainId} chain - Id or key of the chain that contains the token
-     * @param {string} token - Address or symbol of the token on the requested chain
-     * @throws {LifiError} - Throws a LifiError if request fails
-     */
-    getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions) => Promise<Token>;
-    /**
-     * Get a quote for a token transfer
-     * @param {QuoteRequest} request - The configuration of the requested quote
-     * @throws {LifiError} - Throws a LifiError if request fails
-     */
-    getQuote: (request: QuoteRequest, options?: RequestOptions) => Promise<LifiStep>;
-    /**
-     * Get a quote for a destination contract call
-     * @param {ContractCallQuoteRequest} request - The configuration of the requested destination call
-     * @throws {LifiError} - Throws a LifiError if request fails
-     */
-    getContractCallQuote: (request: ContractCallQuoteRequest, options?: RequestOptions) => Promise<LifiStep>;
-    /**
-     * Check the status of a transfer. For cross chain transfers, the "bridge" parameter is required.
-     * @param {GetStatusRequest} request - Configuration of the requested status
-     * @throws {LifiError} - Throws a LifiError if request fails
-     */
-    getStatus: (request: GetStatusRequest, options?: RequestOptions) => Promise<StatusResponse>;
-    /**
-     * Get the available tools to bridge and swap tokens.
-     * @param {ToolsRequest?} request - The configuration of the requested tools
-     * @returns The tools that are available on the requested chains
-     */
-    getTools: (request?: ToolsRequest, options?: RequestOptions) => Promise<ToolsResponse>;
-    /**
-     * Get all known tokens.
-     * @param {TokensRequest?} request - The configuration of the requested tokens
-     * @returns The tokens that are available on the requested chains
-     */
-    getTokens: (request?: TokensRequest, options?: RequestOptions) => Promise<TokensResponse>;
-    /**
-     * Get all available chains
-     * @return {Promise<Chain[]>} A list of all available chains
-     * @throws {LifiError} Throws a LifiError if request fails.
-     */
-    getChains: () => Promise<ExtendedChain[]>;
-    /**
-     * Get a set of routes for a request that describes a transfer of tokens.
-     * @param {RoutesRequest} request - A description of the transfer.
-     * @return {Promise<RoutesResponse>} The resulting routes that can be used to realize the described transfer of tokens.
-     * @throws {LifiError} Throws a LifiError if request fails.
-     */
-    getRoutes: (request: RoutesRequest, options?: RequestOptions) => Promise<RoutesResponse>;
-    /**
-     * Get the transaction data for a single step of a route
-     * @param {LifiStep} step - The step object.
-     * @return {Promise<LifiStep>} The step populated with the transaction data.
-     * @throws {LifiError} Throws a LifiError if request fails.
-     */
-    getStepTransaction: (step: LifiStep, options?: RequestOptions) => Promise<LifiStep>;
-    /**
-     * Get gas recommendation for a certain chain
-     * @param {GasRecommendationRequest} request - Configuration of the requested recommendation.
-     * @throws {LifiError} Throws a LifiError if request fails.
-     */
-    getGasRecommendation: (request: GasRecommendationRequest, options?: RequestOptions) => Promise<GasRecommendationResponse>;
-    /**
-     * Returns the balances of a specific token a wallet holds across all aggregated chains.
-     * @param {string} walletAddress - A wallet address.
-     * @param {Token} token - A Token object.
-     * @return {Promise<TokenAmount | null>} An object containing the token and the amounts on different chains.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    getTokenBalance: (walletAddress: string, token: Token) => Promise<TokenAmount | null>;
-    /**
-     * Returns the balances for a list tokens a wallet holds  across all aggregated chains.
-     * @param {string} walletAddress - A wallet address.
-     * @param {Token[]} tokens - A list of Token objects.
-     * @return {Promise<TokenAmount[]>} A list of objects containing the tokens and the amounts on different chains.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    getTokenBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
-    /**
-     * This method queries the balances of tokens for a specific list of chains for a given wallet.
-     * @param {string} walletAddress - A walletaddress.
-     * @param {{ [chainId: number]: Token[] }} tokensByChain - A list of Token objects organized by chain ids.
-     * @return {Promise<{ [chainId: number]: TokenAmount[] }>} A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    getTokenBalancesForChains: (walletAddress: string, tokensByChain: {
-        [chainId: number]: Token[];
-    }) => Promise<{
-        [chainId: number]: TokenAmount[];
-    }>;
-    /**
-     * Get the current approval for a certain token.
-     * @param signer - The signer owning the token
-     * @param token - The token that should be checked
-     * @param approvalAddress - The address that has be approved
-     */
-    getTokenApproval: (signer: Signer, token: Token, approvalAddress: string) => Promise<string | undefined>;
-    /**
-     * Get the current approval for a list of token / approval address pairs.
-     * @param signer - The signer owning the tokens
-     * @param tokenData - A list of token and approval address pairs
-     */
-    bulkGetTokenApproval: (signer: Signer, tokenData: RevokeTokenData[]) => Promise<{
-        token: Token;
-        approval: string | undefined;
-    }[]>;
-    /**
-     * Set approval for a certain token and amount.
-     * @param { ApproveTokenRequest } request - The approval request
-     */
-    approveToken: (request: ApproveTokenRequest) => Promise<void>;
-    /**
-     * Revoke approval for a certain token.
-     * @param { RevokeApprovalRequest } request - The revoke request
-     */
-    revokeTokenApproval: (request: RevokeApprovalRequest) => Promise<void>;
-    /**
-     * Get all the available connections for swap/bridging tokens
-     * @param connectionRequest ConnectionsRequest
-     * @returns ConnectionsResponse
-     */
-    getConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;
-}

package/dist/LiFi.js

@@ -1,235 +0,0 @@
-import { approveToken, bulkGetTokenApproval, getTokenApproval, revokeTokenApproval, } from './allowance';
-import * as balance from './balance';
-import { getRpcProvider } from './connectors';
-import { RouteExecutionManager } from './execution/RouteExecutionManager';
-import { checkPackageUpdates } from './helpers';
-import ApiService from './services/ApiService';
-import ChainsService from './services/ChainsService';
-import { isToken } from './typeguards';
-import { ValidationError } from './utils/errors';
-import { name, version } from './version';
-export class LiFi extends RouteExecutionManager {
-    constructor(configUpdate) {
-        super(configUpdate);
-        /**
-         * Get the current configuration of the SDK
-         * @return {Config} - The config object
-         */
-        this.getConfig = () => {
-            return this.configService.getConfig();
-        };
-        /**
-         * Get the SDK configuration after all setup calls are finished
-         * @return {Promise<Config>} - The config object
-         */
-        this.getConfigAsync = () => {
-            return this.configService.getConfigAsync();
-        };
-        /**
-         * Get an instance of a provider for a specific chain
-         * @param {number} chainId - Id of the chain the provider is for
-         * @param {boolean} archive - Whether to use an archive provider that is based on a default rpc or not. defaults to false
-         * @return {FallbackProvider} The provider for the given chain
-         */
-        this.getRpcProvider = (chainId, archive = false) => {
-            return getRpcProvider(chainId, archive);
-        };
-        /**
-         * Set a new confuration for the SDK
-         * @param {ConfigUpdate} configUpdate - An object containing the configuration fields that should be updated.
-         * @return {Config} The renewed config object
-         */
-        this.setConfig = (configUpdate) => {
-            return this.configService.updateConfig(configUpdate);
-        };
-        /**
-         * Get a set of current possibilities based on a request that specifies which chains, exchanges and bridges are preferred or unwanted.
-         * @param {PossibilitiesRequest} request - Object defining preferences regarding chain, exchanges and bridges
-         * @return {Promise<PossibilitiesResponse>} Object listing current possibilities for any-to-any cross-chain-swaps based on the provided preferences.
-         * @throws {LifiError} Throws a LifiError if request fails.
-         * @deprecated We don't want to support this endpoint anymore in the future. /chains, /tools, /connections, and /tokens should be used instead
-         */
-        this.getPossibilities = async (request, options) => {
-            return ApiService.getPossibilities(request, options);
-        };
-        /**
-         * Fetch information about a Token
-         * @param {ChainKey | ChainId} chain - Id or key of the chain that contains the token
-         * @param {string} token - Address or symbol of the token on the requested chain
-         * @throws {LifiError} - Throws a LifiError if request fails
-         */
-        this.getToken = async (chain, token, options) => {
-            return ApiService.getToken(chain, token, options);
-        };
-        /**
-         * Get a quote for a token transfer
-         * @param {QuoteRequest} request - The configuration of the requested quote
-         * @throws {LifiError} - Throws a LifiError if request fails
-         */
-        this.getQuote = async (request, options) => {
-            return ApiService.getQuote(request, options);
-        };
-        /**
-         * Get a quote for a destination contract call
-         * @param {ContractCallQuoteRequest} request - The configuration of the requested destination call
-         * @throws {LifiError} - Throws a LifiError if request fails
-         */
-        this.getContractCallQuote = async (request, options) => {
-            return ApiService.getContractCallQuote(request, options);
-        };
-        /**
-         * Check the status of a transfer. For cross chain transfers, the "bridge" parameter is required.
-         * @param {GetStatusRequest} request - Configuration of the requested status
-         * @throws {LifiError} - Throws a LifiError if request fails
-         */
-        this.getStatus = async (request, options) => {
-            return ApiService.getStatus(request, options);
-        };
-        /**
-         * Get the available tools to bridge and swap tokens.
-         * @param {ToolsRequest?} request - The configuration of the requested tools
-         * @returns The tools that are available on the requested chains
-         */
-        this.getTools = async (request, options) => {
-            return ApiService.getTools(request || {}, options);
-        };
-        /**
-         * Get all known tokens.
-         * @param {TokensRequest?} request - The configuration of the requested tokens
-         * @returns The tokens that are available on the requested chains
-         */
-        this.getTokens = async (request, options) => {
-            return ApiService.getTokens(request || {}, options);
-        };
-        /**
-         * Get all available chains
-         * @return {Promise<Chain[]>} A list of all available chains
-         * @throws {LifiError} Throws a LifiError if request fails.
-         */
-        this.getChains = async () => {
-            return this.chainsService.getChains();
-        };
-        /**
-         * Get a set of routes for a request that describes a transfer of tokens.
-         * @param {RoutesRequest} request - A description of the transfer.
-         * @return {Promise<RoutesResponse>} The resulting routes that can be used to realize the described transfer of tokens.
-         * @throws {LifiError} Throws a LifiError if request fails.
-         */
-        this.getRoutes = async (request, options) => {
-            return ApiService.getRoutes(request, options);
-        };
-        /**
-         * Get the transaction data for a single step of a route
-         * @param {LifiStep} step - The step object.
-         * @return {Promise<LifiStep>} The step populated with the transaction data.
-         * @throws {LifiError} Throws a LifiError if request fails.
-         */
-        this.getStepTransaction = async (step, options) => {
-            return ApiService.getStepTransaction(step, options);
-        };
-        /**
-         * Get gas recommendation for a certain chain
-         * @param {GasRecommendationRequest} request - Configuration of the requested recommendation.
-         * @throws {LifiError} Throws a LifiError if request fails.
-         */
-        this.getGasRecommendation = async (request, options) => {
-            return ApiService.getGasRecommendation(request, options);
-        };
-        /**
-         * Returns the balances of a specific token a wallet holds across all aggregated chains.
-         * @param {string} walletAddress - A wallet address.
-         * @param {Token} token - A Token object.
-         * @return {Promise<TokenAmount | null>} An object containing the token and the amounts on different chains.
-         * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-         */
-        this.getTokenBalance = async (walletAddress, token) => {
-            if (!walletAddress) {
-                throw new ValidationError('Missing walletAddress.');
-            }
-            if (!isToken(token)) {
-                throw new ValidationError(`Invalid token passed: address "${token.address}" on chainId "${token.chainId}"`);
-            }
-            return balance.getTokenBalance(walletAddress, token);
-        };
-        /**
-         * Returns the balances for a list tokens a wallet holds  across all aggregated chains.
-         * @param {string} walletAddress - A wallet address.
-         * @param {Token[]} tokens - A list of Token objects.
-         * @return {Promise<TokenAmount[]>} A list of objects containing the tokens and the amounts on different chains.
-         * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-         */
-        this.getTokenBalances = async (walletAddress, tokens) => {
-            if (!walletAddress) {
-                throw new ValidationError('Missing walletAddress.');
-            }
-            const invalidTokens = tokens.filter((token) => !isToken(token));
-            if (invalidTokens.length) {
-                throw new ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
-            }
-            return balance.getTokenBalances(walletAddress, tokens);
-        };
-        /**
-         * This method queries the balances of tokens for a specific list of chains for a given wallet.
-         * @param {string} walletAddress - A walletaddress.
-         * @param {{ [chainId: number]: Token[] }} tokensByChain - A list of Token objects organized by chain ids.
-         * @return {Promise<{ [chainId: number]: TokenAmount[] }>} A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
-         * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-         */
-        this.getTokenBalancesForChains = async (walletAddress, tokensByChain) => {
-            if (!walletAddress) {
-                throw new ValidationError('Missing walletAddress.');
-            }
-            const tokenList = Object.values(tokensByChain).flat();
-            const invalidTokens = tokenList.filter((token) => !isToken(token));
-            if (invalidTokens.length) {
-                throw new ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
-            }
-            return balance.getTokenBalancesForChains(walletAddress, tokensByChain);
-        };
-        /**
-         * Get the current approval for a certain token.
-         * @param signer - The signer owning the token
-         * @param token - The token that should be checked
-         * @param approvalAddress - The address that has be approved
-         */
-        this.getTokenApproval = async (signer, token, approvalAddress) => {
-            return getTokenApproval(signer, token, approvalAddress);
-        };
-        /**
-         * Get the current approval for a list of token / approval address pairs.
-         * @param signer - The signer owning the tokens
-         * @param tokenData - A list of token and approval address pairs
-         */
-        this.bulkGetTokenApproval = async (signer, tokenData) => {
-            return bulkGetTokenApproval(signer, tokenData);
-        };
-        /**
-         * Set approval for a certain token and amount.
-         * @param { ApproveTokenRequest } request - The approval request
-         */
-        this.approveToken = (request) => {
-            return approveToken(request);
-        };
-        /**
-         * Revoke approval for a certain token.
-         * @param { RevokeApprovalRequest } request - The revoke request
-         */
-        this.revokeTokenApproval = (request) => {
-            return revokeTokenApproval(request);
-        };
-        /**
-         * Get all the available connections for swap/bridging tokens
-         * @param connectionRequest ConnectionsRequest
-         * @returns ConnectionsResponse
-         */
-        this.getConnections = async (connectionRequest) => {
-            const connections = await ApiService.getAvailableConnections(connectionRequest);
-            return connections;
-        };
-        this.chainsService = ChainsService.getInstance();
-        this.chainsService.getChains().then((chains) => {
-            this.configService.updateChains(chains);
-        });
-        checkPackageUpdates(name, version, configUpdate.disableVersionCheck);
-    }
-}

package/dist/allowance/checkAllowance.d.ts

@@ -1,4 +0,0 @@
-import { PopulatedTransaction, Signer } from 'ethers';
-import { StatusManager } from '../execution/StatusManager';
-import { Chain, InternalExecutionSettings, LifiStep } from '../types';
-export declare const checkAllowance: (signer: Signer, step: LifiStep, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean, shouldBatchTransactions?: boolean) => Promise<void | PopulatedTransaction>;

package/dist/allowance/checkAllowance.js

@@ -1,96 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { constants, } from 'ethers';
-import { getApproved, setApproval } from '../allowance/utils';
-import { getProvider } from '../utils/getProvider';
-import { parseError } from '../utils/parseError';
-export const checkAllowance = async (signer, step, statusManager, settings, chain, allowUserInteraction = false, shouldBatchTransactions = false) => {
-    // Ask the user to set an allowance
-    let allowanceProcess = statusManager.findOrCreateProcess(step, 'TOKEN_ALLOWANCE');
-    // Check allowance
-    try {
-        if (allowanceProcess.txHash && allowanceProcess.status !== 'DONE') {
-            if (allowanceProcess.status !== 'PENDING') {
-                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING');
-            }
-            await getProvider(signer).waitForTransaction(allowanceProcess.txHash);
-            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-        }
-        else {
-            const approvalRequest = {
-                from: step.action.fromToken.address,
-                to: step.estimate.approvalAddress,
-            };
-            if (settings.updateTransactionRequestHook) {
-                const config = await settings.updateTransactionRequestHook(approvalRequest);
-                approvalRequest.gasLimit = config.gasLimit;
-                approvalRequest.gasPrice = config.gasPrice;
-                approvalRequest.maxFeePerGas = config.maxFeePerGas;
-                approvalRequest.maxPriorityFeePerGas = config.maxPriorityFeePerGas;
-            }
-            if (!approvalRequest.from) {
-                throw new Error('Missing Signer address');
-            }
-            if (!approvalRequest.to) {
-                throw new Error('Missing ERC20 contract address');
-            }
-            const approved = await getApproved(signer, approvalRequest.from, approvalRequest.to);
-            if (new BigNumber(step.action.fromAmount).gt(approved)) {
-                if (!allowUserInteraction) {
-                    return;
-                }
-                const approvalAmount = settings.infiniteApproval
-                    ? constants.MaxUint256.toString()
-                    : step.action.fromAmount;
-                if (shouldBatchTransactions) {
-                    const populatedTransaction = await setApproval(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount, true);
-                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-                    return populatedTransaction;
-                }
-                const approveTx = (await setApproval(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount));
-                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
-                    txHash: approveTx.hash,
-                    txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + approveTx.hash,
-                });
-                // Wait for the transcation
-                await approveTx.wait();
-                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-            }
-            else {
-                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-            }
-        }
-    }
-    catch (e) {
-        if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-            await transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
-        }
-        else {
-            const error = await parseError(e, step, allowanceProcess);
-            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
-                error: {
-                    message: error.message,
-                    htmlMessage: error.htmlMessage,
-                    code: error.code,
-                },
-            });
-            statusManager.updateExecution(step, 'FAILED');
-            throw error;
-        }
-    }
-};
-const transactionReplaced = async (replacementTx, allowanceProcess, step, chain, statusManager) => {
-    try {
-        allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
-            txHash: replacementTx.hash,
-            txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + replacementTx.hash,
-        });
-        await replacementTx.wait();
-        allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-    }
-    catch (e) {
-        if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-            await transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
-        }
-        throw e;
-    }
-};

package/dist/allowance/index.d.ts

@@ -1,2 +0,0 @@
-export * from './checkAllowance';
-export * from './tokenApproval';

package/dist/allowance/index.js

@@ -1,2 +0,0 @@
-export * from './checkAllowance';
-export * from './tokenApproval';