dequanto 0.0.1

package/dist/src/tokens/TokenProviders/ITokenProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/tokens/TokenProviders/TPChain.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPChain = void 0;
+class TPChain {
+    constructor(platform, explorer) {
+        this.platform = platform;
+        this.explorer = explorer;
+    }
+    async getByAddress(platform, address) {
+        if (this.platform !== platform) {
+            return null;
+        }
+        try {
+            let source = await this.explorer?.getContractSource(address);
+            return {
+                address: address,
+                symbol: source
+                    .ContractName
+                    ?.replace(/bep20/i, ''),
+            };
+        }
+        catch (error) {
+            // just ignore if not resolved
+            return null;
+        }
+    }
+    getBySymbol(platform, symbol) {
+        // Does not support by name
+        return null;
+    }
+    async redownloadTokens() {
+        return [];
+    }
+}
+exports.TPChain = TPChain;

package/dist/src/tokens/TokenProviders/TPCoinmarketcap.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPCoinmarketcap = void 0;
+const axios_1 = __importDefault(require("axios"));
+const atma_utils_1 = require("atma-utils");
+const JsonArrayStore_1 = require("@dequanto/json/JsonArrayStore");
+const _config_1 = require("@dequanto/utils/$config");
+const ATokenProvider_1 = require("./ATokenProvider");
+const coinmarketcap = _config_1.$config.get('coinmarketcap');
+const tokensStore = new JsonArrayStore_1.JsonArrayStore({
+    path: atma_utils_1.class_Uri.combine(coinmarketcap?.cache ?? './data/tokens/coinmarketcap/', 'tokens.json'),
+    key: (x) => x.symbol
+});
+const HOST = `https://pro-api.coinmarketcap.com/`;
+class TPCoinmarketcap extends ATokenProvider_1.ATokenProvider {
+    getTokens() {
+        return tokensStore.getAll();
+    }
+    async redownloadTokens() {
+        if (coinmarketcap == null) {
+            console.warn(`No ApiKey for coinmarketcap found. Skipping this token provider`);
+            return [];
+        }
+        let url = atma_utils_1.class_Uri.combine(HOST, `/v1/cryptocurrency/map?CMC_PRO_API_KEY=${coinmarketcap.key}`);
+        let resp = await axios_1.default.get(url);
+        let tokens = resp.data.data;
+        let arr = tokens.map(token => {
+            if (token.platform == null) {
+                return null;
+            }
+            let platform;
+            switch (token.platform.name) {
+                case "Binance Smart Chain":
+                    platform = "bsc";
+                    break;
+                case "Ethereum":
+                    platform = "eth";
+                    break;
+                case "Polygon":
+                    platform = "polygon";
+                    break;
+                case "xDai":
+                    platform = "xdai";
+                    break;
+                default:
+                    return null;
+            }
+            return {
+                symbol: token.symbol,
+                name: token.name,
+                platforms: [{
+                        platform,
+                        address: token.platform.token_address
+                    }]
+            };
+        }).filter(Boolean);
+        await tokensStore.saveAll(arr);
+    }
+}
+exports.TPCoinmarketcap = TPCoinmarketcap;

