dequanto 0.0.1

package/dist/src/clients/HardhatWeb3Client.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HardhatWeb3Client = void 0;
+const common_1 = __importDefault(require("@ethereumjs/common"));
+const _config_1 = require("@dequanto/utils/$config");
+const Web3Client_1 = require("./Web3Client");
+const ClientEndpoints_1 = require("./utils/ClientEndpoints");
+const TxFactory_1 = require("./utils/TxFactory");
+// https://hardhat.org/hardhat-network/reference/
+class HardhatWeb3Client extends Web3Client_1.Web3Client {
+    constructor(opts) {
+        super(ClientEndpoints_1.ClientEndpoints.filterEndpoints(_config_1.$config.get('web3.hardhat.endpoints'), opts));
+        this.platform = 'hardhat';
+        this.chainId = 31337;
+        this.chainToken = 'ETH';
+        this.TIMEOUT = 5 * 60 * 1000;
+        this.defaultGasLimit = 2000000;
+    }
+    sign(txData, privateKey) {
+        const key = Buffer.from(privateKey, 'hex');
+        const common = new common_1.default({
+            chain: 31337,
+            hardfork: 'london',
+            customChains: [
+                {
+                    chainId: 31337,
+                    url: 'http://127.0.0.1:8545/',
+                    name: 'ETH',
+                    comment: '',
+                    hardforks: [
+                        {
+                            name: 'london',
+                            block: 0
+                        }
+                    ],
+                    genesis: {
+                        hash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+                        timestamp: '0x5ED20F84',
+                        difficulty: 0x1,
+                        gasLimit: 0x989680,
+                        nonce: '0x0',
+                        stateRoot: '',
+                        extraData: '',
+                    }
+                }
+            ]
+        });
+        const tx = TxFactory_1.TxFactory.fromTxData(txData, { common });
+        const signedTx = tx.sign(key);
+        return signedTx.serialize();
+    }
+}
+exports.HardhatWeb3Client = HardhatWeb3Client;

package/dist/src/clients/PolyWeb3Client.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolyWeb3Client = void 0;
+const common_1 = __importDefault(require("@ethereumjs/common"));
+const _config_1 = require("@dequanto/utils/$config");
+const Web3Client_1 = require("./Web3Client");
+const ClientEndpoints_1 = require("./utils/ClientEndpoints");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const TxFactory_1 = require("./utils/TxFactory");
+class PolyWeb3Client extends Web3Client_1.Web3Client {
+    constructor(opts) {
+        super(ClientEndpoints_1.ClientEndpoints.filterEndpoints(_config_1.$config.get('web3.polygon.endpoints'), opts));
+        this.platform = 'polygon';
+        this.chainId = 137;
+        this.chainToken = 'MATIC';
+        this.defaultGasLimit = 2000000;
+    }
+    async getGasPrice() {
+        let { price, base, priority } = await super.getGasPrice();
+        price = _bigint_1.$bigint.min(price, _bigint_1.$bigint.toWei(60, _bigint_1.$bigint.GWEI_DECIMALS));
+        // Use minimum gas price as 15 gwei (network sometimes returns too low fees)
+        let gasPrice = _bigint_1.$bigint.max(price, _bigint_1.$bigint.toWei(28, _bigint_1.$bigint.GWEI_DECIMALS));
+        return {
+            price: gasPrice,
+            base: gasPrice,
+            priority: gasPrice
+        };
+    }
+    // https://raw.githubusercontent.com/maticnetwork/launch/master/mainnet-v1/sentry/sentry/bor/genesis.json
+    // https://raw.githubusercontent.com/maticnetwork/launch/master/mainnet-v1/sentry/sentry/heimdall/config/genesis.json
+    sign(txData, privateKey) {
+        const key = Buffer.from(privateKey, 'hex');
+        const common = new common_1.default({
+            chain: 137,
+            hardfork: 'london',
+            customChains: [
+                {
+                    chainId: 137,
+                    networkId: 137,
+                    url: 'https://rpc-mainnet.maticvigil.com',
+                    name: 'MATIC',
+                    comment: '',
+                    hardforks: [
+                        {
+                            name: "spuriousDragon",
+                            block: 0
+                        },
+                        {
+                            name: 'berlin',
+                            block: 14750000
+                        },
+                        {
+                            name: 'london',
+                            block: 23850000
+                        }
+                    ],
+                    genesis: {
+                        hash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+                        timestamp: '0x5ED20F84',
+                        difficulty: 0x1,
+                        gasLimit: 0x989680,
+                        nonce: '0x0',
+                        stateRoot: '',
+                        extraData: '',
+                    }
+                }
+            ]
+        });
+        const tx = TxFactory_1.TxFactory.fromTxData(txData, { common });
+        const signedTx = tx.sign(key);
+        return signedTx.serialize();
+    }
+}
+exports.PolyWeb3Client = PolyWeb3Client;

