@lifi/sdk 1.1.4 → 1.2.0

package/dist/cjs/allowance/index.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revokeTokenApproval = exports.approveToken = exports.bulkGetTokenApproval = exports.getTokenApproval = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethers_1 = require("ethers");
+const helpers_1 = require("../helpers");
+const utils_1 = require("../utils/utils");
+const utils_2 = require("./utils");
+const getTokenApproval = (signer, token, approvalAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    // native token don't need approval
+    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+        return;
+    }
+    const approved = yield (0, utils_2.getApproved)(signer, token.address, approvalAddress);
+    return approved.toString();
+});
+exports.getTokenApproval = getTokenApproval;
+const bulkGetTokenApproval = (signer, tokenData) => __awaiter(void 0, void 0, void 0, function* () {
+    // filter out native tokens
+    const filteredTokenData = tokenData.filter(({ token }) => !(0, utils_1.isNativeTokenAddress)(token.address));
+    // group by chain
+    const tokenDataByChain = (0, utils_2.groupByChain)(filteredTokenData);
+    const approvalPromises = Object.keys(tokenDataByChain).map((chainId) => __awaiter(void 0, void 0, void 0, function* () {
+        const parsedChainId = Number.parseInt(chainId);
+        // get allowances for current chain and token list
+        return (0, utils_2.getAllowanceViaMulticall)(signer, parsedChainId, tokenDataByChain[parsedChainId]);
+    }));
+    const approvalsByChain = yield Promise.all(approvalPromises);
+    const approvals = approvalsByChain.flat();
+    return tokenData.map(({ token }) => {
+        // native token don't need approval
+        if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+            return { token, approval: undefined };
+        }
+        const approved = approvals.find((approval) => (0, helpers_1.isSameToken)(approval.token, token));
+        return { token, approval: approved === null || approved === void 0 ? void 0 : approved.approvedAmount.toString() };
+    });
+});
+exports.bulkGetTokenApproval = bulkGetTokenApproval;
+const approveToken = ({ signer, token, approvalAddress, amount, infiniteApproval = false, }) => __awaiter(void 0, void 0, void 0, function* () {
+    // native token don't need approval
+    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+        return;
+    }
+    const approvedAmount = yield (0, utils_2.getApproved)(signer, token.address, approvalAddress);
+    if (new bignumber_js_1.default(amount).gt(approvedAmount)) {
+        const approvalAmount = infiniteApproval
+            ? ethers_1.constants.MaxUint256.toString()
+            : amount;
+        const approveTx = yield (0, utils_2.setApproval)(signer, token.address, approvalAddress, approvalAmount);
+        yield approveTx.wait();
+    }
+});
+exports.approveToken = approveToken;
+const revokeTokenApproval = ({ signer, token, approvalAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
+    // native token don't need approval
+    if ((0, utils_1.isNativeTokenAddress)(token.address)) {
+        return;
+    }
+    const approvedAmount = yield (0, utils_2.getApproved)(signer, token.address, approvalAddress);
+    if (!approvedAmount.isZero()) {
+        const approveTx = yield (0, utils_2.setApproval)(signer, token.address, approvalAddress, '0');
+        yield approveTx.wait();
+    }
+});
+exports.revokeTokenApproval = revokeTokenApproval;

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

@@ -0,0 +1,14 @@
+import { ChainId, Token } from '@lifi/types';
+import BigNumber from 'bignumber.js';
+import { ContractTransaction, Signer } from 'ethers';
+import { RevokeTokenData } from '../types';
+export declare const getApproved: (signer: Signer, tokenAddress: string, contractAddress: string) => Promise<BigNumber>;
+export declare const setApproval: (signer: Signer, tokenAddress: string, contractAddress: string, amount: string) => Promise<ContractTransaction>;
+export declare const getAllowanceViaMulticall: (signer: Signer, chainId: ChainId, tokenData: RevokeTokenData[]) => Promise<{
+    token: Token;
+    approvalAddress: string;
+    approvedAmount: BigNumber;
+}[]>;
+export declare const groupByChain: (tokenDataList: RevokeTokenData[]) => {
+    [chainId: number]: RevokeTokenData[];
+};

package/dist/cjs/allowance/utils.js