package/dist/src/tokens/TokenProviders/TPOneInch.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPOneInch = void 0;
+const axios_1 = __importDefault(require("axios"));
+const JsonArrayStore_1 = require("@dequanto/json/JsonArrayStore");
+const TokenUtils_1 = require("../utils/TokenUtils");
+const ATokenProvider_1 = require("./ATokenProvider");
+const _path_1 = require("@dequanto/utils/$path");
+class TPOneInch extends ATokenProvider_1.ATokenProvider {
+    constructor() {
+        super(...arguments);
+        this.store = new JsonArrayStore_1.JsonArrayStore({
+            path: _path_1.$path.resolve('/data/tokens/1inch.json'),
+            key: x => x.symbol,
+            format: true,
+        });
+    }
+    getTokens() {
+        return this.store.getAll();
+    }
+    async redownloadTokens() {
+        let tokensByPlatform = await Promise.all([
+            this.downloadForPlatform('eth'),
+            this.downloadForPlatform('bsc'),
+            this.downloadForPlatform('polygon'),
+        ]);
+        let globals = TokenUtils_1.TokenUtils.merge(...tokensByPlatform);
+        await this.store.saveAll(globals);
+        return globals;
+    }
+    async downloadForPlatform(platform) {
+        let url;
+        switch (platform) {
+            case 'eth':
+                url = `https://api.1inch.exchange/v3.0/1/tokens`;
+                break;
+            case 'bsc':
+                url = `https://api.1inch.exchange/v3.0/56/tokens`;
+                break;
+            case 'polygon':
+                url = `https://api.1inch.exchange/v3.0/137/tokens`;
+                break;
+            default:
+                throw new Error(`Invalid Platform ${platform}`);
+        }
+        let resp = await axios_1.default.get(url);
+        let hash = resp.data.tokens;
+        let arr = Object.keys(hash).map(key => {
+            let t = hash[key];
+            return {
+                symbol: t.symbol,
+                name: t.name,
+                decimals: t.decimals,
+                logo: t.logoURI,
+                platform: platform,
+                address: t.address,
+            };
+        });
+        return arr;
+    }
+}
+exports.TPOneInch = TPOneInch;

package/dist/src/tokens/TokenProviders/TPSushiswap.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPSushiswap = void 0;
+const axios_1 = __importDefault(require("axios"));
+const JsonArrayStore_1 = require("@dequanto/json/JsonArrayStore");
+const TokenUtils_1 = require("../utils/TokenUtils");
+const ATokenProvider_1 = require("./ATokenProvider");
+const _path_1 = require("@dequanto/utils/$path");
+class TPSushiswap extends ATokenProvider_1.ATokenProvider {
+    constructor() {
+        super(...arguments);
+        this.store = new JsonArrayStore_1.JsonArrayStore({
+            path: _path_1.$path.resolve('/data/tokens/sushi.json'),
+            key: x => x.symbol,
+            format: true,
+        });
+    }
+    getTokens() {
+        return this.store.getAll();
+    }
+    /** Finds remote  */
+    async find(address) {
+        throw new Error('Not implemented');
+    }
+    async redownloadTokens() {
+        let tokensByPlatform = await Promise.all([
+            this.downloadForPlatform('eth'),
+            this.downloadForPlatform('polygon'),
+            this.downloadForPlatform('xdai'),
+        ]);
+        let globals = TokenUtils_1.TokenUtils.merge(...tokensByPlatform);
+        await this.store.saveAll(globals);
+        return globals;
+    }
+    async downloadForPlatform(platform) {
+        let url;
+        let mapper;
+        function mapperApi(resp) {
+            let arr = resp.data[1];
+            return arr.map(t => {
+                return {
+                    symbol: t.Symbol,
+                    name: t.Name,
+                    decimals: t.Decimals,
+                    platform: platform,
+                    address: t.Contract,
+                };
+            });
+        }
+        function mapperGithub(resp) {
+            let arr = resp.data;
+            return arr.map(t => {
+                return {
+                    symbol: t.symbol,
+                    name: t.name,
+                    decimals: t.decimals,
+                    platform: platform,
+                    address: t.address,
+                };
+            });
+        }
+        switch (platform) {
+            case 'eth':
+                url = `https://api2.sushipro.io/?action=all_tokens&chainID=1`;
+                mapper = mapperApi;
+                break;
+            case 'bsc':
+                throw new Error(`Bsc is not supported by sushiswap api`);
+                break;
+            case 'polygon':
+                url = `https://api2.sushipro.io/?action=all_tokens&chainID=137`;
+                mapper = mapperApi;
+                break;
+            case 'xdai':
+                url = `https://raw.githubusercontent.com/sushiswap/default-token-list/master/tokens/xdai.json`;
+                mapper = mapperGithub;
+                break;
+            default:
+                throw new Error(`Invalid Platform ${platform}`);
+        }
+        let resp = await axios_1.default.get(url);
+        let tokens = mapper(resp);
+        return tokens;
+    }
+}
+exports.TPSushiswap = TPSushiswap;

