dequanto 0.0.1

package/src/BlockchainExplorer/Polyscan.ts

@@ -0,0 +1,23 @@
+import di from 'a-di';
+import { BlockChainExplorerFactory } from './BlockChainExplorerFactory';
+import { $config } from '@dequanto/utils/$config';
+import { PolyWeb3Client } from '@dequanto/clients/PolyWeb3Client';
+
+const contracts = $config.get('contracts.polygon', []);
+
+export class Polyscan extends BlockChainExplorerFactory.create({
+    ABI_CACHE: `./cache/poly/abis.json`,
+    CONTRACTS: contracts,
+    getWeb3 () {
+        return di.resolve(PolyWeb3Client)
+    },
+    getConfig () {
+        const config = $config.get('blockchainExplorer.polygon');
+        return {
+            key: config?.key,
+            host: config?.host,
+        };
+    }
+}) {
+
+}

package/src/ChainAccounts.ts

@@ -0,0 +1,72 @@
+import { TAddress } from './models/TAddress'
+import { TPlatform } from './models/TPlatform'
+import { $config } from './utils/$config'
+import { Wallet } from 'ethers';
+import crypto from 'crypto';
+import { $address } from './utils/$address';
+
+
+export class ChainAccount {
+    name?: string
+    address: TAddress
+    key: string
+    platform?: TPlatform
+}
+
+const accounts: {
+    [platform: string]: {
+        [name: string]: ChainAccount
+    }
+} = $config.get('accounts');
+
+export namespace ChainAccountProvider {
+    export function get (platform: TPlatform, name: string): ChainAccount {
+        let acc: ChainAccount = 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;
+    }
+    export function tryGet (mix: string | TAddress, platform?): ChainAccount {
+        let all = this.getAll();
+
+        let accounts = all.filter(x => ($address.eq(mix, x.address) || x.name == mix));
+        if (accounts.length === 0) {
+            return null;
+        }
+        let acc = accounts[0];
+        return {
+            ... acc,
+            platform: platform ?? acc.platform
+        };
+    }
+    export function getAll (): ChainAccount[] {
+        let out = [];
+        for (let platform in accounts) {
+            for (let name in accounts[platform]) {
+                let account = accounts[platform][name];
+                account.name = name;
+                account.platform = platform as TPlatform;
+                out.push(account);
+            }
+        }
+        return out;
+    }
+    export function getAddressFromKey (key: string) {
+        const bytes = Buffer.from(key, 'hex');
+        const wallet = new Wallet(bytes);
+        return wallet.address;
+    }
+
+    export function generate (opts?: { name?: string, platform?: TPlatform }): ChainAccount {
+        const bytes = crypto.randomBytes(32);
+        const wallet = new Wallet(bytes);
+        return {
+            ...(opts ?? {}),
+            address: wallet.address,
+            key: bytes.toString('hex'),
+        }
+    }
+}

package/src/ChainAccountsService.ts

@@ -0,0 +1,74 @@
+import di from 'a-di';
+import alot from 'alot';
+import { ChainAccount, ChainAccountProvider } from './ChainAccounts';
+import { JsonArrayStore } from './json/JsonArrayStore';
+import { TAddress } from './models/TAddress';
+import { TPlatform } from './models/TPlatform';
+import { $address } from './utils/$address';
+
+export class ChainAccountsService {
+    private store = di.resolve(Store);
+    private config = ChainAccountProvider;
+
+    async get (mix: string | TAddress, platform?: TPlatform): Promise<ChainAccount> {
+        let acc = this.config.tryGet(mix, platform);
+        return acc ?? this.store.get(mix);
+    }
+    async getAll (): Promise<ChainAccount[]> {
+        return this.store.getAll();
+    }
+    async generate (opts: { name: string, platform: TPlatform }) {
+        let current = await this.get(opts.name, opts.platform);
+        if (current) {
+            return current;
+        }
+        let account = this.config.generate(opts);
+        await this.store.save(account);
+        return account;
+    }
+    async generateMany (names: string[], platform: TPlatform) {
+        let newAccounts = [];
+        let accounts = await alot(names).mapAsync(async name => {
+            let current = await this.get(name, platform);
+            if (current) {
+                return current;
+            }
+            let account = this.config.generate({ name, platform });
+            newAccounts.push(account)
+            return account;
+        }).toArrayAsync();
+
+        if (newAccounts.length > 0) {
+            await this.store.saveMany(newAccounts);
+        }
+        return accounts;
+    }
+}
+
+
+class Store {
+    private fs = new JsonArrayStore <ChainAccount> ({
+        path: './db/accounts/accounts.json',
+        key: x => (x.key ?? x.address),
+        format: true,
+    })
+
+    async get (name: string): Promise<ChainAccount>
+    async get (address: TAddress): Promise<ChainAccount>
+    async get (mix: string | TAddress): Promise<ChainAccount> {
+        let accounts = await this.fs.getAll();
+        if ($address.isValid(mix)) {
+            return accounts.find(x => $address.eq(mix, x.address));
+        }
+        return accounts.find(x => x.name === mix);
+    }
+    async getAll () {
+        return await this.fs.getAll();
+    }
+    async save (account: ChainAccount) {
+        await this.fs.upsert(account);
+    }
+    async saveMany (accounts: ChainAccount[]) {
+        await this.fs.upsertMany(accounts);
+    }
+}

package/src/Config.ts