@@ -0,0 +1,82 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupByChain = exports.getAllowanceViaMulticall = exports.setApproval = exports.getApproved = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethers_1 = require("ethers");
+const ChainsService_1 = __importDefault(require("../services/ChainsService"));
+const types_1 = require("../types");
+const errors_1 = require("../utils/errors");
+const multicall_1 = require("../utils/multicall");
+const getApproved = (signer, tokenAddress, contractAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const signerAddress = yield signer.getAddress();
+    const erc20 = new ethers_1.Contract(tokenAddress, types_1.ERC20_ABI, signer);
+    try {
+        const approved = yield erc20.allowance(signerAddress, contractAddress);
+        return new bignumber_js_1.default(approved.toString());
+    }
+    catch (e) {
+        return new bignumber_js_1.default(0);
+    }
+});
+exports.getApproved = getApproved;
+const setApproval = (signer, tokenAddress, contractAddress, amount) => {
+    const erc20 = new ethers_1.Contract(tokenAddress, types_1.ERC20_ABI, signer);
+    return erc20.approve(contractAddress, amount);
+};
+exports.setApproval = setApproval;
+const getAllowanceViaMulticall = (signer, chainId, tokenData) => __awaiter(void 0, void 0, void 0, function* () {
+    const chainsService = ChainsService_1.default.getInstance();
+    const chain = yield chainsService.getChainById(chainId);
+    if (!chain.multicallAddress) {
+        throw new errors_1.ServerError(`No multicall address configured for chainId ${chainId}.`);
+    }
+    const ownerAddress = yield signer.getAddress();
+    const calls = [];
+    tokenData.map(({ token, approvalAddress }) => {
+        calls.push({
+            address: token.address,
+            name: 'allowance',
+            params: [ownerAddress, approvalAddress],
+        });
+    });
+    const result = yield (0, multicall_1.fetchDataUsingMulticall)(calls, types_1.ERC20_ABI, chainId, chain.multicallAddress);
+    if (!result.length) {
+        throw new errors_1.ServerError(`Couldn't load allowance from chainId ${chainId} using multicall.`);
+    }
+    const parsedResult = result.map(({ data }) => {
+        var _a;
+        return ({
+            approvalAmount: (_a = data) !== null && _a !== void 0 ? _a : new bignumber_js_1.default(0),
+        });
+    });
+    return tokenData.map(({ token, approvalAddress }, i) => ({
+        token,
+        approvalAddress,
+        approvedAmount: parsedResult[i].approvalAmount,
+    }));
+});
+exports.getAllowanceViaMulticall = getAllowanceViaMulticall;
+const groupByChain = (tokenDataList) => {
+    // group by chain
+    const tokenDataByChain = {};
+    tokenDataList.forEach((tokenData) => {
+        if (!tokenDataByChain[tokenData.token.chainId]) {
+            tokenDataByChain[tokenData.token.chainId] = [];
+        }
+        tokenDataByChain[tokenData.token.chainId].push(tokenData);
+    });
+    return tokenDataByChain;
+};
+exports.groupByChain = groupByChain;

package/dist/cjs/balances/index.d.ts

@@ -0,0 +1,11 @@
+import { Token, TokenAmount } from '@lifi/types';
+declare const _default: {
+    getTokenBalance: (walletAddress: string, token: Token) => Promise<TokenAmount | null>;
+    getTokenBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
+    getTokenBalancesForChains: (walletAddress: string, tokensByChain: {
+        [chainId: number]: Token[];
+    }) => Promise<{
+        [chainId: number]: TokenAmount[];
+    }>;
+};
+export default _default;