package/dist/src/tokens/TokenProviders/TPUniswap.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPUniswap = void 0;
+const axios_1 = __importDefault(require("axios"));
+const JsonArrayStore_1 = require("@dequanto/json/JsonArrayStore");
+const ATokenProvider_1 = require("./ATokenProvider");
+const _path_1 = require("@dequanto/utils/$path");
+const TheGraphUrl = 'https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v2';
+class TPUniswap extends ATokenProvider_1.ATokenProvider {
+    constructor() {
+        super(...arguments);
+        this.store = new JsonArrayStore_1.JsonArrayStore({
+            path: _path_1.$path.resolve('/data/tokens/uni.json'),
+            key: x => x.symbol
+        });
+    }
+    getTokens() {
+        return this.store.getAll();
+    }
+    /** Finds remote  */
+    async find(address) {
+        let body = {
+            query: `
+                {
+                    tokens (where: {id: "${address}"}) {
+                    id
+                    symbol
+                    name
+                    decimals
+                    }
+                }
+            `
+        };
+        let resp = await axios_1.default.post(TheGraphUrl, body);
+        return resp.data.data?.tokens[0];
+    }
+    async redownloadTokens() {
+        let skip = 0;
+        let take = 1000;
+        let out = [];
+        while (true) {
+            let body = {
+                query: `
+                {
+                    tokens (skip: ${skip} first:${take}) {
+                      id
+                      symbol
+                      name
+                      decimals
+                    }
+                }
+                `
+            };
+            let resp = await axios_1.default.post(TheGraphUrl, body);
+            console.log(resp);
+            let tokens = resp.data.data?.tokens ?? [];
+            let arr = tokens.map(uniT => {
+                return {
+                    symbol: uniT.symbol,
+                    name: uniT.name,
+                    decimals: Number(uniT.decimals) || 18,
+                    platforms: [
+                        {
+                            platform: 'eth',
+                            address: uniT.id,
+                            decimals: uniT.decimals,
+                        }
+                    ]
+                };
+            });
+            out = out.concat(...arr);
+            if (tokens.length < take) {
+                break;
+            }
+            skip += take;
+        }
+        await this.store.saveAll(out);
+        return out;
+    }
+}
+exports.TPUniswap = TPUniswap;

