dequanto 0.0.1

package/src/tokens/TokenProviders/TPUniswap.ts

@@ -0,0 +1,85 @@
+import axios from 'axios'
+import { JsonArrayStore } from '@dequanto/json/JsonArrayStore';
+import { ITokenProvider } from './ITokenProvider';
+import { ATokenProvider } from './ATokenProvider';
+import { ITokenGlob } from '@dequanto/models/ITokenGlob';
+import { $path } from '@dequanto/utils/$path';
+
+
+const TheGraphUrl = 'https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v2';
+
+export class TPUniswap extends ATokenProvider implements ITokenProvider {
+    store = new JsonArrayStore<ITokenGlob> ({
+        path: $path.resolve('/data/tokens/uni.json'),
+        key: x => x.symbol
+    });
+
+    getTokens(): Promise<ITokenGlob[]> {
+        return this.store.getAll();
+    }
+
+    /** Finds remote  */
+    async find (address: string) {
+        let body = {
+            query: `
+                {
+                    tokens (where: {id: "${address}"}) {
+                    id
+                    symbol
+                    name
+                    decimals
+                    }
+                }
+            `
+        };
+        let resp = await axios.post(TheGraphUrl, body);
+        return resp.data.data?.tokens[0];
+    }
+
+    async redownloadTokens () {
+        let skip = 0;
+        let take = 1000;
+        let out = [] as ITokenGlob[];
+        while (true) {
+            let body = {
+                query: `
+                {
+                    tokens (skip: ${skip} first:${take}) {
+                      id
+                      symbol
+                      name
+                      decimals
+                    }
+                }
+                `
+            };
+
+            let resp = await axios.post(TheGraphUrl, body);
+            console.log(resp);
+            let tokens = resp.data.data?.tokens ?? [];
+
+            let arr = tokens.map(uniT => {
+                return <ITokenGlob> {
+                    symbol: uniT.symbol,
+                    name: uniT.name,
+                    decimals: Number(uniT.decimals) || 18,
+                    platforms: [
+                        {
+                            platform: 'eth',
+                            address: uniT.id,
+                            decimals: uniT.decimals,
+                        }
+                    ]
+                };
+            })
+            out = out.concat(...arr);
+            if (tokens.length < take) {
+                break;
+            }
+            skip += take;
+        }
+
+        await this.store.saveAll(out);
+        return out;
+    }
+}

package/src/tokens/TokenService.ts