package/dist/src/clients/Web3Client.js

@@ -0,0 +1,186 @@
+"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.Web3Client = void 0;
+const memd_1 = __importDefault(require("memd"));
+const ClientPool_1 = require("./ClientPool");
+const ClientPoolStats_1 = require("./ClientPoolStats");
+class Web3Client {
+    constructor(config) {
+        this.config = config;
+        this.TIMEOUT = 3 * 60 * 1000;
+        this.pool = new ClientPool_1.ClientPool(this.config);
+    }
+    getEventStream(address, abi, event) {
+        return this.pool.getEventStream(address, abi, event);
+    }
+    with(fn) {
+        return this.pool.call(fn);
+    }
+    withSync(fn) {
+        return this.pool.callSync(fn);
+    }
+    async getWeb3(options) {
+        return await this.pool.getWeb3(options);
+    }
+    async getNodeURL(options) {
+        return await this.pool.getNodeURL(options);
+    }
+    async subscribe(...args) {
+        let web3 = await this.getWeb3({ ws: true });
+        return web3.eth.subscribe(...args);
+    }
+    readContract(data) {
+        let { address, method, abi, options, blockNumber, arguments: params } = data;
+        return this.pool.call(async (web3) => {
+            let contract = new web3.eth.Contract(abi, address);
+            let callArgs = [];
+            if (options != null) {
+                callArgs[0] = options;
+            }
+            if (blockNumber != null) {
+                callArgs[0] = null;
+                callArgs[1] = blockNumber;
+            }
+            let result = await contract.methods[method](...params).call(...callArgs);
+            return result;
+        }, {
+            trace: ClientPoolStats_1.ClientPoolTrace.createContractCall(address, method, params)
+        });
+    }
+    encodeParameters(types, paramaters) {
+        return this.pool.callSync(web3 => {
+            return web3.eth.abi.encodeParameters(types, paramaters);
+        });
+    }
+    getBalance(address, blockNumber) {
+        return this.pool.call(async (web3) => {
+            let weiStr = await web3.eth.getBalance(address, blockNumber);
+            return BigInt(weiStr);
+        });
+    }
+    getTransactionCount(address, type) {
+        return this.pool.call(web3 => {
+            return web3.eth.getTransactionCount(address, type);
+        });
+    }
+    isSyncing() {
+        return this.pool.call(web3 => {
+            return web3.eth.isSyncing();
+        });
+    }
+    getTransaction(txHash, opts) {
+        return this.pool.call(web3 => {
+            return web3.eth.getTransaction(txHash);
+        }, opts);
+    }
+    getTransactionReceipt(txHash) {
+        return this.pool.call(web3 => {
+            return web3.eth.getTransactionReceipt(txHash);
+        });
+    }
+    getBlock(nr) {
+        return this.pool.call(web3 => {
+            return web3.eth.getBlock(nr);
+        });
+    }
+    getPendingTransactions() {
+        return this.pool.call(web3 => {
+            return web3.eth.getPendingTransactions();
+        });
+    }
+    getPoolStatus() {
+        return this.pool.call(async (web3) => {
+            let eth = web3.eth;
+            if (eth.txpool == null) {
+                eth.extend({
+                    property: 'txpool',
+                    methods: [{
+                            name: 'content',
+                            call: 'txpool_content'
+                        }, {
+                            name: 'inspect',
+                            call: 'txpool_inspect'
+                        }, {
+                            name: 'status',
+                            call: 'txpool_status'
+                        }]
+                });
+            }
+            let status = await eth.txpool.status();
+            return {
+                baseFee: BigInt(status.baseFee),
+                pending: Number(status.pending),
+                queued: Number(status.queued),
+            };
+        });
+    }
+    getStorageAt(address, position, blockNumber) {
+        return this.pool.call(web3 => {
+            return web3.eth.getStorageAt(address, position, blockNumber);
+        });
+    }
+    getGasPrice() {
+        return this.pool.call(web3 => {
+            return web3.eth.getGasPrice().then(x => {
+                return {
+                    price: BigInt(x)
+                };
+            });
+        });
+    }
+    getGasEstimation(from, tx) {
+        return this.pool.call(async (web3) => {
+            let txData = {
+                from: from,
+                to: tx.to,
+                value: tx.value,
+                data: tx.data,
+                nonce: tx.nonce,
+            };
+            let gasAmount = await web3.eth.estimateGas(txData);
+            return gasAmount;
+        });
+    }
+    sendSignedTransaction(signedTxBuffer) {
+        return this.pool.callPromiEvent(web3 => {
+            return web3.eth.sendSignedTransaction(signedTxBuffer);
+        }, { preferSafe: true, distinct: true });
+    }
+    getBlockNumber() {
+        return this.pool.call(web3 => {
+            return web3.eth.getBlockNumber();
+        });
+    }
+    getBlockNumberCached() {
+        return this.pool.call(web3 => {
+            return web3.eth.getBlockNumber();
+        });
+    }
+    getNodeInfos() {
+        return this.pool.getNodeInfos();
+    }
+    getNodeStats() {
+        return this.pool.getNodeStats();
+    }
+    static url(url) {
+        const Ctor = this;
+        return new Ctor({
+            endpoints: [
+                { url }
+            ],
+        });
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize({ maxAge: 30 })
+], Web3Client.prototype, "getBlockNumberCached", null);
+exports.Web3Client = Web3Client;