package/dist/src/tokens/TokenService.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenService = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const WXDaiTokenContract_1 = require("@dequanto/chains/xdai/tokens/WXDaiTokenContract");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const TokensServiceFactory_1 = require("./TokensServiceFactory");
+const _require_1 = require("@dequanto/utils/$require");
+class TokenService {
+    constructor(client) {
+        this.client = client;
+        this.tokensProvider = TokensServiceFactory_1.TokensServiceFactory.get(this.client.platform);
+    }
+    async balanceOf(address, token) {
+        token = await this.getToken(token);
+        let isNative = this.tokensProvider.isNative(token.address);
+        if (isNative) {
+            return this.client.getBalance(address);
+        }
+        let erc20 = await this.tokensProvider.erc20(token);
+        let balance = await erc20.balanceOf(address);
+        return balance;
+    }
+    async hasToken(address, token, amount) {
+        let t = await this.getToken(token);
+        let balance = await this.balanceOf(address, t);
+        let wei = _bigint_1.$bigint.toWei(amount, t.decimals);
+        return wei <= balance;
+    }
+    async ensureApproved(account, tokenMix, spender, amount) {
+        let token = await this.getToken(tokenMix);
+        let erc20 = await this.tokensProvider.erc20(token.address);
+        let approved = await erc20.allowance(account.address, spender);
+        let desiredApproval = typeof amount === 'bigint'
+            ? amount
+            : _bigint_1.$bigint.toWei(amount, token.decimals);
+        if (true || approved < desiredApproval) {
+            return await erc20
+                .$config({
+                gasEstimation: true,
+                type: 2,
+            }, {
+                retries: 0
+            })
+                .approve(account, spender, desiredApproval * 2n);
+        }
+        return null;
+    }
+    /**
+     * @param amount Can be negative (wraps all with rest)
+     */
+    async wrapNativeToERC20(account, amount) {
+        let amountWei = _bigint_1.$bigint.toWei(amount, 18);
+        if (amountWei < 0n) {
+            let balance = await this.client.getBalance(account.address);
+            amountWei = balance + amountWei;
+        }
+        _require_1.$require.gt(amountWei, 0n);
+        let depositor;
+        switch (this.client.platform) {
+            case 'xdai':
+                depositor = a_di_1.default.resolve(WXDaiTokenContract_1.WXDaiTokenContract);
+                break;
+        }
+        if (depositor == null) {
+            throw new Error(`Wrapping depositor not found for platform ${this.client?.platform}`);
+        }
+        return await depositor.deposit({
+            ...account,
+            value: amountWei
+        });
+    }
+    /**
+     *
+     */
+    async unwrapNative(account, amount) {
+        let depositor;
+        switch (this.client.platform) {
+            case 'xdai':
+                depositor = a_di_1.default.resolve(WXDaiTokenContract_1.WXDaiTokenContract);
+                break;
+        }
+        if (depositor == null) {
+            throw new Error(`Wrapping depositor not found for platform ${this.client?.platform}`);
+        }
+        if (amount == null || amount === Infinity) {
+            amount = await depositor.balanceOf(account.address);
+        }
+        let amountWei = typeof amount === 'number'
+            ? _bigint_1.$bigint.toWei(amount, 18)
+            : amount;
+        console.log(amount, amountWei);
+        _require_1.$require.gt(amountWei, 0n);
+        return await depositor.withdraw(account, amountWei);
+    }
+    async getToken(mix) {
+        let token = typeof mix === 'string'
+            ? await this.tokensProvider.getKnownToken(mix)
+            : mix;
+        if (this.tokensProvider.isNative(token.address)) {
+            token = {
+                ...token,
+                address: '0x0000000000000000000000000000000000000000',
+            };
+        }
+        if (token == null || token.address == null) {
+            throw new Error(`Address undefined: ${token}`);
+        }
+        return token;
+    }
+}
+exports.TokenService = TokenService;

package/dist/src/tokens/TokenSwapService.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenSwapService = void 0;
+const ChainAccountsService_1 = require("@dequanto/ChainAccountsService");
+const a_di_1 = __importDefault(require("a-di"));
+const Paraswap_1 = require("./defi/paraswap/Paraswap");
+class TokenSwapService {
+    constructor(client, provider = a_di_1.default.resolve(Paraswap_1.Paraswap, client.platform, client)) {
+        this.client = client;
+        this.provider = provider;
+    }
+    async swap(account, params) {
+        if (typeof account === 'string') {
+            let accountsService = a_di_1.default.resolve(ChainAccountsService_1.ChainAccountsService);
+            let acc = await accountsService.get(account, this.client.platform);
+            if (acc == null) {
+                throw new Error(`Account ${account} not found`);
+            }
+            account = acc;
+        }
+        // let transfer = di.resolve(TokenTransferService, this.client);
+        // let balance = await transfer.getBalance(account, params.from);
+        // let token = await transfer.getToken(TOKEN_FROM);
+        // let amount = balance - $bigint.toWei(24, token.decimals);
+        let { from, to, amount } = params;
+        let tx = await this.provider.swap(account, {
+            from: from,
+            to: to,
+            fromAmount: amount,
+        });
+        return tx;
+    }
+}
+exports.TokenSwapService = TokenSwapService;

