dequanto 0.0.1

package/src/loggers/TxLoggerService.ts

@@ -0,0 +1,146 @@
+import { ChainAccount } from '@dequanto/ChainAccounts';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
+import { IToken } from '@dequanto/models/IToken';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TokenTransferService } from '@dequanto/tokens/TokenTransferService';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $logger } from '@dequanto/utils/$logger';
+import di from 'a-di';
+import { Everlog } from 'everlog';
+import { ILogger } from 'everlog/fs/LoggerFile';
+import { ICsvColumnValue } from 'everlog/model/ICsvColumn';
+import { TransactionReceipt } from 'web3-core';
+
+export class TxLoggerService {
+    logs: ILogger = Everlog.createChannel(this.name, {
+        columns: [
+            {
+                type: 'date',
+                name: 'Date'
+            },
+            {
+                type: 'string',
+                name: 'Action'
+            },
+            {
+                type: 'string',
+                name: 'From'
+            },
+            {
+                type: 'string',
+                name: 'To'
+            },
+            {
+                type: 'string',
+                name: 'Tx',
+            },
+            {
+                type: 'boolean',
+                name: 'Status'
+            },
+            {
+                type: 'number',
+                name: 'Time'
+            },
+            {
+                type: 'number',
+                name: 'Gas Used',
+            },
+            {
+                type: 'number',
+                name: 'Gas Price',
+            }
+        ]
+    });
+
+
+    constructor(public name: string) {
+
+    }
+
+    async logSwapTransaction(tx: TxWriter, swap: {
+        account: ChainAccount
+        fromToken: string | IToken
+        toToken: string | IToken
+        amount?: bigint
+    }) {
+        let service = di.resolve(TokenTransferService, tx.client);
+        let fromAmount = swap.amount ?? await service.getBalance(swap.account.address, swap.fromToken);
+
+        let [ fromToken, toToken ] = await Promise.all([
+            service.getToken(swap.fromToken),
+            service.getToken(swap.toToken),
+        ]);
+
+        let fromSymbol = fromToken.symbol;
+        let toSymbol = toToken.symbol;
+
+        return await this.logTransaction(`Swap`, tx, async receipt => {
+            let toAmount = await service.getReceived(receipt);
+
+            let fromAmountEth = $bigint.toEther(fromAmount, fromToken.decimals);
+            let toAmountEth = $bigint.toEther(toAmount, toToken.decimals);
+
+            $logger.log(`Swapped ${fromAmountEth}${fromSymbol} → ${toAmountEth}${toSymbol}`);
+
+            return [
+                { name: 'Tokens-Out', value: `${fromAmountEth}${fromSymbol}` },
+                { name: 'Tokens-In', value: `${toAmountEth}${toSymbol}` },
+            ];
+        });
+    }
+
+    async logTransaction (action: string, tx: TxWriter, onReceipt?: (receipt: TransactionReceipt) => Promise<ICsvColumnValue[]> ) {
+        if (tx == null) {
+            $logger.log(`TxLogger - Tx is undefined, possible reason: was not sent`);
+            this.logs.writeRow([
+                new Date(),
+                action
+            ]);
+            return;
+        }
+
+        let txData = tx.builder.data;
+        let gasPrice = 0n; //BigInt((txData.gasPrice) as string);
+        $logger.log(`TxLogger - Tx for action: ${action}; GasPrice: ${ gasPrice }`);
+
+        tx.on('log', message => {
+            $logger.log(`Tx ${tx.client.platform}:`, message);
+        });
+
+        this.logs.writeRow([
+            new Date(),
+            action,
+            tx.account.name ?? tx.account.address,
+            '',
+            '',
+            '',
+            '',
+            '',
+            gasPrice
+        ]);
+        let started = Date.now();
+        let receipt = await tx.onCompleted;
+        let params = onReceipt ? await onReceipt(receipt) : [];
+
+        this.logs.writeRow([
+            new Date(),
+            action,
+            tx.account.address,
+            tx.builder.data.to,
+            receipt.transactionHash,
+            receipt.status,
+            Math.round((Date.now() - started) / 1000) + 's',
+            receipt.gasUsed,
+        ], params);
+
+        return receipt;
+    }
+
+    static async log(tx: TxWriter) {
+        let logger = di.resolve(TxLoggerService, 'transactions');
+        return logger.logTransaction('tx', tx);
+    }
+}

package/src/models/IContractDetails.ts

@@ -0,0 +1,8 @@
+export interface IContractDetails {
+    name: string
+    address: string
+    proxy?: string
+    refAbi?: string
+
+    abi?: string
+}

