dequanto 0.0.1

package/src/clients/utils/ClientEndpoints.ts

@@ -0,0 +1,26 @@
+import { IWeb3EndpointOptions } from '../interfaces/IWeb3EndpointOptions';
+
+export namespace ClientEndpoints {
+
+    export function filterEndpoints (endpoints, opts: IWeb3EndpointOptions) {
+        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;
+        })
+    }
+
+}

package/src/clients/utils/ClientErrorUtil.ts

@@ -0,0 +1,26 @@
+
+
+export namespace ClientErrorUtil {
+    export function isConnectionFailed (error: Error & { code?, reason? }) {
+        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;
+    }
+    export function isAlreadyKnown (error: Error & { code?, reason? }) {
+        return /already known/i.test(error.message);
+    }
+
+    export function IsInsufficientFunds (error: Error) {
+        // @TODO - is there a future proof way to check for the error?
+        return /insufficient funds/i.test(error.message);
+    }
+
+    export function IsNonceTooLow(error: Error) {
+        return /nonce too low/i.test(error.message);
+    }
+}

package/src/clients/utils/TxFactory.ts

@@ -0,0 +1,17 @@
+import {
+    FeeMarketEIP1559Transaction,
+    Transaction,
+    TxData,
+    FeeMarketEIP1559TxData,
+    TxOptions
+} from '@ethereumjs/tx';
+
+export namespace TxFactory {
+    export function fromTxData (txData: TxData | FeeMarketEIP1559TxData, opts?: TxOptions) {
+        const Factory = txData.type && Number(txData.type) === 2
+            ? FeeMarketEIP1559Transaction
+            : Transaction
+
+        return Factory.fromTxData(txData as any, opts);
+    }
+}

package/src/contracts/BscContract.ts

@@ -0,0 +1,28 @@
+import di from 'a-di'
+import { BscWeb3Client } from '@dequanto/clients/BscWeb3Client'
+import { ContractReader } from './ContractReader'
+import { Bscscan } from '@dequanto/BlockchainExplorer/Bscscan'
+import { Contract, IContractInit } from './Contract'
+import { ContractProvider } from './ContractProvider'
+
+export class BscContract extends Contract {
+
+    public client = di.resolve(BscWeb3Client);
+    public explorer = di.resolve(Bscscan);
+    public runner = di.resolve(ContractReader, this.client);
+    public provider = di.resolve(ContractProvider, this.explorer);
+
+    static async create (name: string, opts?: IContractInit): Promise<BscContract>
+    static async create (address: string, opts?: IContractInit): Promise<BscContract>
+    static async create (mix: string, opts?: IContractInit): Promise<BscContract> {
+
+        let explorer = di.resolve(Bscscan);
+        return Contract.create<BscContract>(mix, {
+
+            Ctor: BscContract,
+            explorer,
+
+            ...(opts ?? {})
+        });
+    }
+}

package/src/contracts/Contract.ts

