dequanto 0.0.1

package/src/clients/ClientPoolStats.ts

@@ -0,0 +1,64 @@
+import { TAddress } from '@dequanto/models/TAddress';
+import { $logger } from '@dequanto/utils/$logger';
+import { ClientStatus } from './model/ClientStatus';
+
+
+interface IClientCallLog {
+    url: string
+    time: number
+    error?: Error
+    status: ClientStatus
+}
+
+
+class ClientPoolStatsHandler {
+    calls: IClientCallLog[] = []
+    addCall (log: Partial<IClientCallLog>) {
+        this.calls.push(log as any);
+    }
+
+    log () {
+        $logger.log(this.calls);
+    }
+}
+export class ClientPoolTraceError extends Error {
+
+    static create ($error: Error, trace: ClientPoolTrace) {
+        let traceLog = trace?.toString() ?? '';
+        return {
+            name: $error.name,
+            stack: $error.stack,
+            message:  traceLog + '\n' + $error.message
+        };
+    }
+}
+
+export class ClientPoolTrace {
+
+    action: string
+    calls: IClientCallLog[] = []
+
+    onComplete (log) {
+        this.calls.push(log);
+    }
+
+    toString () {
+        return [
+            `${this.action} using clients:`,
+            ...this.calls.map(call => {
+                return [
+                    `${call.url} ${call.status} ${call.time}ms`,
+                    `${call.error?.message}`
+                ].join('\n');
+            })
+        ].join('\n');
+    }
+
+    static createContractCall (address: TAddress, methodName: string, ...args) {
+        let trace = new ClientPoolTrace();
+        trace.action = `Contact: ${address} ${methodName}(${args.join(', ')})`;
+        return trace;
+    }
+}
+
+export const ClientPoolStats = new ClientPoolStatsHandler();

package/src/clients/EthWeb3Client.ts

@@ -0,0 +1,36 @@
+import { $config } from '@dequanto/utils/$config';
+import { Transaction, TxData } from '@ethereumjs/tx'
+import Common from '@ethereumjs/common'
+import { Web3Client } from './Web3Client';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { IWeb3EndpointOptions } from './interfaces/IWeb3EndpointOptions';
+import { ClientEndpoints } from './utils/ClientEndpoints';
+
+export class EthWeb3Client extends Web3Client {
+
+    platform: TPlatform = 'eth'
+    chainId: number = 1;
+    chainToken = 'ETH';
+    TIMEOUT: number = 15 * 60 * 1000;
+    defaultGasLimit = 2_000_000
+
+
+    constructor (opts?: IWeb3EndpointOptions) {
+        super(ClientEndpoints.filterEndpoints($config.get('web3.eth.endpoints'), opts));
+
+        //let host = `192.168.1.220`;
+        // let host = `localhost`;
+        // this.web3 = new Web3(`ws://${host}:8546`);
+        // this.eth = this.web3.eth;
+    }
+    sign(txData: TxData, privateKey: string): Buffer {
+
+        const key = Buffer.from(privateKey, 'hex');
+        const common = new Common({
+            chain: 'mainnet'
+        })
+        const tx = Transaction.fromTxData(txData, { common });
+        const signedTx = tx.sign(key);
+        return signedTx.serialize();
+    }
+}

package/src/clients/HardhatWeb3Client.ts