package/dist/cjs/balances/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = __importDefault(require("./utils"));
+const getTokenBalance = (walletAddress, token) => __awaiter(void 0, void 0, void 0, function* () {
+    const tokenAmounts = yield getTokenBalances(walletAddress, [token]);
+    return tokenAmounts.length ? tokenAmounts[0] : null;
+});
+const getTokenBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+    // split by chain
+    const tokensByChain = {};
+    tokens.forEach((token) => {
+        if (!tokensByChain[token.chainId]) {
+            tokensByChain[token.chainId] = [];
+        }
+        tokensByChain[token.chainId].push(token);
+    });
+    const tokenAmountsByChain = yield getTokenBalancesForChains(walletAddress, tokensByChain);
+    return Object.values(tokenAmountsByChain).flat();
+});
+const getTokenBalancesForChains = (walletAddress, tokensByChain) => __awaiter(void 0, void 0, void 0, function* () {
+    const tokenAmountsByChain = {};
+    const promises = Object.keys(tokensByChain).map((chainIdStr) => __awaiter(void 0, void 0, void 0, function* () {
+        const chainId = parseInt(chainIdStr);
+        const tokenAmounts = yield utils_1.default.getBalances(walletAddress, tokensByChain[chainId]);
+        tokenAmountsByChain[chainId] = tokenAmounts;
+    }));
+    yield Promise.allSettled(promises);
+    return tokenAmountsByChain;
+});
+exports.default = {
+    getTokenBalance,
+    getTokenBalances,
+    getTokenBalancesForChains,
+};

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

@@ -0,0 +1,5 @@
+import { Token, TokenAmount } from '@lifi/types';
+declare const _default: {
+    getBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
+};
+export default _default;

package/dist/cjs/balances/utils.js

@@ -0,0 +1,150 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethers_1 = require("ethers");
+const connectors_1 = require("../connectors");
+const multicall_1 = require("../utils/multicall");
+const utils_1 = require("../utils/utils");
+const balanceAbi = [
+    {
+        constant: true,
+        inputs: [{ name: 'who', type: 'address' }],
+        name: 'balanceOf',
+        outputs: [{ name: '', type: 'uint256' }],
+        payable: false,
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        constant: true,
+        inputs: [{ name: 'addr', type: 'address' }],
+        name: 'getEthBalance',
+        outputs: [{ name: 'balance', type: 'uint256' }],
+        payable: false,
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
+const getBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+    if (tokens.length === 0) {
+        return [];
+    }
+    const { chainId } = tokens[0];
+    tokens.forEach((token) => {
+        if (token.chainId !== chainId) {
+            // eslint-disable-next-line no-console
+            console.warn(`Requested tokens have to be on same chain.`);
+            return [];
+        }
+    });
+    if ((yield (0, connectors_1.getMulticallAddress)(chainId)) && tokens.length > 1) {
+        return getBalancesFromProviderUsingMulticall(walletAddress, tokens);
+    }
+    else {
+        return getBalancesFromProvider(walletAddress, tokens);
+    }
+});
+const getBalancesFromProviderUsingMulticall = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+    // Configuration
+    const { chainId } = tokens[0];
+    const multicallAddress = yield (0, connectors_1.getMulticallAddress)(chainId);
+    if (!multicallAddress) {
+        throw new Error('No multicallAddress found for the given chain.');
+    }
+    return executeMulticall(walletAddress, tokens, multicallAddress, chainId);
+});
+const executeMulticall = (walletAddress, tokens, multicallAddress, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+    // Collect calls we want to make
+    const calls = [];
+    tokens.map((token) => {
+        if ((0, utils_1.isZeroAddress)(token.address)) {
+            calls.push({
+                address: multicallAddress,
+                name: 'getEthBalance',
+                params: [walletAddress],
+            });
+        }
+        else {
+            calls.push({
+                address: token.address,
+                name: 'balanceOf',
+                params: [walletAddress],
+            });
+        }
+    });
+    const res = yield fetchViaMulticall(calls, balanceAbi, chainId, multicallAddress);
+    if (!res.length) {
+        return [];
+    }
+    return tokens.map((token, i) => {
+        const amount = new bignumber_js_1.default(res[i].amount.toString() || '0')
+            .shiftedBy(-token.decimals)
+            .toFixed();
+        return Object.assign(Object.assign({}, token), { amount: amount || '0', blockNumber: res[i].blockNumber });
+    });
+});
+const fetchViaMulticall = (calls, abi, chainId, multicallAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield (0, multicall_1.fetchDataUsingMulticall)(calls, abi, chainId, multicallAddress);
+    return result.map(({ data, blockNumber }) => ({
+        amount: data ? data : new bignumber_js_1.default(0),
+        blockNumber,
+    }));
+});
+const getBalancesFromProvider = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+    const chainId = tokens[0].chainId;
+    const rpc = yield (0, connectors_1.getRpcProvider)(chainId);
+    const tokenAmountPromises = tokens.map((token) => __awaiter(void 0, void 0, void 0, function* () {
+        let amount = '0';
+        let blockNumber;
+        try {
+            const balance = yield getBalanceFromProvider(walletAddress, token.address, chainId, rpc);
+            amount = new bignumber_js_1.default(balance.amount.toString())
+                .shiftedBy(-token.decimals)
+                .toString();
+            blockNumber = balance.blockNumber;
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.warn(e);
+        }
+        return Object.assign(Object.assign({}, token), { amount,
+            blockNumber });
+    }));
+    return Promise.all(tokenAmountPromises);
+});
+const getBalanceFromProvider = (walletAddress, assetId, chainId, provider) => __awaiter(void 0, void 0, void 0, function* () {
+    const blockNumber = yield getCurrentBlockNumber(chainId);
+    let balance;
+    if ((0, utils_1.isZeroAddress)(assetId)) {
+        balance = yield provider.getBalance(walletAddress, blockNumber);
+    }
+    else {
+        const contract = new ethers_1.ethers.Contract(assetId, ['function balanceOf(address owner) view returns (uint256)'], provider);
+        balance = yield contract.balanceOf(walletAddress, {
+            blockTag: blockNumber,
+        });
+    }
+    return {
+        amount: balance,
+        blockNumber,
+    };
+});
+const getCurrentBlockNumber = (chainId) => __awaiter(void 0, void 0, void 0, function* () {
+    const rpc = yield (0, connectors_1.getRpcProvider)(chainId);
+    return rpc.getBlockNumber();
+});
+exports.default = {
+    getBalances,
+};