package/src/models/IToken.ts

@@ -0,0 +1,11 @@
+import { TAddress } from '@dequanto/models/TAddress'
+import { TPlatform } from './TPlatform'
+
+export interface IToken {
+    symbol?: string
+    name?: string
+    platform: TPlatform
+    address: TAddress
+    decimals?: number
+    logo?: string
+}

package/src/models/ITokenGlob.ts

@@ -0,0 +1,14 @@
+import { TAddress } from '@dequanto/models/TAddress'
+import { TPlatform } from '@dequanto/models/TPlatform'
+
+export class ITokenGlob {
+    symbol: string
+    name: string
+    logo?: string
+
+    platforms: {
+        platform: TPlatform
+        address: TAddress
+        decimals: number
+    }[]
+}

package/src/models/ITransactionDetails.ts

@@ -0,0 +1,11 @@
+import { TransactionDescription } from 'ethers/lib/utils';
+import { Transaction } from 'web3-core';
+
+
+export interface ITransactionDetails extends Transaction {
+    isError?: '1' | string
+    details?: {
+        name: string
+        args: any[]
+    }
+}

package/src/models/TAddress.ts

@@ -0,0 +1 @@
+export type TAddress = string;

package/src/models/TBufferLike.ts

@@ -0,0 +1,2 @@
+export declare type TBufferLike = Buffer | Uint8Array | number[] | number | TPrefixedHexString;
+export declare type TPrefixedHexString = string;

package/src/models/THex.ts

@@ -0,0 +1 @@
+export type THex = string

package/src/models/TPlatform.ts

@@ -0,0 +1 @@
+export type TPlatform = 'eth' | 'bsc' | 'polygon' | 'arbitrum' | 'xdai' | 'boba' | 'hardhat';

package/src/models/TResult.ts

@@ -0,0 +1,6 @@
+
+export type TResult<T> = {
+    error?: Error
+    result?: T
+}
+export type TResultAsync<T> = Promise<TResult<T>>;

package/src/ns/NameService.ts

@@ -0,0 +1,21 @@
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { $require } from '@dequanto/utils/$require';
+import { EnsProvider } from './providers/EnsProvider';
+import { INsProvider } from './providers/INsProvider';
+
+export class NameService {
+
+    providers: INsProvider[] = [
+        new EnsProvider(this.client)
+    ];
+
+    constructor(public client: Web3Client) {
+
+    }
+
+    getAddress (domain: string) {
+        let provider = this.providers.find(x => x.supports(domain));
+        $require.notNull(provider, `NS Provider for ${domain} not found`);
+        return provider.getAddress(domain);
+    }
+}

package/src/ns/providers/EnsProvider.ts

@@ -0,0 +1,45 @@
+
+import di from 'a-di';
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
+import { ContractReader } from '@dequanto/contracts/ContractReader';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TBufferLike } from '@dequanto/models/TBufferLike';
+import { $config } from '@dequanto/utils/$config';
+import { $require } from '@dequanto/utils/$require';
+import { INsProvider } from './INsProvider';
+import { $ns } from '../utils/$ns';
+
+export class EnsProvider implements INsProvider {
+
+    constructor (public client = di.resolve(EthWeb3Client)) {
+
+    }
+
+    supports (domain: string) {
+        return /\.eth$/.test(domain);
+    }
+
+    async getAddress(domain: string): Promise<TAddress> {
+        let hash = $ns.namehash(domain);
+        let resolverAddr = await this.getResolverAddress(hash);
+        let address = await this.resolveAddress(hash, resolverAddr);
+        return address;
+    }
+
+    private async resolveAddress (hash: TBufferLike, resolverAddr: TAddress) {
+        let registryAddr = $config.get('ns.ens.registry');
+        $require.Address(registryAddr);
+
+        let reader = new ContractReader(this.client);
+        let address = await reader.readAsync(resolverAddr, `addr(bytes32):address`, hash);
+        return address;
+    }
+    private async getResolverAddress (hash: TBufferLike): Promise<TAddress> {
+        let registryAddr = $config.get('ns.ens.registry');
+        $require.Address(registryAddr);
+
+        let reader = new ContractReader(this.client);
+        let address = await reader.readAsync(registryAddr, `resolver(bytes32):address`, hash);
+        return address;
+    }
+}

package/src/ns/providers/INsProvider.ts

@@ -0,0 +1,6 @@
+import { TAddress } from '@dequanto/models/TAddress'
+
+export interface INsProvider {
+    supports (domain: string): boolean
+    getAddress (domain: string): Promise<TAddress>
+}

