@lifi/sdk 1.1.2 → 1.1.5

package/dist/balances/utils.js

@@ -1,15 +1,3 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 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) {
@@ -19,43 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var bignumber_js_1 = __importDefault(require("bignumber.js"));
-var ethers_1 = require("ethers");
-var connectors_1 = require("../connectors");
-var multicall_1 = require("../utils/multicall");
-var utils_1 = require("../utils/utils");
-var balanceAbi = [
+import BigNumber from 'bignumber.js';
+import { ethers } from 'ethers';
+import { getMulticallAddress, getRpcProvider } from '../connectors';
+import { fetchDataUsingMulticall } from '../utils/multicall';
+import { isZeroAddress } from '../utils/utils';
+const balanceAbi = [
     {
         constant: true,
         inputs: [{ name: 'who', type: 'address' }],
@@ -75,181 +32,114 @@ var balanceAbi = [
         type: 'function',
     },
 ];
-var getBalances = function (walletAddress, tokens) { return __awaiter(void 0, void 0, void 0, function () {
-    var chainId;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (tokens.length === 0) {
-                    return [2 /*return*/, []];
-                }
-                chainId = tokens[0].chainId;
-                tokens.forEach(function (token) {
-                    if (token.chainId !== chainId) {
-                        // eslint-disable-next-line no-console
-                        console.warn("Requested tokens have to be on same chain.");
-                        return [];
-                    }
-                });
-                return [4 /*yield*/, (0, connectors_1.getMulticallAddress)(chainId)];
-            case 1:
-                if ((_a.sent()) && tokens.length > 1) {
-                    return [2 /*return*/, getBalancesFromProviderUsingMulticall(walletAddress, tokens)];
-                }
-                else {
-                    return [2 /*return*/, getBalancesFromProvider(walletAddress, tokens)];
-                }
-                return [2 /*return*/];
-        }
-    });
-}); };
-var getBalancesFromProviderUsingMulticall = function (walletAddress, tokens) { return __awaiter(void 0, void 0, void 0, function () {
-    var chainId, multicallAddress;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                chainId = tokens[0].chainId;
-                return [4 /*yield*/, (0, connectors_1.getMulticallAddress)(chainId)];
-            case 1:
-                multicallAddress = _a.sent();
-                if (!multicallAddress) {
-                    throw new Error('No multicallAddress found for the given chain.');
-                }
-                return [2 /*return*/, executeMulticall(walletAddress, tokens, multicallAddress, chainId)];
+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 [];
         }
     });
-}); };
-var executeMulticall = function (walletAddress, tokens, multicallAddress, chainId) { return __awaiter(void 0, void 0, void 0, function () {
-    var calls, res;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                calls = [];
-                tokens.map(function (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],
-                        });
-                    }
-                });
-                return [4 /*yield*/, fetchViaMulticall(calls, balanceAbi, chainId, multicallAddress)];
-            case 1:
-                res = _a.sent();
-                if (!res.length) {
-                    return [2 /*return*/, []];
-                }
-                return [2 /*return*/, tokens.map(function (token, i) {
-                        var amount = new bignumber_js_1.default(res[i].amount.toString() || '0')
-                            .shiftedBy(-token.decimals)
-                            .toFixed();
-                        return __assign(__assign({}, token), { amount: amount || '0', blockNumber: res[i].blockNumber });
-                    })];
+    if ((yield 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 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 (isZeroAddress(token.address)) {
+            calls.push({
+                address: multicallAddress,
+                name: 'getEthBalance',
+                params: [walletAddress],
+            });
         }
-    });
-}); };
-var fetchViaMulticall = function (calls, abi, chainId, multicallAddress) { return __awaiter(void 0, void 0, void 0, function () {
-    var result;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, (0, multicall_1.fetchDataUsingMulticall)(calls, abi, chainId, multicallAddress)];
-            case 1:
-                result = _a.sent();
-                return [2 /*return*/, result.map(function (_a) {
-                        var data = _a.data, blockNumber = _a.blockNumber;
-                        return ({
-                            amount: data ? data : new bignumber_js_1.default(0),
-                            blockNumber: blockNumber,
-                        });
-                    })];
+        else {
+            calls.push({
+                address: token.address,
+                name: 'balanceOf',
+                params: [walletAddress],
+            });
         }
     });