@@ -0,0 +1,34 @@
+import { IContractDetails } from './models/IContractDetails';
+import { TPlatform } from './models/TPlatform';
+
+export interface IProviderEndpoint {
+    url: string
+    private?: boolean
+    safe?: boolean
+}
+export class Config {
+    accounts: {
+        [platform in TPlatform]: {
+            [name: string]: {
+                address: string
+                key: string
+            }
+        }
+    }
+    blockchainExplorer: {
+        [platform in TPlatform]: {
+            key: string
+            host: string
+        }
+    }
+    web3: {
+        [platform in TPlatform]: {
+            endpoints: IProviderEndpoint[]
+        }
+    }
+    contracts?: {
+        [platform in TPlatform]: IContractDetails[]
+    }
+}
+
+export const config = new Config();

package/src/blocks/BlockDateResolver.ts

@@ -0,0 +1,149 @@
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { $block } from '@dequanto/utils/$block';
+import alot from 'alot';
+
+export class BlockDateResolver {
+    private AVG_INITIAL = {
+        eth: 12 * 1000,
+        bsc: 3 * 1000,
+        polygon: 3 * 1000,
+    };
+
+    private closestTime: number;
+    private closestIdx: number;
+
+    private known = [] as IKnownBlock[]
+    private q: Date;
+
+    constructor(public client: Web3Client) {
+
+    }
+
+    async getBlockNumberFor (date: 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 now = new Date();
+        let topBlock = <IKnownBlock> {
+            blockNumber: await this.client.getBlockNumberCached(),
+            date: now,
+            avg,
+        };
+
+        this.known.push(topBlock);
+        return await this.moveNext(date);
+    }
+
+    private async moveNext (date: Date) {
+
+        let closestIndex = this.getClosest(date);
+        let block = this.known[closestIndex];
+        let timeDiff = this.diffTime(block.date, date);
+
+        let timeDistance = Math.abs(timeDiff);
+        const BLOCKS_TOLERANCE = 2;
+        if (timeDistance <= block.avg * BLOCKS_TOLERANCE) {
+            return block.blockNumber;
+        }
+        if (this.closestTime != null && timeDistance >= this.closestTime) {
+            let b = this.known[this.closestIdx];
+            return b.blockNumber;
+        }
+
+        this.closestTime = timeDistance;
+        this.closestIdx = closestIndex;
+
+        let nextInfo = await this.checkPoint(block, timeDiff);
+        if (nextInfo == null) {
+            return block.blockNumber;
+        }
+
+        return this.moveNext(date);
+    }
+
+    /**
+     * Returns index of the first known block, which is most near to specified block (it can be before or after the specified date).
+     */
+    private getClosest (date: Date) {
+        let entry = alot(this.known).map(x => [
+            this.diffTimeAbs(x.date, date),
+            x
+        ] as const).minItem(x => x[0])[1];
+        let i = this.known.indexOf(entry);
+        return i;
+    }
+
+    private async checkPoint (anchor: IKnownBlock, diffTime: number) {
+        let diffCount = Math.round(diffTime / anchor.avg);
+        if (diffCount === 0) {
+            return null;
+        }
+        let blockNumber = anchor.blockNumber + diffCount;
+        let date = await this.getBlockDate(blockNumber);
+        let info = {
+            blockNumber: blockNumber,
+            date: date,
+        };
+        this.push(info);
+        this.refineAvg();
+
+        return info;
+    }
+
+    private push(info: IKnownBlock) {
+        for (let i = 0; i < this.known.length; i++) {
+            let x = this.known[i];
+            if (info.date < x.date) {
+                this.known.splice(i, 0, info);
+                return;
+            }
+        }
+        this.known.push(info);
+    }
+
+    /** Loads the block and gets the Date of the block */
+    private async getBlockDate (blockNumber: number) {
+        let block = await this.client.getBlock(blockNumber);
+        if (block == null) {
+            throw new Error(`Block not loaded: ${blockNumber}`);
+        }
+        let date = $block.getDate(block);
+        return date;
+    }
+    /** Returns SIGNED time in milliseconds between two dates. Negative values when t2 < t1 */
+    private diffTime (t1: Date, t2: Date) {
+        return (t2.getTime() - t1.getTime());
+    }
+    /** Returns ABSOLUTE time in milliseconds between two dates.  */
+    private diffTimeAbs (t1: Date, t2: Date) {
+        return Math.abs(this.diffTime(t1, t2));
+    }
+    /** Returns AVG block count between two dates */
+    private getAvgBlockCountBetween (b1: IKnownBlock, b2: IKnownBlock) {
+        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 */
+    private refineAvg () {
+        for (let i = 1; i < this.known.length; i++) {
+            let info = this.known[i];
+            let prev = this.known[i - 1];
+
+            info.avg = this.getAvgBlockCountBetween(prev, info);
+            if (i === 1) {
+                this.known[0].avg = info.avg;
+            }
+        }
+    }
+}
+
+interface IKnownBlock {
+    blockNumber: number;
+    date: Date
+    avg?: number
+}
+

package/src/bridges/BridgeFactory.ts

@@ -0,0 +1,16 @@
+import { HopBridge } from './hop/HopBridge';
+import { IBridge } from './models/IBridge';
+
+export class BridgeFactory {
+    bridges = [
+        new HopBridge()
+    ] as  IBridge[];
+
+    get(name: 'hop' | string): IBridge {
+        let bridge = this.bridges.find(x => x.name === name);
+        if (bridge == null) {
+            throw new Error(`Bridge $${name} not supported.`);
+        }
+        return bridge;
+    }
+}