package/src/ns/providers/UDProvider.ts

@@ -0,0 +1,49 @@
+
+import di from 'a-di';
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
+import { ContractReader } from '@dequanto/contracts/ContractReader';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TBufferLike } from '@dequanto/models/TBufferLike';
+import { $config } from '@dequanto/utils/$config';
+import { $require } from '@dequanto/utils/$require';
+import { INsProvider } from './INsProvider';
+import { $ns } from '../utils/$ns';
+
+export class UDProvider implements INsProvider {
+
+    constructor (public client = di.resolve(EthWeb3Client)) {
+
+    }
+
+    supports (domain: string) {
+        return /\.(x|crypto|coin|wallet|bitcoin|888|nft|dao|zil|blockchain)$/.test(domain);
+    }
+
+    async getAddress(domain: string): Promise<TAddress> {
+        let hash = $ns.namehash(domain);
+        let resolverAddr = await this.getResolverAddress(hash);
+        let address = await this.resolveAddress(hash, resolverAddr);
+        return address;
+    }
+
+    private async resolveAddress (hash: TBufferLike, resolverAddr: TAddress) {
+
+
+        let reader = new ContractReader(this.client);
+        let data = await reader.readAsync(
+            resolverAddr,
+            `getData(string[] keys, uint256 tokenId):(address,address,string[])`,
+            ['crypto.ETH.address'],
+            hash
+        );
+        let info = data[2];
+        return info[0];
+    }
+    private async getResolverAddress (hash: TBufferLike): Promise<TAddress> {
+        let platform = this.client.platform;
+        let registryAddr = $config.get(`ns.ud.${platform}.registry`);
+        $require.Address(registryAddr);
+
+        return registryAddr;
+    }
+}

package/src/ns/utils/$ns.ts

@@ -0,0 +1,15 @@
+import { keccak256 } from 'web3-utils';
+
+
+export namespace $ns {
+    export function namehash(domain: string) {
+        let labels = domain.toLowerCase().split('.');
+        let node = '0x' + ''.padStart(64,'0');
+        for(let i = labels.length - 1; i >= 0; i--) {
+            let labelSha = keccak256(labels[i]).substring(2);
+
+            node = keccak256(`${node}${labelSha}`);
+        }
+        return node;
+    }
+}

package/src/structs/PackedRanges.spec.ts

@@ -0,0 +1,38 @@
+import { PackedRanges } from './PackedRanges';
+
+UTest({
+    'adding numbers' () {
+        let tracker = new PackedRanges({
+            ranges: [[1,100]]
+        });
+
+        tracker.add(101);
+        deepEq_(tracker.ranges, [[1, 101]])
+
+        tracker.ranges = [[5,100]];
+        tracker.add(4);
+        deepEq_(tracker.ranges, [[4, 100]])
+
+        tracker.ranges = [[1,100]];
+        tracker.add(102);
+        deepEq_(tracker.ranges, [[1, 100], [102,102]]);
+
+        tracker.add(103);
+        deepEq_(tracker.ranges, [[1, 100], [102,103]]);
+
+        tracker.add(101);
+        deepEq_(tracker.ranges, [[1, 101], [102,103]]);
+
+        tracker.add(102);
+        deepEq_(tracker.ranges, [[1, 102], [102,103]]);
+
+        tracker.compact();
+        deepEq_(tracker.ranges, [[1, 103]]);
+
+        eq_(tracker.includes(50), true);
+        eq_(tracker.includes(120), false);
+
+        tracker.remove(89);
+        deepEq_(tracker.ranges, [[1, 88], [90,103]]);
+    }
+})

package/src/structs/PackedRanges.ts