package/dist/src/clients/Web3ClientFactory.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Web3ClientFactory = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const BscWeb3Client_1 = require("./BscWeb3Client");
+const EthWeb3Client_1 = require("./EthWeb3Client");
+const PolyWeb3Client_1 = require("./PolyWeb3Client");
+const ArbWeb3Client_1 = require("@dequanto/chains/arbitrum/ArbWeb3Client");
+const XDaiWeb3Client_1 = require("@dequanto/chains/xdai/XDaiWeb3Client");
+var Web3ClientFactory;
+(function (Web3ClientFactory) {
+    function get(platform, opts) {
+        switch (platform) {
+            case 'bsc':
+                return a_di_1.default.resolve(BscWeb3Client_1.BscWeb3Client, opts);
+            case 'eth':
+                return a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client, opts);
+            case 'polygon':
+                return a_di_1.default.resolve(PolyWeb3Client_1.PolyWeb3Client, opts);
+            case 'arbitrum':
+                return a_di_1.default.resolve(ArbWeb3Client_1.ArbWeb3Client, opts);
+            case 'xdai':
+                return a_di_1.default.resolve(XDaiWeb3Client_1.XDaiWeb3Client, opts);
+            default:
+                throw new Error(`Unsupported platform ${platform} for web3 client`);
+        }
+    }
+    Web3ClientFactory.get = get;
+})(Web3ClientFactory = exports.Web3ClientFactory || (exports.Web3ClientFactory = {}));

package/dist/src/clients/interfaces/IWeb3Client.js

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

package/dist/src/clients/interfaces/IWeb3ClientStatus.js

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

package/dist/src/clients/interfaces/IWeb3EndpointOptions.js

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

package/dist/src/clients/model/ClientStatus.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientStatus = void 0;
+var ClientStatus;
+(function (ClientStatus) {
+    ClientStatus[ClientStatus["Ok"] = 200] = "Ok";
+    ClientStatus[ClientStatus["NetworkError"] = 500] = "NetworkError";
+    ClientStatus[ClientStatus["CallError"] = 400] = "CallError";
+})(ClientStatus = exports.ClientStatus || (exports.ClientStatus = {}));

package/dist/src/clients/model/PromiEventWrap.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiEventWrap = void 0;
+const atma_utils_1 = require("atma-utils");
+class PromiEventWrap extends atma_utils_1.class_Dfr {
+    constructor() {
+        super(...arguments);
+        this._events = new atma_utils_1.class_EventEmitter();
+    }
+    on(event, cb) {
+        if (event !== 'error' && this.$source) {
+            this.bindOn(event);
+        }
+        this._events.on(event, cb);
+        return this;
+    }
+    once(event, cb) {
+        if (event !== 'error' && this.$source) {
+            this.bindOnOnce(event);
+        }
+        this._events.once(event, cb);
+        return this;
+    }
+    emit(event, ...args) {
+        this._events.emit(event, ...args);
+    }
+    /** Attach this wrapper to the promievent */
+    bind(promiEvent) {
+        this.$source = promiEvent;
+        for (let event in this._events._listeners) {
+            if (event !== 'error') {
+                this.bindOn(event);
+            }
+        }
+        promiEvent.then(result => {
+            this.resolve(result);
+        }, err => {
+            this.reject(err);
+        });
+    }
+    bindOn(event) {
+        this.$source.on(event, (...args) => {
+            this.emit(event, ...args);
+        });
+    }
+    bindOnOnce(event) {
+        this.$source.once(event, (...args) => {
+            this.emit(event, ...args);
+        });
+    }
+}
+exports.PromiEventWrap = PromiEventWrap;