package/dist/cjs/connectors.d.ts

@@ -0,0 +1,6 @@
+import { ChainId } from './types';
+import { FallbackProvider } from '@ethersproject/providers';
+export declare const getRpcUrl: (chainId: ChainId, archive?: boolean) => Promise<string>;
+export declare const getRpcUrls: (chainId: ChainId, archive?: boolean) => Promise<string[]>;
+export declare const getRpcProvider: (chainId: number, archive?: boolean) => Promise<FallbackProvider>;
+export declare const getMulticallAddress: (chainId: ChainId) => Promise<string | undefined>;

package/dist/cjs/connectors.js

@@ -0,0 +1,77 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMulticallAddress = exports.getRpcProvider = exports.getRpcUrls = exports.getRpcUrl = void 0;
+const ethers_1 = require("ethers");
+const _1 = require(".");
+const types_1 = require("./types");
+const ConfigService_1 = __importDefault(require("./services/ConfigService"));
+// cached providers
+const chainProviders = {};
+// Archive RPC Provider
+const archiveRpcs = {
+    [types_1.ChainId.ETH]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/eth/mainnet/archive',
+    [types_1.ChainId.BSC]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/bsc/mainnet/archive',
+    [types_1.ChainId.POL]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/polygon/mainnet/archive',
+    [types_1.ChainId.FTM]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/fantom/mainnet',
+};
+// RPC Urls
+const getRpcUrl = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const rpcUrls = yield (0, exports.getRpcUrls)(chainId, archive);
+    return rpcUrls[0];
+});
+exports.getRpcUrl = getRpcUrl;
+const getRpcUrls = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
+    if (archive && archiveRpcs[chainId]) {
+        return [archiveRpcs[chainId]];
+    }
+    const configService = ConfigService_1.default.getInstance();
+    const config = yield configService.getConfigAsync();
+    return config.rpcs[chainId];
+});
+exports.getRpcUrls = getRpcUrls;
+const getRandomProvider = (providerList) => {
+    const index = (0, _1.getRandomNumber)(0, providerList.length - 1);
+    return providerList[index];
+};
+// Provider
+const getRpcProvider = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
+    if (archive && archiveRpcs[chainId]) {
+        // return archive PRC, but don't cache it
+        return new ethers_1.providers.FallbackProvider([
+            new ethers_1.providers.StaticJsonRpcProvider(yield (0, exports.getRpcUrl)(chainId, archive), chainId),
+        ]);
+    }
+    if (!chainProviders[chainId]) {
+        chainProviders[chainId] = [];
+        const urls = yield (0, exports.getRpcUrls)(chainId, archive);
+        urls.forEach((url) => {
+            chainProviders[chainId].push(new ethers_1.providers.FallbackProvider([
+                new ethers_1.providers.StaticJsonRpcProvider(url, chainId),
+            ]));
+        });
+    }
+    if (!chainProviders[chainId].length) {
+        throw new _1.ServerError(`Unable to configure provider for chain ${chainId}`);
+    }
+    return getRandomProvider(chainProviders[chainId]);
+});
+exports.getRpcProvider = getRpcProvider;
+// Multicall
+const getMulticallAddress = (chainId) => __awaiter(void 0, void 0, void 0, function* () {
+    const configService = ConfigService_1.default.getInstance();
+    const config = yield configService.getConfigAsync();
+    return config.multicallAddresses[chainId];
+});
+exports.getMulticallAddress = getMulticallAddress;