@@ -0,0 +1,60 @@
+import Common from '@ethereumjs/common'
+import { $config } from '@dequanto/utils/$config';
+import { TxData } from '@ethereumjs/tx'
+import { Web3Client } from './Web3Client';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { IWeb3EndpointOptions } from './interfaces/IWeb3EndpointOptions';
+import { ClientEndpoints } from './utils/ClientEndpoints';
+import { TxFactory } from './utils/TxFactory';
+
+
+// https://hardhat.org/hardhat-network/reference/
+
+export class HardhatWeb3Client extends Web3Client {
+
+    platform: TPlatform = 'hardhat'
+    chainId: number = 31337
+    chainToken = 'ETH';
+    TIMEOUT: number = 5 * 60 * 1000;
+    defaultGasLimit = 2_000_000
+
+    constructor (opts?: IWeb3EndpointOptions) {
+        super(ClientEndpoints.filterEndpoints($config.get('web3.hardhat.endpoints'), opts));
+    }
+
+    sign(txData: TxData, privateKey: string): Buffer {
+
+        const key = Buffer.from(privateKey, 'hex');
+        const common = new Common({
+            chain: 31337,
+            hardfork: 'london',
+            customChains: [
+                <any> {
+                    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.fromTxData(txData, { common });
+        const signedTx = tx.sign(key);
+        return signedTx.serialize();
+    }
+}

package/src/clients/PolyWeb3Client.ts

@@ -0,0 +1,91 @@
+import Common from '@ethereumjs/common'
+import { $config } from '@dequanto/utils/$config';
+import { FeeMarketEIP1559Transaction, Transaction,  TxData } from '@ethereumjs/tx'
+import { Web3Client } from './Web3Client';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { ClientEndpoints } from './utils/ClientEndpoints';
+import { IWeb3EndpointOptions } from './interfaces/IWeb3EndpointOptions';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { TxFactory } from './utils/TxFactory';
+
+export class PolyWeb3Client extends Web3Client {
+
+
+
+    platform: TPlatform = 'polygon';
+    chainId: number = 137;
+    chainToken = 'MATIC';
+    defaultGasLimit = 2_000_000;
+
+    constructor (opts?: IWeb3EndpointOptions) {
+        super(ClientEndpoints.filterEndpoints($config.get('web3.polygon.endpoints'), opts));
+    }
+
+    async getGasPrice() {
+        let { price, base, priority } = await super.getGasPrice();
+
+        price = $bigint.min(
+            price,
+            $bigint.toWei(60, $bigint.GWEI_DECIMALS)
+        );
+
+        // Use minimum gas price as 15 gwei (network sometimes returns too low fees)
+        let gasPrice = $bigint.max(
+            price,
+            $bigint.toWei(28, $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: TxData, privateKey: string): Buffer {
+
+        const key = Buffer.from(privateKey, 'hex');
+
+        const common = new Common({
+            chain: 137,
+            hardfork: 'london',
+            customChains: [
+                <any> {
+                    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.fromTxData(txData as any, { common });
+        const signedTx = tx.sign(key);
+        return signedTx.serialize();
+    }
+}

package/src/clients/Web3Client.ts

@@ -0,0 +1,228 @@
+import memd from 'memd';
+import Web3 from 'web3';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { TxData } from '@ethereumjs/tx';
+import { BlockHeader, BlockTransactionString, Syncing } from 'web3-eth';
+import { ClientPool, IPoolWeb3Request } from './ClientPool';
+import { ClientPoolTrace } from './ClientPoolStats';
+import { IWeb3Client } from './interfaces/IWeb3Client';
+import { Log, LogsOptions } from 'web3-core';
+import { Subscription } from 'web3-core-subscriptions';
+
+
+export abstract class Web3Client implements IWeb3Client {
+
+    public TIMEOUT = 3 * 60 * 1000;
+
+    abstract platform: TPlatform;
+    abstract chainId: number;
+    abstract chainToken: string;
+    abstract defaultGasLimit: number;
+
+    abstract sign(txData: TxData, privateKey: string): Buffer
+
+
+    private pool = new ClientPool(this.config);
+
+    constructor (public config: { url: string }[] ) {
+
+    }
+
+    getEventStream (address: TAddress, abi: any, event: string) {
+        return this.pool.getEventStream(address, abi, event);
+    }
+
+    with <TResult> (fn: (web3: Web3) => Promise<TResult>) {
+        return this.pool.call(fn);
+    }
+    withSync <TResult> (fn: (web3: Web3) => TResult) {
+        return this.pool.callSync(fn);
+    }
+    async getWeb3 (options?: IPoolWeb3Request) {
+        return await this.pool.getWeb3(options);
+    }
+    async getNodeURL (options?: IPoolWeb3Request) {
+        return await this.pool.getNodeURL(options);
+    }
+
+    subscribe(
+        type: 'logs',
+        options: LogsOptions,
+        callback?: (error: Error, log: Log) => void
+    ): Promise<Subscription<Log>>;
+    subscribe(
+        type: 'syncing',
+        callback?: (error: Error, result: Syncing) => void
+    ): Promise<Subscription<Syncing>>;
+    subscribe(
+        type: 'newBlockHeaders',
+        callback?: (error: Error, blockHeader: BlockHeader) => void
+    ): Promise<Subscription<BlockHeader>>;
+    subscribe(
+        type: 'pendingTransactions',
+        callback?: (error: Error, transactionHash: string) => void
+    ): Promise<Subscription<string>>;
+    async subscribe (...args): Promise<Subscription<any>>{
+        let web3 = await this.getWeb3({ ws: true });
+        return web3.eth.subscribe(...args as Parameters<Web3['eth']['subscribe']>);
+    }
+
+    readContract (data: {
+        address: TAddress,
+        abi: any
+        method: string,
+        arguments?: any[]
+        options?: { from?: string, },
+        blockNumber?: number
+    }) {
+        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: ClientPoolTrace.createContractCall(address, method, params)
+        });
+    }
+
+    encodeParameters (types: any[], paramaters: any[]) {
+        return this.pool.callSync(web3 => {
+            return web3.eth.abi.encodeParameters(types, paramaters);
+        });
+    }
+
+    getBalance (address: TAddress, blockNumber?: number): Promise<bigint> {
+        return this.pool.call(async web3 => {
+            let weiStr = await web3.eth.getBalance(address, blockNumber);
+            return BigInt(weiStr);
+        });
+    }
+    getTransactionCount(address: TAddress, type?: 'pending' | string) {
+        return this.pool.call(web3 => {
+            return web3.eth.getTransactionCount(address, type);
+        });
+    }
+    isSyncing () {
+        return this.pool.call(web3 => {
+            return web3.eth.isSyncing();
+        });
+    }
+    getTransaction (txHash: TAddress, opts?: IPoolWeb3Request) {
+        return this.pool.call(web3 => {
+            return web3.eth.getTransaction(txHash);
+        }, opts);
+    }
+    getTransactionReceipt (txHash: TAddress) {
+        return this.pool.call(web3 => {
+            return web3.eth.getTransactionReceipt(txHash);
+        });
+    }
+    getBlock (nr: number): Promise<BlockTransactionString> {
+        return this.pool.call(web3 => {
+            return web3.eth.getBlock(nr);
+        });
+    }
+    getPendingTransactions () {
+        return this.pool.call(web3 => {
+            return web3.eth.getPendingTransactions();
+        });
+    }
+    getPoolStatus(): Promise<{ baseFee: bigint, pending: number, queued: number }> {
+        return this.pool.call(async web3 => {
+            let eth = web3.eth as any;
+            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: TAddress, position: string | number | bigint, blockNumber?: number) {
+        return this.pool.call(web3 => {
+            return web3.eth.getStorageAt(address, <any> position, blockNumber);
+        });
+    }
+    getGasPrice (): Promise<{ price: bigint, base?: bigint, priority?: bigint }> {
+        return this.pool.call(web3 => {
+            return web3.eth.getGasPrice().then(x => {
+                return {
+                    price: BigInt(x)
+                };
+            });
+        });
+    }
+    getGasEstimation (from: TAddress, tx: TxData) {
+        return this.pool.call(async web3 => {
+            let txData = {
+                from: from,
+                to: tx.to as string,
+                value: tx.value as any,
+                data: tx.data as any,
+                nonce: tx.nonce as any,
+            };
+            let gasAmount = await web3.eth.estimateGas(txData);
+            return gasAmount;
+        })
+    }
+
+    sendSignedTransaction(signedTxBuffer: string) {
+        return this.pool.callPromiEvent(web3 => {
+            return web3.eth.sendSignedTransaction(signedTxBuffer);
+        }, { preferSafe: true, distinct: true });
+    }
+
+    getBlockNumber () {
+        return this.pool.call(web3 => {
+            return web3.eth.getBlockNumber();
+        });
+    }
+
+    @memd.deco.memoize({ maxAge: 30 })
+    getBlockNumberCached () {
+        return this.pool.call(web3 => {
+            return web3.eth.getBlockNumber();
+        });
+    }
+
+    getNodeInfos () {
+        return this.pool.getNodeInfos();
+    }
+    getNodeStats () {
+        return this.pool.getNodeStats();
+    }
+
+    static url<T extends Web3Client> (url: string): T {
+        const Ctor: any = this;
+        return new Ctor({
+            endpoints: [
+                { url }
+            ],
+        });
+    }
+}

package/src/clients/Web3ClientFactory.ts

@@ -0,0 +1,28 @@
+import di from 'a-di';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { BscWeb3Client } from './BscWeb3Client';
+import { EthWeb3Client } from './EthWeb3Client';
+import { IWeb3EndpointOptions } from './interfaces/IWeb3EndpointOptions';
+import { PolyWeb3Client } from './PolyWeb3Client';
+import { ArbWeb3Client } from '@dequanto/chains/arbitrum/ArbWeb3Client';
+import { XDaiWeb3Client } from '@dequanto/chains/xdai/XDaiWeb3Client';
+
+export namespace Web3ClientFactory {
+
+    export function get (platform: TPlatform, opts?: IWeb3EndpointOptions) {
+        switch (platform) {
+            case 'bsc':
+                return di.resolve(BscWeb3Client, opts);
+            case 'eth':
+                return di.resolve(EthWeb3Client, opts);
+            case 'polygon':
+                return di.resolve(PolyWeb3Client, opts);
+            case 'arbitrum':
+                return di.resolve(ArbWeb3Client, opts);
+            case 'xdai':
+                return di.resolve(XDaiWeb3Client, opts);
+            default:
+                throw new Error(`Unsupported platform ${platform} for web3 client`);
+        }
+    }
+}

package/src/clients/interfaces/IWeb3Client.ts

@@ -0,0 +1,14 @@
+import { TxData } from '@ethereumjs/tx';
+import Web3 from 'web3';
+
+export interface IWeb3Client {
+    platform: string
+    chainId: number
+    defaultGasLimit: number
+
+    // web3: Web3
+    // eth: Web3['eth']
+
+
+    sign (txData: TxData, privateKey: string): Buffer
+}

package/src/clients/interfaces/IWeb3ClientStatus.ts

@@ -0,0 +1,23 @@
+export interface IWeb3ClientStatus {
+    i: number
+    url: string
+
+    status: 'error' | 'live' | 'offline'
+
+    blockNumber: number
+
+    blockNumberBehind: number
+
+    syncing: {
+        currentBlock: number
+        highestBlock: number
+        knownStates: number
+        startingBlock: number
+    }
+
+    peers: number
+
+    error?: Error
+
+    pingMs: number
+}

package/src/clients/interfaces/IWeb3EndpointOptions.ts

@@ -0,0 +1,9 @@
+import { Config } from '@dequanto/Config';
+
+export interface IWeb3EndpointOptions {
+    type?: 'private'
+    safe?: boolean
+    ws?: boolean
+
+    endpoints?: Config['web3']['eth']['endpoints']
+}

package/src/clients/model/ClientStatus.ts

@@ -0,0 +1,5 @@
+export enum ClientStatus {
+    Ok = 200,
+    NetworkError = 500,
+    CallError = 400
+}

package/src/clients/model/PromiEventWrap.ts

@@ -0,0 +1,61 @@
+
+import { class_Dfr, class_EventEmitter, mixin } from 'atma-utils';
+import { PromiEvent } from 'web3-core';
+
+export class PromiEventWrap extends class_Dfr {
+
+    private _events = new class_EventEmitter();
+
+    $source: PromiEvent<any>
+
+    on (event, cb): this {
+
+        if (event !== 'error' && this.$source) {
+            this.bindOn(event);
+        }
+        this._events.on(event, cb);
+        return this;
+    }
+    once (event, cb): this {
+        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: PromiEvent<any>) {
+
+        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);
+            }
+        );
+    }
+
+
+    private bindOn (event) {
+        this.$source.on(event as any, (...args) => {
+            this.emit(event, ...args);
+        });
+    }
+    private bindOnOnce (event) {
+        this.$source.once(event as any, (...args) => {
+            this.emit(event, ...args);
+        });
+    }
+}

package/src/clients/model/SubscriptionWrap.ts

@@ -0,0 +1,53 @@
+
+import { class_Dfr, class_EventEmitter, mixin } from 'atma-utils';
+
+
+export class SubscriptionWrap extends mixin(class_Dfr, class_EventEmitter) {
+
+    private $source
+    private $wrapped = [] as [string, Function][]
+
+    _listeners: { [event: string]: Function[] }
+
+
+
+    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', ())
+    }
+
+
+    private bindOn (event) {
+        let fn = (...args) => {
+            this.emit(event, ...args);
+        };
+        this.$wrapped.push([event, fn]);
+        this.$source.on(event as any, fn);
+    }
+    private unbindAll () {
+        this.$wrapped.forEach(([event, cb]) => {
+            this.$source.off(event, cb);
+        })
+        this.$wrapped = [];
+    }
+
+}