package/dist/src/clients/model/SubscriptionWrap.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionWrap = void 0;
+const atma_utils_1 = require("atma-utils");
+class SubscriptionWrap extends (0, atma_utils_1.mixin)(atma_utils_1.class_Dfr, atma_utils_1.class_EventEmitter) {
+    constructor() {
+        super(...arguments);
+        this.$wrapped = [];
+    }
+    on(event, cb) {
+        if (event !== 'error' && this.$source) {
+            this.bindOn(event);
+        }
+        return super.on(event, cb);
+    }
+    bind(stream) {
+        if (this.$source) {
+            this.unbindAll();
+        }
+        this.$source = stream;
+        for (let event in this._listeners) {
+            if (event !== 'error') {
+                this.bindOn(event);
+            }
+        }
+        //stream.on('error', ())
+    }
+    bindOn(event) {
+        let fn = (...args) => {
+            this.emit(event, ...args);
+        };
+        this.$wrapped.push([event, fn]);
+        this.$source.on(event, fn);
+    }
+    unbindAll() {
+        this.$wrapped.forEach(([event, cb]) => {
+            this.$source.off(event, cb);
+        });
+        this.$wrapped = [];
+    }
+}
+exports.SubscriptionWrap = SubscriptionWrap;

package/dist/src/clients/utils/ClientEndpoints.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientEndpoints = void 0;
+var ClientEndpoints;
+(function (ClientEndpoints) {
+    function filterEndpoints(endpoints, opts) {
+        if (opts?.endpoints) {
+            endpoints = opts.endpoints;
+        }
+        if (opts == null) {
+            return endpoints;
+        }
+        return endpoints.filter(endpoint => {
+            if (opts.type != null && endpoint.type !== opts.type) {
+                return false;
+            }
+            if (opts.safe != null && endpoint.safe !== opts.safe) {
+                return false;
+            }
+            if (opts.ws === true && endpoint.url.startsWith('ws') === false) {
+                return false;
+            }
+            return true;
+        });
+    }
+    ClientEndpoints.filterEndpoints = filterEndpoints;
+})(ClientEndpoints = exports.ClientEndpoints || (exports.ClientEndpoints = {}));

package/dist/src/clients/utils/ClientErrorUtil.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientErrorUtil = void 0;
+var ClientErrorUtil;
+(function (ClientErrorUtil) {
+    function isConnectionFailed(error) {
+        if (error.code === 1006 || error.reason === 'connection failed') {
+            return true;
+        }
+        let str = error.message;
+        if (str.includes('CONNECTION ERROR') || str.includes('Invalid JSON RPC response') || str.includes('getaddrinfo ENOTFOUND')) {
+            return true;
+        }
+        return false;
+    }
+    ClientErrorUtil.isConnectionFailed = isConnectionFailed;
+    function isAlreadyKnown(error) {
+        return /already known/i.test(error.message);
+    }
+    ClientErrorUtil.isAlreadyKnown = isAlreadyKnown;
+    function IsInsufficientFunds(error) {
+        // @TODO - is there a future proof way to check for the error?
+        return /insufficient funds/i.test(error.message);
+    }
+    ClientErrorUtil.IsInsufficientFunds = IsInsufficientFunds;
+    function IsNonceTooLow(error) {
+        return /nonce too low/i.test(error.message);
+    }
+    ClientErrorUtil.IsNonceTooLow = IsNonceTooLow;
+})(ClientErrorUtil = exports.ClientErrorUtil || (exports.ClientErrorUtil = {}));

package/dist/src/clients/utils/TxFactory.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxFactory = void 0;
+const tx_1 = require("@ethereumjs/tx");
+var TxFactory;
+(function (TxFactory) {
+    function fromTxData(txData, opts) {
+        const Factory = txData.type && Number(txData.type) === 2
+            ? tx_1.FeeMarketEIP1559Transaction
+            : tx_1.Transaction;
+        return Factory.fromTxData(txData, opts);
+    }
+    TxFactory.fromTxData = fromTxData;
+})(TxFactory = exports.TxFactory || (exports.TxFactory = {}));