@@ -0,0 +1,126 @@
+import di from 'a-di'
+import alot from 'alot'
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer'
+import { IContractDetails } from '@dequanto/models/IContractDetails'
+import { ContractProvider, IContractProvider } from './ContractProvider'
+import { IContractReader } from './ContractReader'
+
+import { Transaction, TransactionReceipt } from 'web3-core';
+import { utils } from 'ethers'
+import { ITransactionDetails } from '@dequanto/models/ITransactionDetails'
+import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder'
+import { TxWriter } from '@dequanto/txs/TxWriter'
+import { Web3Client } from '@dequanto/clients/Web3Client'
+import { $contract } from '@dequanto/utils/$contract'
+import { ChainAccount } from '@dequanto/ChainAccounts'
+
+export interface IContractInit {
+    Ctor?:  new (...args) => any
+    explorer?: IBlockChainExplorer
+    client?: Web3Client
+
+    refAbi?: string
+}
+
+export abstract class Contract {
+    name: string = null
+    address: string = null
+    proxyImpl: string = null
+    refAbi: string = null
+    abi: string = null
+
+    opts: IContractInit
+
+    protected abstract client: Web3Client
+    protected abstract runner: IContractReader
+    protected abstract provider: IContractProvider
+    protected abstract explorer: IBlockChainExplorer
+
+    constructor (data: Partial<IContractDetails>, opts: IContractInit) {
+        this.name = data.name;
+        this.address = data.address;
+        this.proxyImpl = data.proxy;
+        this.refAbi = data.refAbi;
+        this.abi = data.abi;
+        this.opts = opts;
+    }
+
+    readAsync<T = any>(methodAbi: string, ...params): Promise<T> {
+        return this.runner.readAsync(this.address, methodAbi, ...params);
+    }
+
+    async writeAsyncWithAccount<T = any>(account: ChainAccount, interfaceAbi: string, ...params): Promise<TxWriter> {
+
+        let txBuilder = new TxDataBuilder(this.client, account, {
+            to: this.address
+        });
+
+        txBuilder.setInputDataWithABI(interfaceAbi, ...params);
+        await Promise.all([
+            txBuilder.setGas(),
+            txBuilder.setNonce(),
+        ]);
+
+        return TxWriter.write(this.client, txBuilder, account);
+    }
+
+    async getTransactionsFor (address: string, opts?: { decode?: boolean }): Promise<ITransactionDetails[]> {
+        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: Transaction): Promise<ITransactionDetails> {
+        const abiAddress = this.refAbi
+            ?? this.proxyImpl
+            ?? this.address
+            ?? tx.to;
+
+        const abi = this.abi ?? await this.provider.getAbi(abiAddress);
+        const inter = new utils.Interface(abi);
+        const decodedInput = inter.parseTransaction({
+            data: tx.input,
+            value: tx.value,
+        });
+
+
+
+        return {
+            ...tx,
+            details: {
+                name: decodedInput.name,
+                args: $contract.normalizeArgs(Array.from(decodedInput.args))
+            }
+        };
+    }
+
+    async parseTrasactions (arr: Transaction[]): Promise<ITransactionDetails[]> {
+        return await alot(arr).mapAsync(async tx => {
+            return await this.parseTrasaction(tx);
+        }).toArrayAsync();
+    }
+
+
+
+
+    protected static async create<T extends Contract> (mix: string, opts?: IContractInit): Promise<T> {
+        let provider = di.resolve(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 = <any> { address: mix };
+        }
+
+        return new opts.Ctor({
+            refAbi: opts.refAbi,
+            ...info,
+        }, opts);
+    }
+}

package/src/contracts/ContractBase.ts