@@ -0,0 +1,207 @@
+import alot from 'alot';
+
+/**
+ *  Allows in a compact way to add/remove a number to the range; check if number was added.
+ */
+
+export class PackedRanges {
+    private ranges: [number, number][] = [];
+
+    from: number = 0
+    to: number
+
+    constructor(opts?: {
+        from?: number
+        to?: number
+        ranges?: [ number, number ][]
+    }) {
+
+        if (opts != null) {
+            this.to = opts.to;
+            this.from = opts.from ?? opts.ranges?.[0]?.[0] ?? this.from;
+            this.ranges = opts.ranges ?? [];
+        }
+    }
+
+    total () {
+        let min = this.from;
+        let max = this.to ?? this.getMax();
+        if (min == null || max == null) {
+            return Infinity;
+        }
+        return max - min;
+    }
+    totalAdded () {
+        let count = 0;
+        for (let i = 0; i < this.ranges.length; i++) {
+            let [min, max] = this.ranges[i];
+            count += max - min + 1;
+        }
+        return count;
+    }
+    totalLeft () {
+        return this.total() - this.totalAdded();
+    }
+
+
+    next(): number {
+        let min = this.from;
+        if (this.ranges.length === 0) {
+            let x = min;
+            this.ranges.push([x, x]);
+            return x;
+        }
+        let [r0Min, r0Max] = this.ranges[0];
+        if (min < r0Min) {
+            this.add(min);
+            return min;
+        }
+        while (this.ranges.length > 1) {
+            let [r1Min, r1Max] = this.ranges[1];
+
+            let next = r0Max + 1;
+            if (next < r1Min) {
+                this.ranges[0][1] = next;
+                return next;
+            }
+            if (next === r1Min) {
+                this.ranges[0][1] = r1Max;
+                this.ranges.splice(1, 1);
+                continue;
+            }
+            throw new Error(`Unsorted ranges r0Max: ${r0Max}, r1Min: ${r1Min}`);
+        }
+
+        r0Max = this.ranges[0][1] + 1;
+
+        if (this.to != null && r0Max >= this.to) {
+            return null;
+        }
+
+        this.ranges[0][1] = r0Max;
+        return r0Max;
+    }
+
+    getMax() {
+        if (this.ranges.length === 0) {
+            return null;
+        }
+        let r = this.ranges[this.ranges.length - 1];
+        return r[1];
+    }
+
+    includes(nr: number) {
+        for (let i = 0; i < this.ranges.length; i++) {
+            let [a, b] = this.ranges[i];
+            if (a <= nr && nr <= b) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    add(nr: number) {
+        let modified = false;
+        for (let i = 0; i < this.ranges.length; i++) {
+            let [a, b] = this.ranges[i];
+            if (a <= nr && nr <= b) {
+                return false;
+            }
+            if (a - 1 === nr) {
+                this.ranges[i][0] = nr;
+                modified = true;
+                break;
+            }
+            if (b + 1 === nr) {
+                this.ranges[i][1] = nr;
+                modified = true;
+                break;
+            }
+        }
+        if (modified === false) {
+            // insert
+            let arr = [nr, nr] as [number, number];
+            let inserted = false;
+            for (let i = 0; i < this.ranges.length; i++) {
+                let [a] = this.ranges[i];
+                if (nr < a) {
+                    this.ranges.splice(i, 0, arr);
+                    inserted = true;
+                    break;
+                }
+            }
+            if (inserted === false) {
+                this.ranges.push(arr);
+            }
+        }
+        return true;
+    }
+    remove (nr: number) {
+        for (let i = 0; i < this.ranges.length; i++) {
+            let [min, max] = this.ranges[i];
+            if (min <= nr && nr <= max) {
+
+                if (min === max) {
+                    this.ranges.splice(i, 1);
+                    return true;
+                }
+                if (min === nr) {
+                    this.ranges[i][0] = min + 1;
+                    return true;
+                }
+                if (max === nr) {
+                    this.ranges[i][1] = max - 1;
+                    return true;
+                }
+
+                let arr1 = [min, nr - 1] as [ number, number];
+                let arr2 = [nr + 1, max] as [ number, number];
+                this.ranges.splice(i, 1, arr1, arr2);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    compact() {
+        for (let i = 0; i < this.ranges.length; i++) {
+            let rangeA = this.ranges[i];
+            for (let j = i + 1; j < this.ranges.length; j++) {
+                let rangeB = this.ranges[j];
+                if (Ranges.overlaps(rangeA, rangeB)) {
+                    let [x1, y1] = rangeA;
+                    let [x2, y2] = rangeB;
+
+                    this.ranges[i] = [Math.min(x1, x2), Math.max(y1, y2)];
+                    this.ranges.splice(j, 1);
+                    j--;
+                    continue;
+                }
+            }
+        }
+
+        this.ranges = alot(this.ranges)
+            .sortBy(([x]) => x)
+            .toArray();
+    }
+
+    set(ranges: [number, number][]) {
+        this.ranges = ranges;
+        this.compact();
+    }
+    serialize() {
+        return JSON.stringify(this.ranges);
+    }
+}
+
+
+
+namespace Ranges {
+    export function overlaps (r1: [number, number], r2: [number, number]) {
+        let [x1, y1] = r1;
+        let [x2, y2] = r2;
+        let d = Math.min(y1, y2) - Math.max(x1, x2);
+
+        return d > -1;
+    }
+}