@@ -0,0 +1,128 @@
+import di from 'a-di';
+import { ChainAccount } from '@dequanto/ChainAccounts';
+import { WXDaiTokenContract } from '@dequanto/chains/xdai/tokens/WXDaiTokenContract';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { IToken } from '@dequanto/models/IToken';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { TokensServiceFactory } from './TokensServiceFactory';
+import { $require } from '@dequanto/utils/$require';
+
+
+export class TokenService {
+
+    private tokensProvider = TokensServiceFactory.get(this.client.platform);
+
+    constructor(public client: Web3Client) {
+
+    }
+
+    async balanceOf(address: TAddress, token: string | IToken): Promise<bigint> {
+        token = await this.getToken(token);
+        let isNative = this.tokensProvider.isNative(token.address);
+        if (isNative) {
+            return this.client.getBalance(address);
+        }
+        let erc20 = await this.tokensProvider.erc20(token);
+        let balance = await erc20.balanceOf(address);
+        return balance;
+    }
+    async hasToken(address: TAddress, token: string | IToken, amount: number): Promise<boolean> {
+        let t = await this.getToken(token);
+        let balance = await this.balanceOf(address, t);
+        let wei = $bigint.toWei(amount, t.decimals);
+        return wei <= balance;
+    }
+
+    async ensureApproved (account: ChainAccount, tokenMix: string | IToken, spender: TAddress, amount: bigint | number): Promise<TxWriter | null> {
+        let token = await this.getToken(tokenMix);
+        let erc20 = await this.tokensProvider.erc20(token.address);
+        let approved = await erc20.allowance(account.address, spender);
+
+        let desiredApproval = typeof amount === 'bigint'
+            ? amount
+            : $bigint.toWei(amount, token.decimals);
+
+        if (true || approved < desiredApproval) {
+            return await erc20
+                .$config({
+                    gasEstimation: true,
+                    type: 2,
+                }, {
+                    retries: 0
+                })
+                .approve(account, spender, desiredApproval * 2n);
+        }
+        return null;
+    }
+
+    /**
+     * @param amount Can be negative (wraps all with rest)
+     */
+    async wrapNativeToERC20 (account: ChainAccount, amount: number): Promise<TxWriter> {
+        let amountWei = $bigint.toWei(amount, 18);
+        if (amountWei < 0n) {
+            let balance = await this.client.getBalance(account.address);
+            amountWei = balance + amountWei;
+        }
+        $require.gt(amountWei, 0n);
+
+        let depositor: { deposit: WXDaiTokenContract['deposit'] };
+        switch (this.client.platform) {
+            case 'xdai':
+                depositor = di.resolve(WXDaiTokenContract);
+                break;
+        }
+        if (depositor == null) {
+            throw new Error(`Wrapping depositor not found for platform ${this.client?.platform}`);
+        }
+        return await depositor.deposit({
+            ...account,
+            value: amountWei
+        });
+    }
+    /**
+     *
+     */
+     async unwrapNative (account: ChainAccount, amount?: number | bigint): Promise<TxWriter> {
+        let depositor: { balanceOf: WXDaiTokenContract['balanceOf'], withdraw: WXDaiTokenContract['withdraw'] };
+        switch (this.client.platform) {
+            case 'xdai':
+                depositor = di.resolve(WXDaiTokenContract);
+                break;
+        }
+        if (depositor == null) {
+            throw new Error(`Wrapping depositor not found for platform ${this.client?.platform}`);
+        }
+        if (amount == null || amount === Infinity) {
+            amount = await depositor.balanceOf(account.address);
+        }
+        let amountWei = typeof amount === 'number'
+            ? $bigint.toWei(amount, 18)
+            : amount;
+
+        console.log(amount, amountWei);
+        $require.gt(amountWei, 0n);
+
+        return await depositor.withdraw(account, amountWei);
+    }
+
+    protected async getToken(mix: string | IToken): Promise<IToken> {
+        let token = typeof mix === 'string'
+            ? await this.tokensProvider.getKnownToken(mix)
+            : mix;
+
+        if (this.tokensProvider.isNative(token.address)) {
+            token = {
+                ...token,
+                address: '0x0000000000000000000000000000000000000000',
+            }
+        }
+
+        if (token == null || token.address == null) {
+            throw new Error(`Address undefined: ${token}`);
+        }
+        return token;
+    }
+}

package/src/tokens/TokenSwapService.ts

@@ -0,0 +1,47 @@
+import { ChainAccount } from '@dequanto/ChainAccounts';
+import { ChainAccountsService } from '@dequanto/ChainAccountsService';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TxLoggerService } from '@dequanto/loggers/TxLoggerService';
+import { IToken } from '@dequanto/models/IToken';
+import di from 'a-di';
+import { ISwapService } from './defi/ISwapService';
+import { Paraswap } from './defi/paraswap/Paraswap';
+
+
+export class TokenSwapService {
+
+    constructor(
+        public client: Web3Client,
+        public provider: ISwapService = di.resolve(Paraswap, client.platform, client)
+    ) {
+
+    }
+
+    async swap (account: string | ChainAccount, params: {
+        from: string | IToken
+        to: string | IToken
+        amount: number | bigint
+    }) {
+        if (typeof account === 'string') {
+            let accountsService = di.resolve(ChainAccountsService);
+            let acc = await accountsService.get(account, this.client.platform);
+            if (acc == null) {
+                throw new Error(`Account ${account} not found`);
+            }
+            account = acc;
+        }
+        // let transfer = di.resolve(TokenTransferService, this.client);
+        // let balance = await transfer.getBalance(account, params.from);
+        // let token = await transfer.getToken(TOKEN_FROM);
+        // let amount = balance - $bigint.toWei(24, token.decimals);
+
+        let { from, to, amount } = params;
+
+        let tx = await this.provider.swap(account, {
+            from:  from,
+            to: to,
+            fromAmount: amount,
+        });
+        return tx;
+    }
+}

package/src/tokens/TokenTransferService.ts