@@ -0,0 +1,158 @@
+import di from 'a-di';
+import memd from 'memd';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import type { Web3Client } from '@dequanto/clients/Web3Client';
+import { TAddress } from '@dequanto/models/TAddress';
+import { ContractReader } from './ContractReader';
+import { ContractWriter } from './ContractWriter';
+import { AbiItem } from 'web3-utils';
+import type { ITxWriterOptions, TxWriter } from '@dequanto/txs/TxWriter';
+import { $contract } from '@dequanto/utils/$contract';
+import { utils } from 'ethers'
+import { ContractStream } from './ContractStream';
+import { TransactionReceipt } from 'web3-core';
+import { ITxConfig } from '@dequanto/txs/ITxConfig';
+import type { BufferLike } from 'ethereumjs-util';
+import { TxTopicInMemoryProvider } from '@dequanto/txs/receipt/TxTopicInMemoryProvider';
+import { $class } from '@dequanto/utils/$class';
+
+
+export abstract class ContractBase {
+    private blockNumber?: number;
+    private blockDate?: Date;
+
+    /** 1.4 for medium*/
+    private gasPriorityFee?: number
+    private builderConfig?: ITxConfig;
+    private writerConfig?: ITxWriterOptions;
+
+    abstract abi?: any
+
+    constructor (
+        public address: TAddress,
+        public client: Web3Client,
+        public explorer: IBlockChainExplorer
+    ) {
+
+    }
+
+    public async getStorageAt (position: string | number | bigint)  {
+        let reader = await this.getContractReader();
+        return reader.getStorageAt(this.address, position);
+    }
+    public parseInputData (buffer: string | BufferLike, value?: string) {
+        const inter = new utils.Interface(this.abi);
+        const decodedInput = inter.parseTransaction({
+            data: buffer as string,
+            value: value,
+        });
+        console.log("decodedInput", decodedInput);
+        return {
+            name: decodedInput.name,
+            args: $contract.normalizeArgs(Array.from(decodedInput.args))
+        };
+    }
+
+    public $config (builderConfig?: ITxConfig, writerConfig?: ITxWriterOptions): this {
+        let $contract = $class.curry(this, {
+            builderConfig: builderConfig,
+            writerConfig: writerConfig,
+        });
+        return $contract;
+    }
+
+    public forBlock (mix: number | undefined | Date): this {
+        if (typeof mix === 'undefined' || typeof mix === 'number') {
+            return this.forBlockNumber(mix);
+        }
+        return this.forBlockAt(mix);
+    }
+    protected forBlockNumber (blockNumber: number | undefined): this {
+        let $contract = $class.curry(this, {
+            blockNumber: blockNumber,
+            blockDate: null
+        })
+        return $contract;
+    }
+    protected forBlockAt (date: Date | undefined): this {
+        let $contract = $class.curry(this, {
+            blockNumber: null,
+            blockDate: date
+        })
+        return $contract;
+    }
+
+    protected async $read (abi: string | AbiItem, ...params) {
+        let reader = await this.getContractReader();
+        return reader.readAsync(this.address, abi, ...params);
+    }
+
+    protected $on (event: string, cb) {
+        let stream = this.getContractStream();
+        return stream.on(event, cb);
+    }
+
+
+    protected async $write (abi: string | AbiItem, eoa: { address: TAddress, key: string, value?: number | string | bigint } , ...params): Promise<TxWriter> {
+
+        let writer = await this.getContractWriter();
+        return writer.writeAsync(eoa, abi, params, {
+            builderConfig: this.builderConfig,
+            writerConfig: this.writerConfig,
+        });
+    }
+
+
+    protected $getAbiItem (type: 'event' | 'function' | 'string', name: string) {
+        return this.abi.find(x => x.type === type && x.name === name);
+    }
+
+    protected $extractLogs (tx: TransactionReceipt, abiItem: AbiItem) {
+        let logs = $contract.extractLogsForAbi(tx, abiItem);
+        return logs.map(log => {
+
+            let params = log.arguments.reduce((aggr, arg) => {
+                aggr[arg.name] = arg.value;
+                return aggr;
+            }, {});
+            return {
+                contract: log.contract,
+                arguments: log.arguments,
+                ...params
+            };
+        })
+    }
+
+    private async getContractReader () {
+        let reader = await this.getContractReaderInner();
+        if (this.blockDate != null) {
+            reader.forBlockAt(this.blockDate);
+        }
+        if (this.blockNumber != null) {
+            reader.forBlock(this.blockNumber);
+        }
+        return reader;
+    }
+
+    @memd.deco.memoize({ perInstance: true })
+    private async getContractReaderInner () {
+        let reader = di.resolve(ContractReader, this.client);
+        return reader;
+    }
+
+    @memd.deco.memoize({ perInstance: true })
+    private async getContractWriter () {
+        if (this.abi != null) {
+            let logParser = di.resolve(TxTopicInMemoryProvider);
+            logParser.register(this.abi);
+        }
+        let writer = di.resolve(ContractWriter, this.address, this.client);
+        return writer;
+    }
+
+    @memd.deco.memoize({ perInstance: true })
+    private getContractStream () {
+        let stream = di.resolve(ContractStream, this.address, this.abi, this.client);
+        return stream;
+    }
+}

package/src/contracts/ContractFactory.ts

@@ -0,0 +1,19 @@
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TAddress } from '@dequanto/models/TAddress';
+import { ContractBase } from './ContractBase';
+
+export class ContractWrapped extends ContractBase {
+    abi?: any;
+}
+
+export namespace ContractFactory {
+
+    export async function get (client: Web3Client, explorer: IBlockChainExplorer, contractAddr: TAddress) {
+        let { abi } = await explorer.getContractAbi(contractAddr);
+
+        let contract = new ContractWrapped(contractAddr, client, explorer);
+        contract.abi = JSON.parse(abi);
+        return contract;
+    }
+}

package/src/contracts/ContractProvider.ts

