dequanto 0.0.1 → 0.0.7

package/dist/src/BlockchainExplorer/BlockChainExplorerFactory.js

@@ -15,14 +15,20 @@ const memd_1 = __importDefault(require("memd"));
 const axios_1 = __importDefault(require("axios"));
 const _logger_1 = require("@dequanto/utils/$logger");
 const _promise_1 = require("@dequanto/utils/$promise");
+const _address_1 = require("@dequanto/utils/$address");
+const _require_1 = require("@dequanto/utils/$require");
+const Web3ClientFactory_1 = require("@dequanto/clients/Web3ClientFactory");
+const _config_1 = require("@dequanto/utils/$config");
 var BlockChainExplorerFactory;
 (function (BlockChainExplorerFactory) {
     function create(opts) {
         const client = new Client();
+        opts = ensureDefaults(opts);
         return class {
-            constructor() {
+            constructor(platform) {
+                this.platform = platform;
                 this.localDb = opts.CONTRACTS;
-                this.config = opts.getConfig();
+                this.config = opts.getConfig(this.platform);
                 this.getContractAbi = memd_1.default.fn.memoize(this.getContractAbi, {
                     trackRef: true,
                     persistance: new memd_1.default.FsTransport({
@@ -47,13 +53,22 @@ var BlockChainExplorerFactory;
                     address = info.proxy;
                 }
                 let url = `${this.config.host}/api?module=contract&action=getabi&address=${address}&apikey=${this.config.key}`;
-                let abi = await client.get(url);
+                let abi;
+                try {
+                    abi = await client.get(url);
+                }
+                catch (err) {
+                    let addressByByteCode = await this.getSimilarContract(address);
+                    if (addressByByteCode != null) {
+                        _logger_1.$logger.log(`Found similar byte code address: ${addressByByteCode}`);
+                        return this.getContractAbi(addressByByteCode);
+                    }
+                    throw err;
+                }
                 let abiJson = JSON.parse(abi);
                 if (params?.implementation) {
                     if (/0x.{64}/.test(params.implementation)) {
-                        let web3 = opts.getWeb3();
-                        let stat = await web3.getNodeInfos();
-                        //-let x = (BigInt($contract.keccak256("eip1967.proxy.implementation")) - 1n).toString(16);
+                        let web3 = opts.getWeb3(this.platform);
                         let uin256Hex = await web3.getStorageAt('0x5a58505a96d1dbf8df91cb21b54419fc36e93fde', `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`);
                         let hex = uin256Hex.replace(/0x0+/, '0x');
                         return this.getContractAbi(hex);
@@ -61,13 +76,18 @@ var BlockChainExplorerFactory;
                     throw new Error(`Implement ${params.implementation} support`);
                 }
                 if (isOpenZeppelinProxy(abiJson)) {
-                    let web3 = opts.getWeb3();
-                    let uin256Hex = await web3.getStorageAt(address, `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`);
-                    let hex = uin256Hex.replace(/0x0+/, '0x');
+                    let web3 = opts.getWeb3(this.platform);
+                    // (BigInt($contract.keccak256("eip1967.proxy.implementation")) - 1n).toString(16);
+                    let uint256Hex = await web3.getStorageAt(address, `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`);
+                    if (_address_1.$address.isEmpty(uint256Hex)) {
+                        // keccak-256 hash of "org.zeppelinos.proxy.implementation"
+                        uint256Hex = await web3.getStorageAt(address, `0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3`);
+                    }
+                    let hex = uint256Hex.replace(/0x0+/, '0x');
                     return this.getContractAbi(hex);
                 }
                 if (hasImplementationSlot(abiJson)) {
-                    let web3 = opts.getWeb3();
+                    let web3 = opts.getWeb3(this.platform);
                     let uin256Hex = await web3.readContract({
                         address: address,
                         abi: abiJson,
@@ -78,7 +98,7 @@ var BlockChainExplorerFactory;
                     return this.getContractAbi(hex);
                 }
                 if (hasTargetSlot(abiJson)) {
-                    let web3 = opts.getWeb3();
+                    let web3 = opts.getWeb3(this.platform);
                     let uin256Hex = await web3.readContract({
                         address: address,
                         abi: abiJson,
@@ -98,8 +118,8 @@ var BlockChainExplorerFactory;
             async getTransactions(addr, params) {
                 return this.loadTxs('txlist', addr, params);
             }
-            async getTransactionsAll(addr) {
-                return this.loadTxsAll('txlist', addr);
+            async getTransactionsAll(addr, params) {
+                return this.loadTxsAll('txlist', addr, params);
             }
             async getInternalTransactions(addr, params) {
                 return this.loadTxs('txlistinternal', addr, params);
@@ -127,6 +147,22 @@ var BlockChainExplorerFactory;
                 });
                 return events;
             }
+            async getSimilarContract(address) {
+                let url = `${this.config.www}/address/${address}#code`;
+                let html = await client.getHtml(url);
+                let rgx = /This contract matches/ig;
+                let match = rgx.exec(html);
+                if (match == null) {
+                    return null;
+                }
+                let rgxAddress = /0x[a-f\d]{40}/g;
+                rgxAddress.lastIndex = match.index;
+                let matchAddress = rgxAddress.exec(html);
+                if (matchAddress == null) {
+                    return null;
+                }
+                return matchAddress[0];
+            }
             async loadTxs(type, address, params) {
                 let url = `${this.config.host}/api?module=account&action=${type}&address=${address}&sort=${params.sort ?? 'desc'}&apikey=${this.config.key}`;
                 if (params.fromBlockNumber != null) {
@@ -141,11 +177,11 @@ var BlockChainExplorerFactory;
                 let txs = await client.get(url);
                 return txs;
             }
-            async loadTxsAll(type, address) {
+            async loadTxsAll(type, address, params) {
                 let page = 1;
                 let size = 1000;
                 let out = [];
-                let fromBlockNumber = null;
+                let fromBlockNumber = params?.fromBlockNumber;
                 while (true) {
                     let arr = await this.loadTxs(type, address, { fromBlockNumber, sort: 'asc' });
                     out.push(...arr);
@@ -165,25 +201,80 @@ var BlockChainExplorerFactory;
 function isOpenZeppelinProxy(abi) {
     let $interface = ['upgradeTo', 'implementation'];
     return $interface.every(name => {
-        return abi.some(item => item.type === 'function' && item.name === name);
+        return hasMethod(abi, name);
     });
 }
 function hasImplementationSlot(abi) {
-    let $interface = ['proxyOwner', 'implementation'];
-    return $interface.every(name => {
-        return abi.some(item => item.type === 'function' && item.name === name);
+    let $required = ['implementation'];
+    let hasRequired = $required.every(name => {
+        return hasMethod(abi, name);
     });
+    if (hasRequired === false) {
+        return false;
+    }
+    let $some = ['proxyOwner', 'proxyType'];
+    let hasOneOf = $some.some(name => {
+        return hasMethod(abi, name);
+    });
+    if (hasOneOf === false) {
+        return false;
+    }
+    return true;
 }
 function hasTargetSlot(abi) {
     let $interface = ['upgrade', 'getTarget'];
     return $interface.every(name => {
-        return abi.some(item => item.type === 'function' && item.name === name);
+        return hasMethod(abi, name);
     });
 }
+function hasMethod(abi, name) {
+    return abi.some(item => item.type === 'function' && item.name === name);
+}
+function ensureDefaults(opts) {
+    opts ?? (opts = {});
+    let hasNull = opts.ABI_CACHE == null
+        || opts.CONTRACTS == null
+        || opts.getConfig == null
+        || opts.getWeb3 == null;
+    if (hasNull === false) {
+        return opts;
+    }
+    let platform = opts.platform;
+    _require_1.$require.notNull(platform, `Generic Blockchain Explorer Config should contain platform name`);
+    opts.ABI_CACHE ?? (opts.ABI_CACHE = `./cache/${platform}/abis.json`);
+    opts.CONTRACTS ?? (opts.CONTRACTS = []);
+    opts.getWeb3 ?? (opts.getWeb3 = (_) => {
+        return Web3ClientFactory_1.Web3ClientFactory.get(platform);
+    });
+    opts.getConfig ?? (opts.getConfig = () => {
+        let config = _config_1.$config.get(`blockchainExplorer.${platform}`);
+        let mainnet = /(?<mainnet>\w+):/.exec(platform)?.groups?.mainnet;
+        if (mainnet != null) {
+            let mainnetConfig = _config_1.$config.get(`blockchainExplorer.${mainnet}`);
+            config = {
+                ...(mainnetConfig ?? {}),
+                ...(config ?? {})
+            };
+        }
+        return {
+            key: config?.key,
+            host: config?.host,
+            www: config?.www,
+        };
+    });
+    return opts;
+}
 class Client {
     async get(url) {
         return this.getInner(url);
     }
+    async getHtml(url) {
+        let resp = await axios_1.default.get(url);
+        if (resp.status !== 200) {
+            throw new Error(`${url} not loaded with status ${resp.status}.`);
+        }
+        return resp.data;
+    }
     async getPaged(url) {
         let arr = [];
         let page = 1;
@@ -225,3 +316,6 @@ class Client {
 __decorate([
     memd_1.default.deco.queued({ throttle: 1000 / 5 })
 ], Client.prototype, "get", null);
+__decorate([
+    memd_1.default.deco.queued({ throttle: 1000 / 5 })
+], Client.prototype, "getHtml", null);

package/dist/src/BlockchainExplorer/BlockChainExplorerProvider.js

@@ -10,6 +10,8 @@ const Bscscan_1 = require("./Bscscan");
 const Etherscan_1 = require("./Etherscan");
 const Polyscan_1 = require("./Polyscan");
 const XDaiscan_1 = require("@dequanto/chains/xdai/XDaiscan");
+const _config_1 = require("@dequanto/utils/$config");
+const Evmscan_1 = require("./Evmscan");
 var BlockChainExplorerProvider;
 (function (BlockChainExplorerProvider) {
     function get(platform) {
@@ -24,7 +26,13 @@ var BlockChainExplorerProvider;
                 return a_di_1.default.resolve(Arbiscan_1.Arbiscan);
             case 'xdai':
                 return a_di_1.default.resolve(XDaiscan_1.XDaiscan);
+            case 'hardhat':
+                return null;
             default:
+                let cfg = _config_1.$config.get(`blockchainExplorer.${platform}`);
+                if (cfg != null) {
+                    return (0, Evmscan_1.Evmscan)({ platform });
+                }
                 throw new Error(`Unsupported platform ${platform} for block chain explorer`);
         }
     }

package/dist/src/BlockchainExplorer/Bscscan.js

@@ -20,6 +20,7 @@ class Bscscan extends BlockChainExplorerFactory_1.BlockChainExplorerFactory.crea
         return {
             key: config?.key,
             host: config?.host,
+            www: config?.www,
         };
     }
 }) {

package/dist/src/BlockchainExplorer/Etherscan.js

@@ -4,10 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Etherscan = void 0;
-const BlockChainExplorerFactory_1 = require("./BlockChainExplorerFactory");
+const a_di_1 = __importDefault(require("a-di"));
 const _config_1 = require("@dequanto/utils/$config");
 const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
-const a_di_1 = __importDefault(require("a-di"));
+const BlockChainExplorerFactory_1 = require("./BlockChainExplorerFactory");
 const contracts = _config_1.$config.get('contracts.eth', []);
 class Etherscan extends BlockChainExplorerFactory_1.BlockChainExplorerFactory.create({
     ABI_CACHE: `./cache/eth/abis.json`,
@@ -15,11 +15,21 @@ class Etherscan extends BlockChainExplorerFactory_1.BlockChainExplorerFactory.cr
     getWeb3() {
         return a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client);
     },
-    getConfig() {
-        const config = _config_1.$config.get('blockchainExplorer.eth');
+    getConfig(platform) {
+        platform ?? (platform = 'eth');
+        let config = _config_1.$config.get(`blockchainExplorer.${platform}`);
+        let mainnet = /(?<mainnet>\w+):/.exec(platform)?.groups?.mainnet;
+        if (mainnet != null) {
+            let mainnetConfig = _config_1.$config.get(`blockchainExplorer.${mainnet}`);
+            config = {
+                ...(mainnetConfig ?? {}),
+                ...(config ?? {})
+            };
+        }
         return {
             key: config?.key,
             host: config?.host,
+            www: config?.www,
         };
     }
 }) {

package/dist/src/BlockchainExplorer/Evmscan.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Evmscan = void 0;
+const BlockChainExplorerFactory_1 = require("./BlockChainExplorerFactory");
+function Evmscan(options) {
+    const ClientConstructor = BlockChainExplorerFactory_1.BlockChainExplorerFactory.create(options);
+    return new ClientConstructor();
+}
+exports.Evmscan = Evmscan;

package/dist/src/BlockchainExplorer/Polyscan.js

@@ -20,6 +20,7 @@ class Polyscan extends BlockChainExplorerFactory_1.BlockChainExplorerFactory.cre
         return {
             key: config?.key,
             host: config?.host,
+            www: config?.www,
         };
     }
 }) {

package/dist/src/ChainAccountProvider.js

@@ -0,0 +1,89 @@
+"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.ChainAccountProvider = void 0;
+const memd_1 = __importDefault(require("memd"));
+const _config_1 = require("./utils/$config");
+const ethers_1 = require("ethers");
+const _address_1 = require("./utils/$address");
+const _crypto_1 = require("./utils/$crypto");
+const _buffer_1 = require("./utils/$buffer");
+var ChainAccountProvider;
+(function (ChainAccountProvider) {
+    function get(platform, name) {
+        let accounts = AccountsConfigProvider.get();
+        let acc = accounts?.[platform]?.[name];
+        if (acc == null) {
+            throw new Error(`Account not resolved by name: ${name} in ${platform}`);
+        }
+        acc.name = name;
+        acc.platform = platform;
+        return acc;
+    }
+    ChainAccountProvider.get = get;
+    function tryGet(mix, platform) {
+        let all = this.getAll();
+        let accounts = all.filter(x => (_address_1.$address.eq(mix, x.address) || x.name == mix));
+        if (accounts.length === 0) {
+            return null;
+        }
+        let acc = accounts[0];
+        return {
+            ...acc,
+            platform: platform ?? acc.platform
+        };
+    }
+    ChainAccountProvider.tryGet = tryGet;
+    function getAll() {
+        return AccountsConfigProvider.get();
+    }
+    ChainAccountProvider.getAll = getAll;
+    function getAddressFromKey(key) {
+        const bytes = _buffer_1.$buffer.fromHex(key);
+        const wallet = new ethers_1.Wallet(bytes);
+        return wallet.address;
+    }
+    ChainAccountProvider.getAddressFromKey = getAddressFromKey;
+    function generate(opts) {
+        const bytes = _crypto_1.$crypto.randomBytes(32);
+        const wallet = new ethers_1.Wallet(bytes);
+        return {
+            ...(opts ?? {}),
+            address: wallet.address,
+            key: wallet.privateKey,
+        };
+    }
+    ChainAccountProvider.generate = generate;
+    class AccountsConfigProvider {
+        static get() {
+            let accounts = _config_1.$config.get('accounts');
+            if (accounts == null) {
+                return [];
+            }
+            if (Array.isArray(accounts)) {
+                return accounts;
+            }
+            let out = [];
+            for (let platform in accounts) {
+                for (let name in accounts[platform]) {
+                    let account = accounts[platform][name];
+                    account.name = name;
+                    account.platform = platform;
+                    out.push(account);
+                }
+            }
+            return out;
+        }
+    }
+    __decorate([
+        memd_1.default.deco.memoize()
+    ], AccountsConfigProvider, "get", null);
+})(ChainAccountProvider = exports.ChainAccountProvider || (exports.ChainAccountProvider = {}));

package/dist/src/ChainAccountsService.js

@@ -6,15 +6,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChainAccountsService = void 0;
 const a_di_1 = __importDefault(require("a-di"));
 const alot_1 = __importDefault(require("alot"));
-const ChainAccounts_1 = require("./ChainAccounts");
+const ChainAccountProvider_1 = require("./ChainAccountProvider");
 const JsonArrayStore_1 = require("./json/JsonArrayStore");
+const NameService_1 = require("./ns/NameService");
 const _address_1 = require("./utils/$address");
+const _is_1 = require("./utils/$is");
 class ChainAccountsService {
     constructor() {
         this.store = a_di_1.default.resolve(Store);
-        this.config = ChainAccounts_1.ChainAccountProvider;
+        this.config = ChainAccountProvider_1.ChainAccountProvider;
     }
     async get(mix, platform) {
+        if (_is_1.$is.hexString(mix) && mix.length >= 64) {
+            return {
+                address: ChainAccountProvider_1.ChainAccountProvider.getAddressFromKey(mix),
+                key: mix
+            };
+        }
+        if (_address_1.$address.isValid(mix) === false) {
+            // Check NS
+            let ns = a_di_1.default.resolve(NameService_1.NameService);
+            if (ns.supports(mix)) {
+                let address = await ns.getAddress(mix);
+                if (address) {
+                    mix = address;
+                }
+            }
+        }
         let acc = this.config.tryGet(mix, platform);
         return acc ?? this.store.get(mix);
     }

package/dist/src/Config.js

@@ -1,7 +1,83 @@
 "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.config = exports.Config = void 0;
+const memd_1 = __importDefault(require("memd"));
+const appcfg_1 = __importDefault(require("appcfg"));
+const _secret_1 = require("./utils/$secret");
+const _cli_1 = require("./utils/$cli");
+const atma_utils_1 = require("atma-utils");
+const atma_io_1 = require("atma-io");
 class Config {
+    static async fetch(parameters) {
+        let unlockedAccountsKey = await _secret_1.$secret.getPin(parameters);
+        let configPathAccounts = _cli_1.$cli.getParamValue('config-accounts', parameters) ?? '%APPDATA%/.dequanto/accounts.json';
+        let configPathGlobal = _cli_1.$cli.getParamValue('config-global', parameters) ?? '%APPDATA%/.dequanto/config.yml';
+        let dequantoConfigs = 'dequanto/configs/';
+        let [
+        //- inApp,
+        inCwd, inNodeModules,] = await Promise.all([
+            //- Directory.existsAsync(env.applicationDir.combine(`./${dequantoConfigs}`).toString()),
+            atma_io_1.Directory.existsAsync(`./${dequantoConfigs}`),
+            atma_io_1.Directory.existsAsync(`./node_modules/${dequantoConfigs}`),
+        ]);
+        let prfx = '%APP%/';
+        if (inNodeModules) {
+            prfx = './node_modules/';
+        }
+        if (inCwd) {
+            prfx = './';
+        }
+        let cfg = await appcfg_1.default.fetch([
+            {
+                path: `${prfx}${dequantoConfigs}dequanto.yml`,
+                optional: true,
+            },
+            {
+                path: `${prfx}${dequantoConfigs}defi.yml`,
+                optional: true,
+            },
+            {
+                path: configPathGlobal,
+                writable: true,
+                optional: true,
+                extendArrays: false,
+            },
+            unlockedAccountsKey ? {
+                name: 'accounts',
+                path: configPathAccounts,
+                writable: true,
+                optional: true,
+                secret: unlockedAccountsKey
+            } : null,
+            {
+                path: 'package.json',
+                getterProperty: 'dequanto',
+                optional: true,
+            },
+            {
+                path: 'dequanto.yml',
+                optional: true
+            },
+        ]);
+        (0, atma_utils_1.obj_extend)(exports.config, cfg.toJSON());
+        return cfg;
+    }
+    static async extend(json) {
+        let current = await Config.fetch();
+        await current.$write(json);
+    }
 }
+__decorate([
+    memd_1.default.deco.memoize()
+], Config, "fetch", null);
 exports.Config = Config;
 exports.config = new Config();

package/dist/src/blocks/BlockDateResolver.js

@@ -10,18 +10,15 @@ class BlockDateResolver {
     constructor(client) {
         this.client = client;
         this.AVG_INITIAL = {
-            eth: 12 * 1000,
-            bsc: 3 * 1000,
-            polygon: 3 * 1000,
+            eth: 12000,
+            bsc: 3000,
+            polygon: 3000,
         };
         this.known = [];
     }
     async getBlockNumberFor(date) {
         this.q = date;
-        let avg = this.AVG_INITIAL[this.client.platform];
-        if (avg == null) {
-            throw new Error(`AVG Block Time not defined for ${this.client.platform}`);
-        }
+        let avg = this.AVG_INITIAL[this.client.platform] ?? this.AVG_INITIAL['eth'];
         let now = new Date();
         let topBlock = {
             blockNumber: await this.client.getBlockNumberCached(),
@@ -69,6 +66,9 @@ class BlockDateResolver {
             return null;
         }
         let blockNumber = anchor.blockNumber + diffCount;
+        if (blockNumber < 0) {
+            throw new Error(`Date Out of range: ${this.q.toISOString()}. Based on the AVG block time, the blockchain was not active on that date`);
+        }
         let date = await this.getBlockDate(blockNumber);
         let info = {
             blockNumber: blockNumber,
@@ -78,6 +78,7 @@ class BlockDateResolver {
         this.refineAvg();
         return info;
     }
+    /** Add a know block to set */
     push(info) {
         for (let i = 0; i < this.known.length; i++) {
             let x = this.known[i];
@@ -110,7 +111,7 @@ class BlockDateResolver {
         let diff = this.diffTimeAbs(b1.date, b2.date);
         return Math.round(diff / Math.abs(b2.blockNumber - b1.blockNumber));
     }
-    /** Having N>1 blocks we can better find out the AVG block time */
+    /** With N>1 blocks we can better find out the AVG block time */
     refineAvg() {
         for (let i = 1; i < this.known.length; i++) {
             let info = this.known[i];

package/dist/src/bridges/hop/HopBridge.js

@@ -18,11 +18,11 @@ const atma_utils_1 = require("atma-utils");
 const Dai_l2AmmWrapperContract_1 = require("./contracts/polygon/Dai_l2AmmWrapperContract");
 const HopAddresses_1 = require("./HopAddresses");
 const Dai_l2BridgeContract_1 = require("./contracts/polygon/Dai_l2BridgeContract");
-const _fn_1 = require("@dequanto/utils/$fn");
 const PlatformFactory_1 = require("@dequanto/chains/PlatformFactory");
 const _require_1 = require("@dequanto/utils/$require");
 const Dai_l2SaddleSwapContract_1 = require("./contracts/polygon/Dai_l2SaddleSwapContract");
 const _address_1 = require("@dequanto/utils/$address");
+const _promise_1 = require("@dequanto/utils/$promise");
 class HopBridge {
     constructor() {
         this.name = 'hop';
@@ -148,6 +148,8 @@ class HopBridge {
             estimatedReceived: BigInt(sendData.estimatedReceived.toString()),
             amountOut: BigInt(sendData.amountOut.toString())
         };
+        // decrease awaitence
+        params.amountOut = _bigint_1.$bigint.multWithFloat(params.amountOut, .98);
         let txWriter = await depositContract
             .$config({
             gasLimit: 300000,
@@ -173,13 +175,14 @@ class HopBridge {
                 result.txTransferId.resolve(event.transferId);
             }
             catch (error) {
+                console.log(`HopBridge transfer ${error.message}`);
                 result.txTransferId.reject(error);
             }
         }());
         return result;
     }
     async waitForTransfer(transferId, symbol, toPlatform, toAccount) {
-        let r = await _fn_1.$fn.waitForObject(async () => {
+        let r = await _promise_1.$promise.waitForObject(async () => {
             let val = await this.status(transferId, symbol, toPlatform);
             console.log(`${_date_1.$date.format(new Date(), 'HH:mm')} Checked for bridge transfer completion: ${val}`);
             if (val) {

package/dist/src/chains/PlatformFactory.js

@@ -18,8 +18,8 @@ const TokensServiceFactory_1 = require("@dequanto/tokens/TokensServiceFactory");
 const TokenTransferService_1 = require("@dequanto/tokens/TokenTransferService");
 const memd_1 = __importDefault(require("memd"));
 class PlatformFactory {
-    async get(platform) {
-        let client = Web3ClientFactory_1.Web3ClientFactory.get(platform);
+    async get(platform, opts) {
+        let client = Web3ClientFactory_1.Web3ClientFactory.get(platform, opts);
         let tokens = TokensServiceFactory_1.TokensServiceFactory.get(platform);
         let explorer = BlockChainExplorerProvider_1.BlockChainExplorerProvider.get(platform);
         let accounts = new ChainAccountsService_1.ChainAccountsService();

package/dist/src/chains/arbitrum/ArbWeb3Client.js

@@ -1,39 +1,20 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArbWeb3Client = void 0;
 const _config_1 = require("@dequanto/utils/$config");
-const tx_1 = require("@ethereumjs/tx");
-const common_1 = __importDefault(require("@ethereumjs/common"));
 const Web3Client_1 = require("@dequanto/clients/Web3Client");
 const ClientEndpoints_1 = require("@dequanto/clients/utils/ClientEndpoints");
 class ArbWeb3Client extends Web3Client_1.Web3Client {
     constructor(opts) {
-        super(ClientEndpoints_1.ClientEndpoints.filterEndpoints(_config_1.$config.get('web3.arbitrum.endpoints'), opts));
+        super({
+            ...(opts ?? {}),
+            endpoints: ClientEndpoints_1.ClientEndpoints.filterEndpoints(_config_1.$config.get('web3.arbitrum.endpoints'), opts)
+        });
         this.platform = 'arbitrum';
-        this.chainId = 42161;
+        this.chainId = this.options.chainId ?? 42161;
         this.chainToken = 'ETH';
         this.TIMEOUT = 15 * 60 * 1000;
         this.defaultGasLimit = 2000000;
     }
-    sign(txData, privateKey) {
-        const key = Buffer.from(privateKey, 'hex');
-        const common = new common_1.default({
-            chain: 42161,
-            customChains: [{
-                    chainId: 42161,
-                    networkId: 42161,
-                    url: 'https://arb1.arbitrum.io/rpc',
-                    name: 'aeth',
-                    comment: '',
-                    hardforks: [{ name: 'mainnet' }]
-                }]
-        });
-        const tx = tx_1.Transaction.fromTxData(txData, { common });
-        const signedTx = tx.sign(key);
-        return signedTx.serialize();
-    }
 }
 exports.ArbWeb3Client = ArbWeb3Client;