@@ -0,0 +1,216 @@
+import di from 'a-di';
+import { ChainAccount } from '@dequanto/ChainAccounts';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { IToken } from '@dequanto/models/IToken';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $is } from '@dequanto/utils/$is';
+import { TokensService } from './TokensService';
+import { TransactionReceipt } from 'web3-core';
+import { $address } from '@dequanto/utils/$address';
+import { ITxConfig } from '@dequanto/txs/ITxConfig';
+import { $promise } from '@dequanto/utils/$promise';
+import { LoggerService } from '@dequanto/loggers/LoggerService';
+import { $logger } from '@dequanto/utils/$logger';
+
+
+export class TokenTransferService {
+
+    private gasPriorityFee?: number
+    private txConfig: ITxConfig
+    private tokenService = di.resolve(TokensService, this.client.platform)
+
+    constructor (public client: Web3Client, private logger = di.resolve(LoggerService)) {
+
+    }
+
+    $config (txConfig: ITxConfig): this {
+        this.txConfig = txConfig;
+        return this;
+    }
+
+
+    async getBalance(address: TAddress, token: string | IToken): Promise<bigint> {
+        token = await this.getToken(token);
+        let isNative = this.tokenService.isNative(token.address);
+        if (isNative) {
+            return this.client.getBalance(address);
+        }
+
+        let erc20 = await TokensService.erc20(token, this.client.platform);
+        let balance = await erc20.balanceOf(address);
+        return balance;
+    }
+    async getReceived(receipt: TransactionReceipt): Promise<bigint> {
+        let receiver = receipt.from;
+        let ANYTOKEN = 'USDC';
+        let erc20 = await TokensService.erc20(ANYTOKEN, this.client.platform);
+        let transfers = erc20.extractLogsTransfer(receipt)
+        let transfer = transfers.find(x => $address.eq(x.to, receiver));
+        return transfer?.value ?? 0n;
+    }
+
+    /** Returns NULL for transaction, if no balance to transfer */
+    async transferAll (from: ChainAccount, to: TAddress, token: string | IToken) : Promise<TxWriter> {
+        token = await this.getToken(token);
+
+        let isNative = this.tokenService.isNative(token.address);
+        if (isNative) {
+            return this.transferNativeAll(from, to);
+        }
+        return this.transferErc20All(from, to, token);
+    }
+    async transferAllWithRemainder (from: ChainAccount, to: TAddress, token: string | IToken, remainder: number | bigint) : Promise<TxWriter> {
+        token = await this.getToken(token);
+
+        let isNative = this.tokenService.isNative(token.address);
+        if (isNative) {
+            return this.transferNativeAll(from, to, { remainder });
+        }
+        return this.transferErc20All(from, to, token, { remainder });
+    }
+    async transfer (from: ChainAccount, to: TAddress, token: string | IToken, amount: number | bigint) : Promise<TxWriter> {
+        token = await this.getToken(token);
+        amount = this.getAmount(amount, token);
+
+        let isNative = this.tokenService.isNative(token.address);
+        if (isNative) {
+            return this.transferNative(from, to, amount);
+        }
+        return this.transferErc20(from, to, token, amount);
+    }
+
+    async getToken (token: string | IToken): Promise<IToken> {
+        if (typeof token === 'string') {
+            token = await this.tokenService.getKnownToken(token);
+        }
+        $is.notNull(token, 'Token is undefined to transfer');
+        return token;
+    }
+    isNativeToken (token: string | IToken): boolean {
+        return this.tokenService.isNative(typeof token === 'string' ? token : token.address);
+    }
+
+    private async transferNativeAll (from: ChainAccount, to: TAddress, opts?: { remainder: number | bigint }): Promise<TxWriter> {
+        let buildTxRetries = 1;
+
+        const buildTx = async () => {
+            let GAS = 21000;
+            let GAS_RATIO = 1.05;
+            let [ balance, gasPrice] = await Promise.all([
+                this.client.getBalance(from.address),
+                this.client.getGasPrice()
+            ]);
+            if (opts?.remainder != null) {
+                let remainder = this.getAmount(opts.remainder, 18);
+                balance -= remainder;
+            }
+
+            let $gasPrice = $bigint.multWithFloat(gasPrice.price, GAS_RATIO);
+            console.log('$gasPrice', $bigint.toGweiFromWei($gasPrice));
+
+            let gasConsumed = BigInt(GAS) * $gasPrice;
+            let transferValue = balance - gasConsumed;
+            if (transferValue <= 0) {
+                if (--buildTxRetries > -1) {
+                    $logger.log(`No balance to transfer retry in 5s`);
+                    await $promise.wait(5000);
+                    return buildTx();
+                }
+                // No balance to transfer
+                $logger.log(`No balance to transfer in ${from.address}. ${ opts?.remainder ? ("Remainder: " + opts?.remainder) : ""}`);
+                return null;
+            }
+
+            let txBuilder = new TxDataBuilder(this.client, from, {
+                to: to,
+                value: $bigint.toHex(transferValue)
+            });
+
+            txBuilder.data.gasPrice = $bigint.toHex($gasPrice);
+
+            // txBuilder.data.maxFeePerGas = $bigint.toHex($gasPrice - 20n**9n);
+            // txBuilder.data.maxPriorityFeePerGas = $bigint.toHex(20n**9n);
+            txBuilder.data.gasLimit = GAS;
+            txBuilder.data.type = 1;
+
+            txBuilder.setConfig(this.txConfig);
+
+            await Promise.all([
+                txBuilder.setNonce({ overriding: true }),
+            ]);
+
+            $logger.log(`TransferNative ALL. Balance ${balance}; GasConsumed ${gasConsumed}; TransferValue ${transferValue}; Nonce: ${txBuilder.data.nonce}`);
+            return txBuilder;
+        }
+        let txBuilder = await buildTx();
+        return TxWriter.write(this.client, txBuilder, from, {
+            retries: 3,
+            async onErrorRebuild (tx, error, errCount) {
+                // In case we got `balance` value, but that one was outdated, then all our calculations where wrong.
+                // Retry the calculation and transfer once again.
+                if (/insufficient funds/.test(error.message)) {
+                    const ms = 6000 * errCount;
+                    $logger.log(`TokenTransfer Failed: insufficient funds. Waiting ${ms}ms to retry`);
+                    await $promise.wait(ms);
+                    return buildTx();
+                }
+                return null;
+            }
+        });
+    }
+    private async transferNative (from: ChainAccount, to: TAddress, amount: bigint): Promise<TxWriter> {
+        let txBuilder = new TxDataBuilder(this.client, from, {
+            to: to,
+            value: $bigint.toHex(amount)
+        });
+
+        let GAS = 21000;
+        await Promise.all([
+            txBuilder.setGas({ priceRatio: this.gasPriorityFee, gasLimit: GAS }),
+            txBuilder.setNonce(),
+        ]);
+        txBuilder.setConfig(this.txConfig);
+        return TxWriter.write(this.client, txBuilder, from);
+    }
+
+    private async transferErc20All (from: ChainAccount, to: TAddress, token: IToken, opts?: { remainder?: number | bigint, retryCount?: number }): Promise<TxWriter> {
+        let erc20 = await TokensService.erc20(token, this.client.platform);
+        let balance = await erc20.balanceOf(from.address);
+        if (opts?.remainder != null) {
+            let remainder = this.getAmount(opts.remainder, 18);
+            balance -= remainder;
+        }
+        if (balance <= 0n) {
+            if (opts?.retryCount == null || opts?.retryCount !== 0) {
+                // re-read
+                this.logger.warn(`TransferErc20All has no balance to transfer: ${token.address}. Balance re-fetch scheduled.`);
+                await $promise.wait(4000);
+                return this.transferErc20All(from, to, token, {
+                    ...(opts ?? {}),
+                    retryCount: 0
+                });
+            }
+            return null;
+        }
+        return erc20
+            .$config(this.txConfig)
+            .transfer(from, to, balance);
+    }
+    private async transferErc20 (from: ChainAccount, to: TAddress, token: IToken, amount: bigint): Promise<TxWriter> {
+        let erc20 = await TokensService.erc20(token, this.client.platform);
+        return erc20
+            .$config(this.txConfig)
+            .transfer(from, to, amount);
+    }
+    private getAmount (amount: number | bigint, token: IToken): bigint
+    private getAmount (amount: number | bigint, decimals: number): bigint
+    private getAmount (amount: number | bigint, mix: number | IToken): bigint {
+        if (typeof amount === 'number') {
+            amount = $bigint.toWei(amount, typeof mix === 'number' ? mix : mix.decimals);
+        }
+        return amount;
+    }
+}