package/dist/src/contracts/BscContract.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BscContract = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const BscWeb3Client_1 = require("@dequanto/clients/BscWeb3Client");
+const ContractReader_1 = require("./ContractReader");
+const Bscscan_1 = require("@dequanto/BlockchainExplorer/Bscscan");
+const Contract_1 = require("./Contract");
+const ContractProvider_1 = require("./ContractProvider");
+class BscContract extends Contract_1.Contract {
+    constructor() {
+        super(...arguments);
+        this.client = a_di_1.default.resolve(BscWeb3Client_1.BscWeb3Client);
+        this.explorer = a_di_1.default.resolve(Bscscan_1.Bscscan);
+        this.runner = a_di_1.default.resolve(ContractReader_1.ContractReader, this.client);
+        this.provider = a_di_1.default.resolve(ContractProvider_1.ContractProvider, this.explorer);
+    }
+    static async create(mix, opts) {
+        let explorer = a_di_1.default.resolve(Bscscan_1.Bscscan);
+        return Contract_1.Contract.create(mix, {
+            Ctor: BscContract,
+            explorer,
+            ...(opts ?? {})
+        });
+    }
+}
+exports.BscContract = BscContract;

package/dist/src/contracts/Contract.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contract = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const alot_1 = __importDefault(require("alot"));
+const ContractProvider_1 = require("./ContractProvider");
+const ethers_1 = require("ethers");
+const TxDataBuilder_1 = require("@dequanto/txs/TxDataBuilder");
+const TxWriter_1 = require("@dequanto/txs/TxWriter");
+const _contract_1 = require("@dequanto/utils/$contract");
+class Contract {
+    constructor(data, opts) {
+        this.name = null;
+        this.address = null;
+        this.proxyImpl = null;
+        this.refAbi = null;
+        this.abi = null;
+        this.name = data.name;
+        this.address = data.address;
+        this.proxyImpl = data.proxy;
+        this.refAbi = data.refAbi;
+        this.abi = data.abi;
+        this.opts = opts;
+    }
+    readAsync(methodAbi, ...params) {
+        return this.runner.readAsync(this.address, methodAbi, ...params);
+    }
+    async writeAsyncWithAccount(account, interfaceAbi, ...params) {
+        let txBuilder = new TxDataBuilder_1.TxDataBuilder(this.client, account, {
+            to: this.address
+        });
+        txBuilder.setInputDataWithABI(interfaceAbi, ...params);
+        await Promise.all([
+            txBuilder.setGas(),
+            txBuilder.setNonce(),
+        ]);
+        return TxWriter_1.TxWriter.write(this.client, txBuilder, account);
+    }
+    async getTransactionsFor(address, opts) {
+        let txs = await this.explorer.getTransactions(address);
+        txs = txs.filter(x => x.to.toUpperCase() === this.address.toUpperCase());
+        if (opts?.decode) {
+            txs = await this.parseTrasactions(txs);
+        }
+        return txs;
+    }
+    async parseTrasaction(tx) {
+        const abiAddress = this.refAbi
+            ?? this.proxyImpl
+            ?? this.address
+            ?? tx.to;
+        const abi = this.abi ?? await this.provider.getAbi(abiAddress);
+        const inter = new ethers_1.utils.Interface(abi);
+        const decodedInput = inter.parseTransaction({
+            data: tx.input,
+            value: tx.value,
+        });
+        return {
+            ...tx,
+            details: {
+                name: decodedInput.name,
+                args: _contract_1.$contract.normalizeArgs(Array.from(decodedInput.args))
+            }
+        };
+    }
+    async parseTrasactions(arr) {
+        return await (0, alot_1.default)(arr).mapAsync(async (tx) => {
+            return await this.parseTrasaction(tx);
+        }).toArrayAsync();
+    }
+    static async create(mix, opts) {
+        let provider = a_di_1.default.resolve(ContractProvider_1.ContractProvider, opts.explorer);
+        let info = await provider.getInfo(mix);
+        if (info == null) {
+            let byName = mix.startsWith('0x') === false;
+            if (byName) {
+                throw new Error(`Contract by name not found ${mix}`);
+            }
+            info = { address: mix };
+        }
+        return new opts.Ctor({
+            refAbi: opts.refAbi,
+            ...info,
+        }, opts);
+    }
+}
+exports.Contract = Contract;