package/dist/cjs/execution/StatusManager.d.ts

@@ -0,0 +1,65 @@
+import { Execution, InternalExecutionSettings, Process, ProcessType, Route, Status, Step, Token } from '../types';
+interface Receipt {
+    fromAmount?: string;
+    toAmount?: string;
+    toToken?: Token;
+    gasUsed?: string;
+    gasPrice?: string;
+}
+declare type InternalUpdateRouteCallback = (route: Route) => void;
+declare type OptionalParameters = Partial<Pick<Process, 'doneAt' | 'failedAt' | 'txHash' | 'txLink' | 'error' | 'substatus' | 'substatusMessage'>>;
+/**
+ * Manages status updates of a route and provides various functions for tracking processes
+ * @param  {Route} route  The route this StatusManger belongs to.
+ * @param  {InternalExecutionSettings} settings   The ExecutionSettings for this route.
+ * @param  {InternalUpdateRouteCallback} internalUpdateRouteCallback  Internal callback to propage route changes.
+ * @return {StatusManager}       An instance of StatusManager.
+ */
+export declare class StatusManager {
+    private readonly route;
+    private readonly settings;
+    private readonly internalUpdateRouteCallback;
+    private shouldUpdate;
+    constructor(route: Route, settings: InternalExecutionSettings, internalUpdateRouteCallback: InternalUpdateRouteCallback);
+    /**
+     * Initializes the execution object of a Step.
+     * @param  {Step} step  The current step in execution
+     * @return {Execution}       The initialized execution object for this step and a function to update this step
+     */
+    initExecutionObject: (step: Step) => Execution;
+    /**
+     * Updates the execution object of a Step.
+     * @param  {Step} step  The current step in execution
+     * @param  {Status} status  The status for the execution
+     * @param  {Receipt} receipt Optional. Information about received tokens
+     * @return {Step}       The step with the updated execution object
+     */
+    updateExecution(step: Step, status: Status, receipt?: Receipt): Step;
+    /**
+     * Create and push a new process into the execution.
+     * @param  {ProcessType} type Type of the process. Used to identify already existing processes.
+     * @param  {Step} step The step that should contain the new process.
+     * @param  {Status} status By default created procces is set to the STARTED status. We can override new process with the needed status.
+     * @return {Process}
+     */
+    findOrCreateProcess: (type: ProcessType, step: Step, status?: Status) => Process;
+    /**
+     * Update a process object.
+     * @param  {Step} step The step where the process should be updated
+     * @param  {ProcessType} type  The process type to update
+     * @param  {Status} status The status the process gets.
+     * @param  {object} [params]   Additional parameters to append to the process.
+     * @return {Process} The update process
+     */
+    updateProcess: (step: Step, type: ProcessType, status: Status, params?: OptionalParameters) => Process;
+    /**
+     * Remove a process from the execution
+     * @param  {Step} step The step where the process should be removed from
+     * @param  {ProcessType} type  The process type to remove
+     * @return {void}
+     */
+    removeProcess: (step: Step, type: ProcessType) => void;
+    updateStepInRoute: (step: Step) => Step;
+    setShouldUpdate(value: boolean): void;
+}
+export {};