dequanto 0.0.1 → 0.0.7

package/dist/src/tokens/TokenOracles/AmmPriceV2Oracle.js

@@ -16,14 +16,13 @@ const TokenPriceStore_1 = require("./TokenPriceStore");
 const _bigint_1 = require("@dequanto/utils/$bigint");
 const AmmPairV2Service_1 = require("../TokenExchanges/AmmBase/V2/AmmPairV2Service");
 const SushiswapPolygonExchange_1 = require("../TokenExchanges/SushiswapPolygonExchange");
-const _logger_1 = require("@dequanto/utils/$logger");
 class AmmPriceV2Oracle {
     constructor(client, explorer) {
         this.client = client;
         this.explorer = explorer;
         this.tokensService = a_di_1.default.resolve(TokensService_1.TokensService, this.client.platform, this.explorer);
         this.pairService = a_di_1.default.resolve(AmmPairV2Service_1.AmmPairV2Service, this.client, this.explorer);
-        this.logger = a_di_1.default.resolve(LoggerService_1.LoggerService, nameof(AmmPriceV2Oracle));
+        this.logger = a_di_1.default.resolve(LoggerService_1.LoggerService, 'AmmPriceV2Oracle');
         switch (client.platform) {
             case 'bsc':
                 this.exchange = a_di_1.default.resolve(PancakeswapExchange_1.PancakeswapExchange, this.client, this.explorer);
@@ -83,7 +82,6 @@ class AmmPriceV2Oracle {
             : await this.pairService.resolveBestStableRoute(this.client.platform, token.address));
         if (route == null || route.length === 0) {
             let error = new Error(`Route not found for Token ${token.address}`);
-            this.logger.write(error.message);
             return { error };
         }
         let pools = await (0, alot_1.default)(route).mapAsync(async (lp) => {
@@ -289,7 +287,7 @@ var TokenPrice;
         let fromPrice = TokenUtils_1.TokenUtils.calcPrice(fromAmount, fromToken, fromUsd ?? toUsd);
         let toPrice = TokenUtils_1.TokenUtils.calcPrice(amountActual, toToken, toUsd ?? fromUsd);
         //console.log('FromPice', fromPrice, fromAmount, fromToken, fromUsd, toUsd);
-        _logger_1.$logger.log(`Swap: ${fromToken.symbol}(${fromAmount})[${fromUsd}$] > ${toToken.symbol} (${amountActual})[${toUsd}$]; Price ${fromToken.symbol}: ${fromPrice}`);
+        //$logger.log(`Swap: ${fromToken.symbol}(${fromAmount})[${fromUsd}$] > ${toToken.symbol} (${amountActual})[${toUsd}$]; Price ${fromToken.symbol}: ${fromPrice}`);
         if (lp.date) {
             // Cache prices
             let fromStore = TokenPriceStore_1.TokenPriceStore.forToken(fromToken.address);

package/dist/src/tokens/TokenOracles/CoingeckoOracle.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoingeckoOracle = void 0;
+const _config_1 = require("@dequanto/utils/$config");
+class CoingeckoOracle {
+    constructor() {
+        this.key = _config_1.$config.get('coingecko.key');
+    }
+    getToken(name) {
+    }
+}
+exports.CoingeckoOracle = CoingeckoOracle;

package/dist/src/tokens/TokenOracles/TokenPriceStore.js

@@ -15,7 +15,7 @@ const memd_1 = __importDefault(require("memd"));
 class TokenPriceStore {
     constructor(token) {
         this.token = token;
-        this.prices = null;
+        this.prices = [];
         this.pricesIdx = {};
         this.store = new JsonArrayStore_1.JsonArrayStore({
             path: `./db/tokens/${this.token}.json`,

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

@@ -1,22 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TPChain = void 0;
+const ContractReader_1 = require("@dequanto/contracts/ContractReader");
 class TPChain {
-    constructor(platform, explorer) {
+    constructor(platform, client) {
         this.platform = platform;
-        this.explorer = explorer;
+        this.client = client;
     }
     async getByAddress(platform, address) {
         if (this.platform !== platform) {
             return null;
         }
+        let reader = new ContractReader_1.ContractReader(this.client);
         try {
-            let source = await this.explorer?.getContractSource(address);
+            let [symbol, name, decimals,] = await Promise.all([
+                reader.readAsync(address, 'function symbol() returns string'),
+                reader.readAsync(address, 'function name() returns string'),
+                reader.readAsync(address, 'function decimals() returns uint8'),
+            ]);
             return {
-                address: address,
-                symbol: source
-                    .ContractName
-                    ?.replace(/bep20/i, ''),
+                platform,
+                address,
+                symbol,
+                name,
+                decimals,
             };
         }
         catch (error) {

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

@@ -0,0 +1,117 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPCoingecko = void 0;
+const axios_1 = __importDefault(require("axios"));
+const memd_1 = __importDefault(require("memd"));
+const alot_1 = __importDefault(require("alot"));
+const atma_io_1 = require("atma-io");
+const _path_1 = require("@dequanto/utils/$path");
+const JsonArrayStore_1 = require("@dequanto/json/JsonArrayStore");
+const ATokenProvider_1 = require("./ATokenProvider");
+const _logger_1 = require("@dequanto/utils/$logger");
+const _promise_1 = require("@dequanto/utils/$promise");
+class TPCoingecko extends ATokenProvider_1.ATokenProvider {
+    constructor() {
+        super(...arguments);
+        this.store = new JsonArrayStore_1.JsonArrayStore({
+            path: _path_1.$path.resolve('/data/tokens/coingecko.json'),
+            key: x => x.symbol,
+            format: true,
+        });
+        this.mapping = {
+            'ethereum': 'eth',
+            'polygon-pos': 'poly',
+            'xdai': 'xdai',
+            'binance-smart-chain': 'bsc',
+            'arbitrum-one': 'arbitrum'
+        };
+    }
+    getTokens() {
+        return this.store.getAll();
+    }
+    async redownloadTokens() {
+        let list = await this.downloadList();
+        (0, _logger_1.l) `Got list of ${list.length} tokens from CoinGecko. Fetching details...`;
+        let tokens = await (0, alot_1.default)(list)
+            .mapAsync(async (token, i) => {
+            if (i > 0 && i % 10 === 0) {
+                (0, _logger_1.l) `Fetched ${i}/${list.length} token details`;
+            }
+            let info = await this.downloadTokenInfoOrCache(token.id);
+            return {
+                name: token.name,
+                symbol: token.symbol,
+                platforms: alot_1.default
+                    .fromObject(info?.detail_platforms ?? {})
+                    .map(entry => {
+                    let platform = this.mapPlatform(entry.key);
+                    return {
+                        platform,
+                        decimals: entry.value.decimal_place,
+                        address: entry.value.contract_address,
+                    };
+                })
+                    .filter(x => Boolean(x.platform) && Boolean(x.address) && Boolean(x.decimals))
+                    .toArray()
+            };
+        })
+            .filterAsync(x => x.platforms.length > 0)
+            .toArrayAsync();
+        await this.store.saveAll(tokens);
+        return tokens;
+    }
+    async downloadList() {
+        let resp = await axios_1.default.get(`https://api.coingecko.com/api/v3/coins/list`);
+        return resp.data;
+    }
+    async downloadTokenInfoOrCache(id) {
+        let cachePath = `./cache/coingecko/${id}.json`;
+        if (await atma_io_1.File.existsAsync(cachePath)) {
+            let json = await atma_io_1.File.readAsync(cachePath);
+            return json.info;
+        }
+        let info = await this._downloadTokenInfo(id);
+        await atma_io_1.File.writeAsync(cachePath, { info, id, timestamp: Date.now() });
+        return info;
+    }
+    // 50 per minute
+    async _downloadTokenInfo(id) {
+        let wait = 10000;
+        async function fetch() {
+            try {
+                let resp = await axios_1.default.get(`https://api.coingecko.com/api/v3/coins/${id}`);
+                return resp.data;
+            }
+            catch (error) {
+                let e = error;
+                if (e.response?.status === 404) {
+                    return { id, detail_platforms: {} };
+                }
+                if (e.response?.status === 429) {
+                    (0, _logger_1.l) `Throttled. Wait for ${wait}ms`;
+                    await _promise_1.$promise.wait(wait);
+                    wait *= 1.2;
+                    return fetch();
+                }
+                throw error;
+            }
+        }
+        return fetch();
+    }
+    mapPlatform(platformName) {
+        return this.mapping[platformName] ?? platformName;
+    }
+}
+__decorate([
+    memd_1.default.deco.throttle(60 * 1000 / 50)
+], TPCoingecko.prototype, "_downloadTokenInfo", null);
+exports.TPCoingecko = TPCoingecko;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPConfig = void 0;
+const ATokenProvider_1 = require("./ATokenProvider");
+const Config_1 = require("@dequanto/Config");
+const _require_1 = require("@dequanto/utils/$require");
+class TPConfig extends ATokenProvider_1.ATokenProvider {
+    async getTokens() {
+        return Config_1.config.tokens ?? [];
+    }
+    async addToken(token) {
+        _require_1.$require.Address(token.address);
+        _require_1.$require.Number(token.decimals);
+        _require_1.$require.notNull(token.platform, 'Not possible to add the token - platform is undefined');
+        let tokens = await this.getTokens();
+        let current = tokens.find(t => t.symbol === token.symbol);
+        if (current == null) {
+            current = {
+                symbol: token.symbol,
+                platforms: []
+            };
+            tokens.push(current);
+        }
+        if (current.platforms == null) {
+            current.platforms = [];
+        }
+        let currentPlatform = current.platforms.find(x => x.platform == token.platform);
+        if (currentPlatform == null) {
+            current.platforms.push({
+                platform: token.platform,
+                decimals: token.decimals,
+                address: token.address,
+            });
+        }
+        else {
+            currentPlatform.decimals = token.decimals;
+            currentPlatform.address = token.address;
+        }
+        await Config_1.Config.extend({
+            tokens
+        });
+    }
+    async redownloadTokens() {
+    }
+}
+exports.TPConfig = TPConfig;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPExplorer = void 0;
+class TPExplorer {
+    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.TPExplorer = TPExplorer;

package/dist/src/tokens/TokenService.js

@@ -14,13 +14,16 @@ class TokenService {
         this.client = client;
         this.tokensProvider = TokensServiceFactory_1.TokensServiceFactory.get(this.client.platform);
     }
-    async balanceOf(address, token) {
+    async balanceOf(address, token, params) {
         token = await this.getToken(token);
         let isNative = this.tokensProvider.isNative(token.address);
         if (isNative) {
-            return this.client.getBalance(address);
+            return this.client.getBalance(address, params?.forBlock);
         }
         let erc20 = await this.tokensProvider.erc20(token);
+        if (params?.forBlock != null) {
+            erc20 = erc20.forBlock(params.forBlock);
+        }
         let balance = await erc20.balanceOf(address);
         return balance;
     }

package/dist/src/tokens/TokenTransferService.js

@@ -14,14 +14,19 @@ 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");
+const _account_1 = require("@dequanto/utils/$account");
 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;
+    $config(builderConfig) {
+        this.builderConfig = builderConfig;
+        return this;
+    }
+    $configWriter(writerConfig) {
+        this.writerConfig = writerConfig;
         return this;
     }
     async getBalance(address, token) {
@@ -39,8 +44,8 @@ class TokenTransferService {
         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;
+        let transfer = transfers.find(x => _address_1.$address.eq(x.params.to, receiver));
+        return transfer?.params.value ?? 0n;
     }
     /** Returns NULL for transaction, if no balance to transfer */
     async transferAll(from, to, token) {
@@ -92,12 +97,12 @@ class TokenTransferService {
                 balance -= remainder;
             }
             let $gasPrice = _bigint_1.$bigint.multWithFloat(gasPrice.price, GAS_RATIO);
-            console.log('$gasPrice', _bigint_1.$bigint.toGweiFromWei($gasPrice));
+            _logger_1.$logger.log(`GasPrice ${_bigint_1.$bigint.toGweiFromWei($gasPrice)}gwei`);
             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`);
+                    _logger_1.$logger.log(`No balance to transfer. Retry in 5s`);
                     await _promise_1.$promise.wait(5000);
                     return buildTx();
                 }
@@ -114,7 +119,7 @@ class TokenTransferService {
             // txBuilder.data.maxPriorityFeePerGas = $bigint.toHex(20n**9n);
             txBuilder.data.gasLimit = GAS;
             txBuilder.data.type = 1;
-            txBuilder.setConfig(this.txConfig);
+            txBuilder.setConfig(this.builderConfig);
             await Promise.all([
                 txBuilder.setNonce({ overriding: true }),
             ]);
@@ -123,6 +128,7 @@ class TokenTransferService {
         };
         let txBuilder = await buildTx();
         return TxWriter_1.TxWriter.write(this.client, txBuilder, from, {
+            ...(this.writerConfig ?? {}),
             retries: 3,
             async onErrorRebuild(tx, error, errCount) {
                 // In case we got `balance` value, but that one was outdated, then all our calculations where wrong.
@@ -138,17 +144,19 @@ class TokenTransferService {
         });
     }
     async transferNative(from, to, amount) {
-        let txBuilder = new TxDataBuilder_1.TxDataBuilder(this.client, from, {
+        let sender = _account_1.$account.getSender(from);
+        let txBuilder = new TxDataBuilder_1.TxDataBuilder(this.client, sender, {
             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);
+        if (sender.address) {
+            await Promise.all([
+                txBuilder.setGas({ priceRatio: this.gasPriorityFee, gasEstimation: true, gasLimitRatio: 1, }),
+                txBuilder.setNonce(),
+            ]);
+        }
+        txBuilder.setConfig(this.builderConfig);
+        return TxWriter_1.TxWriter.write(this.client, txBuilder, from, this.writerConfig);
     }
     async transferErc20All(from, to, token, opts) {
         let erc20 = await TokensService_1.TokensService.erc20(token, this.client.platform);
@@ -167,16 +175,18 @@ class TokenTransferService {
                     retryCount: 0
                 });
             }
-            return null;
+            if (this.builderConfig.gasFunding == null) {
+                return null;
+            }
         }
         return erc20
-            .$config(this.txConfig)
+            .$config(this.builderConfig, this.writerConfig)
             .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)
+            .$config(this.builderConfig, this.writerConfig)
             .transfer(from, to, amount);
     }
     getAmount(amount, mix) {