-}); };
-var getBalancesFromProvider = function (walletAddress, tokens) { return __awaiter(void 0, void 0, void 0, function () {
-    var chainId, rpc, tokenAmountPromises;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                chainId = tokens[0].chainId;
-                return [4 /*yield*/, (0, connectors_1.getRpcProvider)(chainId)];
-            case 1:
-                rpc = _a.sent();
-                tokenAmountPromises = tokens.map(function (token) { return __awaiter(void 0, void 0, void 0, function () {
-                    var amount, blockNumber, balance, e_1;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                amount = '0';
-                                _a.label = 1;
-                            case 1:
-                                _a.trys.push([1, 3, , 4]);
-                                return [4 /*yield*/, getBalanceFromProvider(walletAddress, token.address, chainId, rpc)];
-                            case 2:
-                                balance = _a.sent();
-                                amount = new bignumber_js_1.default(balance.amount.toString())
-                                    .shiftedBy(-token.decimals)
-                                    .toString();
-                                blockNumber = balance.blockNumber;
-                                return [3 /*break*/, 4];
-                            case 3:
-                                e_1 = _a.sent();
-                                // eslint-disable-next-line no-console
-                                console.warn(e_1);
-                                return [3 /*break*/, 4];
-                            case 4: return [2 /*return*/, __assign(__assign({}, token), { amount: amount, blockNumber: blockNumber })];
-                        }
-                    });
-                }); });
-                return [2 /*return*/, Promise.all(tokenAmountPromises)];
-        }
+    const res = yield fetchViaMulticall(calls, balanceAbi, chainId, multicallAddress);
+    if (!res.length) {
+        return [];
+    }
+    return tokens.map((token, i) => {
+        const amount = new BigNumber(res[i].amount.toString() || '0')
+            .shiftedBy(-token.decimals)
+            .toFixed();
+        return Object.assign(Object.assign({}, token), { amount: amount || '0', blockNumber: res[i].blockNumber });
     });
-}); };
-var getBalanceFromProvider = function (walletAddress, assetId, chainId, provider) { return __awaiter(void 0, void 0, void 0, function () {
-    var blockNumber, balance, contract;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, getCurrentBlockNumber(chainId)];
-            case 1:
-                blockNumber = _a.sent();
-                if (!(0, utils_1.isZeroAddress)(assetId)) return [3 /*break*/, 3];
-                return [4 /*yield*/, provider.getBalance(walletAddress, blockNumber)];
-            case 2:
-                balance = _a.sent();
-                return [3 /*break*/, 5];
-            case 3:
-                contract = new ethers_1.ethers.Contract(assetId, ['function balanceOf(address owner) view returns (uint256)'], provider);
-                return [4 /*yield*/, contract.balanceOf(walletAddress, {
-                        blockTag: blockNumber,
-                    })];
-            case 4:
-                balance = _a.sent();
-                _a.label = 5;
-            case 5: return [2 /*return*/, {
-                    amount: balance,
-                    blockNumber: blockNumber,
-                }];
+});
+const fetchViaMulticall = (calls, abi, chainId, multicallAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield fetchDataUsingMulticall(calls, abi, chainId, multicallAddress);
+    return result.map(({ data, blockNumber }) => ({
+        amount: data ? data : new BigNumber(0),
+        blockNumber,
+    }));
+});
+const getBalancesFromProvider = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+    const chainId = tokens[0].chainId;
+    const rpc = yield 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(balance.amount.toString())
+                .shiftedBy(-token.decimals)
+                .toString();
+            blockNumber = balance.blockNumber;
         }