package/dist/src/tokens/TokenTransferService.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTransferService = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const TxDataBuilder_1 = require("@dequanto/txs/TxDataBuilder");
+const TxWriter_1 = require("@dequanto/txs/TxWriter");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const _is_1 = require("@dequanto/utils/$is");
+const TokensService_1 = require("./TokensService");
+const _address_1 = require("@dequanto/utils/$address");
+const _promise_1 = require("@dequanto/utils/$promise");
+const LoggerService_1 = require("@dequanto/loggers/LoggerService");
+const _logger_1 = require("@dequanto/utils/$logger");
+class TokenTransferService {
+    constructor(client, logger = a_di_1.default.resolve(LoggerService_1.LoggerService)) {
+        this.client = client;
+        this.logger = logger;
+        this.tokenService = a_di_1.default.resolve(TokensService_1.TokensService, this.client.platform);
+    }
+    $config(txConfig) {
+        this.txConfig = txConfig;
+        return this;
+    }
+    async getBalance(address, token) {
+        token = await this.getToken(token);
+        let isNative = this.tokenService.isNative(token.address);
+        if (isNative) {
+            return this.client.getBalance(address);
+        }
+        let erc20 = await TokensService_1.TokensService.erc20(token, this.client.platform);
+        let balance = await erc20.balanceOf(address);
+        return balance;
+    }
+    async getReceived(receipt) {
+        let receiver = receipt.from;
+        let ANYTOKEN = 'USDC';
+        let erc20 = await TokensService_1.TokensService.erc20(ANYTOKEN, this.client.platform);
+        let transfers = erc20.extractLogsTransfer(receipt);
+        let transfer = transfers.find(x => _address_1.$address.eq(x.to, receiver));
+        return transfer?.value ?? 0n;
+    }
+    /** Returns NULL for transaction, if no balance to transfer */
+    async transferAll(from, to, token) {
+        token = await this.getToken(token);
+        let isNative = this.tokenService.isNative(token.address);
+        if (isNative) {
+            return this.transferNativeAll(from, to);
+        }
+        return this.transferErc20All(from, to, token);
+    }
+    async transferAllWithRemainder(from, to, token, remainder) {
+        token = await this.getToken(token);
+        let isNative = this.tokenService.isNative(token.address);
+        if (isNative) {
+            return this.transferNativeAll(from, to, { remainder });
+        }
+        return this.transferErc20All(from, to, token, { remainder });
+    }
+    async transfer(from, to, token, amount) {
+        token = await this.getToken(token);
+        amount = this.getAmount(amount, token);
+        let isNative = this.tokenService.isNative(token.address);
+        if (isNative) {
+            return this.transferNative(from, to, amount);
+        }
+        return this.transferErc20(from, to, token, amount);
+    }
+    async getToken(token) {
+        if (typeof token === 'string') {
+            token = await this.tokenService.getKnownToken(token);
+        }
+        _is_1.$is.notNull(token, 'Token is undefined to transfer');
+        return token;
+    }
+    isNativeToken(token) {
+        return this.tokenService.isNative(typeof token === 'string' ? token : token.address);
+    }
+    async transferNativeAll(from, to, opts) {
+        let buildTxRetries = 1;
+        const buildTx = async () => {
+            let GAS = 21000;
+            let GAS_RATIO = 1.05;
+            let [balance, gasPrice] = await Promise.all([
+                this.client.getBalance(from.address),
+                this.client.getGasPrice()
+            ]);
+            if (opts?.remainder != null) {
+                let remainder = this.getAmount(opts.remainder, 18);
+                balance -= remainder;
+            }
+            let $gasPrice = _bigint_1.$bigint.multWithFloat(gasPrice.price, GAS_RATIO);
+            console.log('$gasPrice', _bigint_1.$bigint.toGweiFromWei($gasPrice));
+            let gasConsumed = BigInt(GAS) * $gasPrice;
+            let transferValue = balance - gasConsumed;
+            if (transferValue <= 0) {
+                if (--buildTxRetries > -1) {
+                    _logger_1.$logger.log(`No balance to transfer retry in 5s`);
+                    await _promise_1.$promise.wait(5000);
+                    return buildTx();
+                }
+                // No balance to transfer
+                _logger_1.$logger.log(`No balance to transfer in ${from.address}. ${opts?.remainder ? ("Remainder: " + opts?.remainder) : ""}`);
+                return null;
+            }
+            let txBuilder = new TxDataBuilder_1.TxDataBuilder(this.client, from, {
+                to: to,
+                value: _bigint_1.$bigint.toHex(transferValue)
+            });
+            txBuilder.data.gasPrice = _bigint_1.$bigint.toHex($gasPrice);
+            // txBuilder.data.maxFeePerGas = $bigint.toHex($gasPrice - 20n**9n);
+            // txBuilder.data.maxPriorityFeePerGas = $bigint.toHex(20n**9n);
+            txBuilder.data.gasLimit = GAS;
+            txBuilder.data.type = 1;
+            txBuilder.setConfig(this.txConfig);
+            await Promise.all([
+                txBuilder.setNonce({ overriding: true }),
+            ]);
+            _logger_1.$logger.log(`TransferNative ALL. Balance ${balance}; GasConsumed ${gasConsumed}; TransferValue ${transferValue}; Nonce: ${txBuilder.data.nonce}`);
+            return txBuilder;
+        };
+        let txBuilder = await buildTx();
+        return TxWriter_1.TxWriter.write(this.client, txBuilder, from, {
+            retries: 3,
+            async onErrorRebuild(tx, error, errCount) {
+                // In case we got `balance` value, but that one was outdated, then all our calculations where wrong.
+                // Retry the calculation and transfer once again.
+                if (/insufficient funds/.test(error.message)) {
+                    const ms = 6000 * errCount;
+                    _logger_1.$logger.log(`TokenTransfer Failed: insufficient funds. Waiting ${ms}ms to retry`);
+                    await _promise_1.$promise.wait(ms);
+                    return buildTx();
+                }
+                return null;
+            }
+        });
+    }
+    async transferNative(from, to, amount) {
+        let txBuilder = new TxDataBuilder_1.TxDataBuilder(this.client, from, {
+            to: to,
+            value: _bigint_1.$bigint.toHex(amount)
+        });
+        let GAS = 21000;
+        await Promise.all([
+            txBuilder.setGas({ priceRatio: this.gasPriorityFee, gasLimit: GAS }),
+            txBuilder.setNonce(),
+        ]);
+        txBuilder.setConfig(this.txConfig);
+        return TxWriter_1.TxWriter.write(this.client, txBuilder, from);
+    }
+    async transferErc20All(from, to, token, opts) {
+        let erc20 = await TokensService_1.TokensService.erc20(token, this.client.platform);
+        let balance = await erc20.balanceOf(from.address);
+        if (opts?.remainder != null) {
+            let remainder = this.getAmount(opts.remainder, 18);
+            balance -= remainder;
+        }
+        if (balance <= 0n) {
+            if (opts?.retryCount == null || opts?.retryCount !== 0) {
+                // re-read
+                this.logger.warn(`TransferErc20All has no balance to transfer: ${token.address}. Balance re-fetch scheduled.`);
+                await _promise_1.$promise.wait(4000);
+                return this.transferErc20All(from, to, token, {
+                    ...(opts ?? {}),
+                    retryCount: 0
+                });
+            }
+            return null;
+        }
+        return erc20
+            .$config(this.txConfig)
+            .transfer(from, to, balance);
+    }
+    async transferErc20(from, to, token, amount) {
+        let erc20 = await TokensService_1.TokensService.erc20(token, this.client.platform);
+        return erc20
+            .$config(this.txConfig)
+            .transfer(from, to, amount);
+    }
+    getAmount(amount, mix) {
+        if (typeof amount === 'number') {
+            amount = _bigint_1.$bigint.toWei(amount, typeof mix === 'number' ? mix : mix.decimals);
+        }
+        return amount;
+    }
+}
+exports.TokenTransferService = TokenTransferService;