@@ -0,0 +1,55 @@
+import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { IContractDetails } from '@dequanto/models/IContractDetails';
+import { TAddress } from '@dequanto/models/TAddress';
+import di from 'a-di';
+
+
+interface IContract {
+    address: TAddress
+    abi: string
+    name?: string
+}
+
+export interface IContractProvider {
+    getAbi (address: string): Promise<string>
+    getInfo (address: string): Promise<IContractDetails>
+}
+
+export class ContractProvider implements IContractProvider {
+
+    constructor (public api: IBlockChainExplorer = di.resolve(Etherscan)) {
+
+    }
+
+    async getByName(name: string): Promise<IContract> {
+        let info = this.api.localDb.find(x => x.name === name);
+        let { abi } = await this.api.getContractAbi(info.address);
+
+        return {
+            ...info,
+            abi
+        };
+    }
+
+    async getByAddress (address: string): Promise<IContract> {
+        let info = await this.getInfo(address);
+        if (info == null) {
+            throw new Error(`Contract info not found for ${address}`)
+        }
+        let abi = await this.getAbi(info.address);
+
+        return {
+            ...info,
+            abi
+        };
+    }
+
+    async getAbi (address: string): Promise<string> {
+        let { abi } = await this.api.getContractAbi(address);
+        return abi;
+    }
+    async getInfo (q: string): Promise<IContractDetails> {
+        return this.api.getContractMeta(q);
+    }
+}

package/src/contracts/ContractReader.ts

@@ -0,0 +1,87 @@
+import di from 'a-di';
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
+import { AbiItem } from 'web3-utils';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { $abiParser } from '../utils/$abiParser';
+import { AbiDeserializer } from './utils/AbiDeserializer';
+import { BlockDateResolver } from '@dequanto/blocks/BlockDateResolver';
+import { TAddress } from '@dequanto/models/TAddress';
+
+
+export interface IContractReader {
+    forBlock (blockNumber: number | undefined): IContractReader
+    forBlockAt (date: Date | undefined): IContractReader
+    readAsync<T = any>(address: string, methodAbi: string | AbiItem, ...params: any[]): Promise<T>
+
+}
+export class ContractReader implements IContractReader {
+    private blockNumberTask: Promise<number>;
+
+    constructor(public client: Web3Client = di.resolve(EthWeb3Client)) {
+
+    }
+    forBlock (blockNumber: number | undefined): IContractReader {
+        this.blockNumberTask = blockNumber == null
+            ? null
+            : Promise.resolve(blockNumber);
+        return this;
+    }
+    forBlockAt (date: Date | undefined): IContractReader {
+        if (date != null) {
+            let resolver = new BlockDateResolver(this.client);
+            this.blockNumberTask = resolver.getBlockNumberFor(date);
+        } else {
+            this.blockNumberTask = null;
+        }
+        return this;
+    }
+
+    async getStorageAt(address: TAddress, position: string | number | bigint) {
+        let blockNumber: number = void 0;
+        if (this.blockNumberTask != null) {
+            blockNumber = await this.blockNumberTask;
+        }
+        return this.client.getStorageAt(address, position, blockNumber);
+    }
+
+    async readAsync(address: string, methodAbi: string | AbiItem, ...params: any[]) {
+        let blockNumber: number = void 0;
+        if (this.blockNumberTask != null) {
+            blockNumber = await this.blockNumberTask;
+        }
+
+        let abi: AbiItem;
+        if (typeof methodAbi === 'string') {
+            abi = $abiParser.parseMethod(methodAbi);
+        } else {
+            abi = methodAbi;
+        }
+
+        let method = abi.name;
+        let abiArr = [ abi ];
+
+        try {
+            let result = await this.client.readContract({
+                address,
+                abi: abiArr,
+                method: method,
+                arguments: params,
+                blockNumber: blockNumber,
+            });
+            if (result == null) {
+                throw new Error(`Function call returned undefined`);
+            }
+            return AbiDeserializer.process(result, abi.outputs);
+
+        } catch (error) {
+            let args = params.map((x, i) => `[${i}] ${x}`).join('\n');
+
+            throw new Error(`Contract: ${address} ${methodAbi} with \n${args}\nfailed with ${error.message}`);
+        }
+    }
+
+    static async read (client: Web3Client, address: TAddress, methodAbi: string){
+        let reader = new ContractReader(client);
+        return reader.readAsync(address, methodAbi);
+    }
+}