-    });
-}); };
-var getCurrentBlockNumber = function (chainId) { return __awaiter(void 0, void 0, void 0, function () {
-    var rpc;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, (0, connectors_1.getRpcProvider)(chainId)];
-            case 1:
-                rpc = _a.sent();
-                return [2 /*return*/, rpc.getBlockNumber()];
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.warn(e);
         }
-    });
-}); };
-exports.default = {
-    getBalances: getBalances,
+        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 (isZeroAddress(assetId)) {
+        balance = yield provider.getBalance(walletAddress, blockNumber);
+    }
+    else {
+        const contract = new 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 getRpcProvider(chainId);
+    return rpc.getBlockNumber();
+});
+export default {
+    getBalances,
 };

package/dist/cjs/Lifi.d.ts

@@ -0,0 +1,200 @@
+import { FallbackProvider } from '@ethersproject/providers';
+import { Chain, ChainId, ChainKey, ContractCallQuoteRequest, GetStatusRequest, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, Route, RoutesRequest, RoutesResponse, StatusResponse, Step, Token, TokenAmount, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
+import { Signer } from 'ethers';
+import { ApproveTokenRequest, RevokeApprovalRequest } from './allowance';
+import { Config, ConfigUpdate, ExecutionSettings, RevokeTokenData } from './types';
+export default class LIFI {
+    private activeRouteDictionary;
+    private configService;
+    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 cahin
+     * @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: 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.
+     */
+    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<Step>;
+    /**
+     * 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<Step>;
+    /**
+     * 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<Chain[]>;
+    /**
+     * Get a set of routes for a request that describes a transfer of tokens.
+     * @param {RoutesRequest} routesRequest - 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 {Step} step - The step object.
+     * @return {Promise<Step>} The step populated with the transaction data.
+     * @throws {LifiError} Throws a LifiError if request fails.
+     */
+    getStepTransaction: (step: Step, options?: RequestOptions) => Promise<Step>;
+    /**
+     * Stops the execution of an active route.
+     * @param {Route} route - A route that is currently in execution.
+     * @return {Route} The stopped route.
+     */
+    stopExecution: (route: Route) => Route;
+    /**
+     * Executes a route until a user interaction is necessary (signing transactions, etc.) and then halts until the route is resumed.
+     * @param {Route} route - A route that is currently in execution.
+     */
+    moveExecutionToBackground: (route: Route) => void;
+    /**
+     * Execute a route.
+     * @param {Signer} signer - The signer required to send the transactions.
+     * @param {Route} route - The route that should be executed. Cannot be an active route.
+     * @param {ExecutionSettings} settings - An object containing settings and callbacks.
+     * @return {Promise<Route>} The executed route.
+     * @throws {LifiError} Throws a LifiError if the execution fails.
+     */
+    executeRoute: (signer: Signer, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    /**
+     * Resume the execution of a route that has been stopped or had an error while executing.
+     * @param {Signer} signer - The signer required to send the transactions.
+     * @param {Route} route - The route that is to be executed. Cannot be an active route.
+     * @param {ExecutionSettings} settings - An object containing settings and callbacks.
+     * @return {Promise<Route>} The executed route.
+     * @throws {LifiError} Throws a LifiError if the execution fails.
+     */
+    resumeRoute: (signer: Signer, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    private executeSteps;
+    /**
+     * Update the ExecutionSettings for an active route.
+     * @param {ExecutionSettings} settings - An object with execution settings.
+     * @param {Route} route - The active route that gets the new execution settings.
+     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
+     */
+    updateExecutionSettings: (settings: ExecutionSettings, route: Route) => void;
+    /**
+     * Get the list of active routes.
+     * @return {Route[]} A list of routes.
+     */
+    getActiveRoutes: () => Route[];
+    /**
+     * Return the current route information for given route. The route has to be active.
+     * @param {Route} route - A route object.
+     * @return {Route} The updated route.
+     */
+    getActiveRoute: (route: Route) => Route | undefined;
+    /**
+     * 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>;
+}