package/src/contracts/ContractStream.ts

@@ -0,0 +1,18 @@
+import { ClientEventsStream } from '@dequanto/clients/ClientEventsStream';
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TAddress } from '@dequanto/models/TAddress';
+import di from 'a-di';
+
+export class ContractStream  {
+
+    constructor(public address: TAddress, public abi: any, public client: Web3Client = di.resolve(EthWeb3Client)) {
+
+    }
+
+    on(event: string, cb): ClientEventsStream<any> {
+        let stream = this.client.getEventStream(this.address, this.abi, event);
+        return stream.onData(cb);
+    }
+}
+

package/src/contracts/ContractWriter.ts

@@ -0,0 +1,97 @@
+import di from 'a-di';
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
+import { AbiItem } from 'web3-utils';
+import { ITxWriterOptions, TxWriter } from '@dequanto/txs/TxWriter';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
+import { TAddress } from '@dequanto/models/TAddress';
+import { $abiType } from '@dequanto/utils/$abiType';
+import { $abiParser } from '../utils/$abiParser';
+import { ChainAccount } from '@dequanto/ChainAccounts';
+import { ITxConfig } from '@dequanto/txs/ITxConfig';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $logger } from '@dequanto/utils/$logger';
+import { $class } from '@dequanto/utils/$class';
+
+interface IChainAccountSender extends ChainAccount {
+    value?: number | string | bigint
+}
+
+export interface IContractWriter {
+    writeAsync <T = any> (eoa: { address?: string, key: string }, methodAbi: string | AbiItem, ...params: any[]): Promise<TxWriter>
+}
+
+export class ContractWriter implements IContractWriter {
+
+    protected builderConfig?: ITxConfig;
+    protected writerConfig?: ITxWriterOptions;
+
+
+    constructor(public address: TAddress, public client: Web3Client = di.resolve(EthWeb3Client)) {
+
+    }
+
+    $config (builderConfig?: ITxConfig, writerConfig?: ITxWriterOptions): this {
+        return $class.curry(this, {
+            builderConfig: builderConfig ?? this.builderConfig,
+            writerConfig: writerConfig ?? this.writerConfig,
+        });
+    }
+
+    async writeAsync<T = any>(
+        eoa: IChainAccountSender,
+        interfaceAbi: string | AbiItem,
+        params: any[],
+        configs?: {
+            builderConfig?: ITxConfig
+            writerConfig?: ITxWriterOptions
+        }
+    ): Promise<TxWriter> {
+
+        let txBuilder = new TxDataBuilder(this.client, eoa, {
+            to: this.address
+        });
+
+        let abi = typeof interfaceAbi === 'string'
+            ? $abiParser.parseMethod(interfaceAbi)
+            : interfaceAbi;
+
+        let builderConfig: ITxConfig = {
+            ...(this.builderConfig ?? {}),
+            ...(configs?.builderConfig ?? {}),
+        };
+
+        txBuilder.setConfig(builderConfig);
+        txBuilder.setValue(eoa.value);
+        txBuilder.setInputDataWithABI(abi, ...params);
+        await Promise.all([
+            txBuilder.setGas({
+                price: builderConfig.gasPrice,
+                priceRatio: builderConfig.gasPriceRatio,
+                gasLimit: builderConfig.gasLimit,
+                gasLimitRatio: builderConfig.gasLimitRatio,
+                gasEstimation: builderConfig.gasEstimation,
+                from: builderConfig.from ?? eoa.address,
+                type: builderConfig.type ?? null,
+            }),
+            txBuilder.setNonce({
+                nonce: builderConfig.nonce,
+                noncePending: builderConfig.noncePending,
+            }),
+        ]);
+
+        console.log(txBuilder.data, eoa, this.address);
+        let writer = TxWriter.write(
+            this.client,
+            txBuilder,
+            eoa,
+            configs?.writerConfig ?? this.writerConfig
+        );
+
+        writer.on('log', message => {
+            $logger.log(`TxContract ${ abi.name}; ${message}`);
+        });
+        return writer;
+    }
+}
+