dequanto 0.0.1 → 0.0.7

package/src/tokens/TokenExchanges/AmmV2ExchangeBase.ts

@@ -15,6 +15,7 @@ import { AmmVaultV2Contract } from './AmmBase/V2/AmmVaultV2Contract';
 import { TokensServiceBsc } from '../TokensServiceBsc';
 import { $is } from '@dequanto/utils/$is';
 import { $address } from '@dequanto/utils/$address';
+import { $require } from '@dequanto/utils/$require';
 
 
 interface ILPPair extends IToken {
@@ -82,7 +83,7 @@ export abstract class AmmV2ExchangeBase {
 
 
     async calcSwap (from: IToken, to: IToken, fromAmount: bigint): Promise<{ amount: bigint, priceImpact: number }> {
-        $is.BigInt(fromAmount);
+        $require.BigInt(fromAmount);
 
         if (fromAmount === 0n) {
             return {
@@ -102,8 +103,8 @@ export abstract class AmmV2ExchangeBase {
             return null;
         }
 
-        $is.BigInt(lpReserves?._reserve0, `Reserve 0 not valid for LPAddress ${lpAddress}`);
-        $is.BigInt(lpReserves?._reserve1, `Reserve 1 not valid for LPAddress ${lpAddress}`);
+        $require.BigInt(lpReserves?._reserve0, `Reserve 0 not valid for LPAddress ${lpAddress}`);
+        $require.BigInt(lpReserves?._reserve1, `Reserve 1 not valid for LPAddress ${lpAddress}`);
 
         let [ fromI, toI] = BigInt(from.address) < BigInt(to.address) ? [0, 1] : [1, 0];
 

package/src/tokens/TokenExchanges/OneInchExchange.ts

@@ -1,7 +1,7 @@
 import di from 'a-di';
 import axios from 'axios';
 import { BlockChainExplorerProvider } from '@dequanto/BlockchainExplorer/BlockChainExplorerProvider';
-import { ChainAccount } from '@dequanto/ChainAccounts';
+import { ChainAccount } from "@dequanto/models/TAccount";
 import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
 import { ERC20 } from '@dequanto/contracts/common/ERC20';
 import { IToken } from '@dequanto/models/IToken';

package/src/tokens/TokenExchanges/PancakeswapExchange.ts

@@ -7,19 +7,14 @@ import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExp
 import { Web3Client } from '@dequanto/clients/Web3Client';
 import { $require } from '@dequanto/utils/$require';
 
-
-const config = $config.get('pancackeswap');
-
-const factory = $require.Address(config.factory, 'Factory Address');
-const masterChef = $require.Address(config.masterChef, 'MasterChef Address');
-const vault = $require.Address(config.vault, 'Vault Address');
-
 export class PancakeswapExchange extends AmmV2ExchangeBase {
 
     name = 'pancake'
-    factoryAddress = factory
-    masterChefAddress = masterChef
-    vaultAddress = vault
+    config = $config.get('pancackeswap');
+    factoryAddress = $require.Address(this.config.factory, 'Factory Address')
+    masterChefAddress = $require.Address(this.config.masterChef, 'MasterChef Address');
+    vaultAddress = $require.Address(this.config.vault, 'Vault Address')
+
 
     constructor(
         public client: Web3Client = di.resolve(BscWeb3Client),

package/src/tokens/TokenExchanges/SushiswapPolygonExchange.ts

@@ -8,19 +8,22 @@ import { Web3Client } from '@dequanto/clients/Web3Client';
 import { $require } from '@dequanto/utils/$require';
 
 
-const config = $config.get('pancackeswap');
 
-const factory = $require.Address(config.factory, 'Factory Address');
-const masterChef = $require.Address(config.masterChef, 'MasterChef Address');
-const vault = $require.Address(config.vault, 'Vault Address');
+
 
 export class SushiswapPolygonExchange extends AmmV2ExchangeBase {
 
     name = 'sushiswap'
+    config = $config.get('sushiswap');
+
     factoryAddress = '0xc35dadb65012ec5796536bd9864ed8773abc74c4'
-    masterChefAddress = masterChef
+    masterChefAddress = $require.Address(this.config?.masterChef ?? '0x0769fd68dFb93167989C6f7254cd0D766Fb2841F', 'MasterChef Address');
     vaultAddress = '0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506'
 
+    // private factory = $require.Address(this.config.factory, 'Factory Address');
+    // private vault = $require.Address(this.config.vault, 'Vault Address');
+
+
     constructor(
         public client: Web3Client = di.resolve(BscWeb3Client),
         public explorer: IBlockChainExplorer = di.resolve(Bscscan)

package/src/tokens/TokenExchanges/UniswapExchange.ts

@@ -9,18 +9,15 @@ import { Web3Client } from '@dequanto/clients/Web3Client';
 import { $require } from '@dequanto/utils/$require';
 
 
-const config = $config.get('uniswapV2');
-
-const factory = $require.Address(config.factory, 'Factory Address');
-const vault = $require.Address(config.vault, 'Vault Address');
-const masterChef = config.masterChef;
-
 export class UniswapExchange extends AmmV2ExchangeBase {
 
     name = 'uniswap'
-    factoryAddress = factory
-    masterChefAddress = masterChef
-    vaultAddress = vault
+
+    config = $config.get('uniswapV2')
+
+    factoryAddress = $require.Address(this.config.factory, 'Factory Address')
+    masterChefAddress = $require.Address(this.config.vault, 'Vault Address')
+    vaultAddress = this.config.masterChef
 
     constructor(
         public client: Web3Client = di.resolve(EthWeb3Client),

package/src/tokens/TokenOracles/AmmPriceV2Oracle.ts

@@ -16,7 +16,7 @@ import { TokenPriceStore } from './TokenPriceStore';
 import { $bigint } from '@dequanto/utils/$bigint';
 import { AmmPairV2Service, ISwapPool, ISwapPoolInfo } from '../TokenExchanges/AmmBase/V2/AmmPairV2Service';
 import { SushiswapPolygonExchange } from '../TokenExchanges/SushiswapPolygonExchange';
-import { $logger } from '@dequanto/utils/$logger';
+
 
 
 interface ISwapOptions {
@@ -36,7 +36,7 @@ export class AmmPriceV2Oracle {
     exchange: AmmV2ExchangeBase
     tokensService = di.resolve(TokensService, this.client.platform, this.explorer)
     pairService = di.resolve(AmmPairV2Service, this.client, this.explorer)
-    logger = di.resolve(LoggerService, nameof(AmmPriceV2Oracle));
+    logger = di.resolve(LoggerService, 'AmmPriceV2Oracle');
 
     constructor(public client: Web3Client, public explorer: IBlockChainExplorer) {
         switch (client.platform) {
@@ -107,7 +107,6 @@ export class AmmPriceV2Oracle {
 
         if (route == null || route.length === 0) {
             let error = new Error(`Route not found for Token ${token.address}`);
-            this.logger.write(error.message);
             return { error };
         }
 
@@ -122,9 +121,10 @@ export class AmmPriceV2Oracle {
                             date: cacheableDate,
                             priceFrom: price
                         }
-                    }
+                    };
                 }
             }
+
             let poolPair = this.exchange.pairContract(lp.address);
             let lpReserves = await poolPair
                 .forBlock(opts?.block ?? opts?.date)
@@ -368,7 +368,7 @@ namespace TokenPrice {
         let toPrice = TokenUtils.calcPrice(amountActual, toToken, toUsd ?? fromUsd);
 
         //console.log('FromPice', fromPrice, fromAmount, fromToken, fromUsd, toUsd);
-        $logger.log(`Swap: ${fromToken.symbol}(${fromAmount})[${fromUsd}$] > ${toToken.symbol} (${amountActual})[${toUsd}$]; Price ${fromToken.symbol}: ${fromPrice}`);
+        //$logger.log(`Swap: ${fromToken.symbol}(${fromAmount})[${fromUsd}$] > ${toToken.symbol} (${amountActual})[${toUsd}$]; Price ${fromToken.symbol}: ${fromPrice}`);
 
 
         if (lp.date) {

package/src/tokens/TokenOracles/CoingeckoOracle.ts

@@ -0,0 +1,13 @@
+import { $config } from '@dequanto/utils/$config';
+
+export class CoingeckoOracle {
+
+    key = $config.get('coingecko.key');
+
+    constructor() {
+
+    }
+    getToken (name: string) {
+
+    }
+}

package/src/tokens/TokenOracles/TokenPriceStore.ts

@@ -16,7 +16,7 @@ export class TokenPriceStore {
         return stores[token] ?? (stores[token] = new TokenPriceStore(token));
     }
 
-    private prices = null as [number, number][]
+    private prices = [] as [number, number][]
     private pricesIdx = {} as {
         [day: string]: {
             [hour: string]: {

package/src/tokens/TokenPriceService.ts

@@ -68,7 +68,6 @@ export class TokenPriceService {
             return { error: new Error(`Token has no decimals ${token.symbol}`) };
         }
 
-
         let { error, result } = await this.oracle.getPrice(token, opts);
         if (error != null) {
             return { error };

package/src/tokens/TokenProviders/ITokenProvider.ts

@@ -5,5 +5,5 @@ export interface ITokenProvider {
     getByAddress (platform: TPlatform, address: TAddress)
     getBySymbol  (platform: TPlatform, symbol: string)
 
-    redownloadTokens(): Promise<any>
+    redownloadTokens(): Promise<void | any>
 }

package/src/tokens/TokenProviders/TPChain.ts

@@ -1,12 +1,13 @@
-import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import type { Web3Client } from '@dequanto/clients/Web3Client';
 import { IToken } from '@dequanto/models/IToken';
 import { TAddress } from '@dequanto/models/TAddress';
 import { TPlatform } from '@dequanto/models/TPlatform';
 import { ITokenProvider } from './ITokenProvider';
+import { ContractReader } from '@dequanto/contracts/ContractReader';
 
 export class TPChain implements ITokenProvider {
 
-    constructor (public platform: TPlatform, public explorer?: IBlockChainExplorer) {
+    constructor (public platform: TPlatform, public client?: Web3Client) {
 
     }
 
@@ -15,13 +16,24 @@ export class TPChain implements ITokenProvider {
             return null;
         }
 
+        let reader = new ContractReader(this.client)
         try {
-            let source = await this.explorer?.getContractSource(address);
-            return <Partial<IToken>> {
-                address: address,
-                symbol: source
-                    .ContractName
-                    ?.replace(/bep20/i, ''),
+            let [
+                symbol,
+                name,
+                decimals,
+            ] = await Promise.all([
+                reader.readAsync(address, 'function symbol() returns string'),
+                reader.readAsync(address, 'function name() returns string'),
+                reader.readAsync(address, 'function decimals() returns uint8'),
+            ]);
+
+            return <IToken> {
+                platform,
+                address,
+                symbol,
+                name,
+                decimals,
             };
 
         } catch (error) {

package/src/tokens/TokenProviders/TPCoingecko.ts

@@ -0,0 +1,121 @@
+import axios, { type AxiosError } from 'axios';
+import memd from 'memd';
+import alot from 'alot';
+import { File } from 'atma-io';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { ITokenProvider } from './ITokenProvider';
+import { $path } from '@dequanto/utils/$path';
+import { JsonArrayStore } from '@dequanto/json/JsonArrayStore';
+import { ITokenGlob } from '@dequanto/models/ITokenGlob';
+import { ATokenProvider } from './ATokenProvider';
+import { l } from '@dequanto/utils/$logger';
+import { $promise } from '@dequanto/utils/$promise';
+
+export class TPCoingecko extends ATokenProvider  implements ITokenProvider {
+
+    store = new JsonArrayStore<ITokenGlob> ({
+        path: $path.resolve('/data/tokens/coingecko.json'),
+        key: x => x.symbol,
+        format: true,
+    });
+
+
+    getTokens(): Promise<ITokenGlob[]> {
+        return this.store.getAll();
+    }
+
+    async redownloadTokens(): Promise<ITokenGlob[]> {
+        let list = await this.downloadList();
+        l`Got list of ${list.length} tokens from CoinGecko. Fetching details...`;
+
+
+        let tokens = await alot(list)
+        .mapAsync(async (token, i) => {
+
+            if (i > 0 && i % 10 === 0) {
+                l`Fetched ${i}/${list.length} token details`;
+            }
+            let info = await this.downloadTokenInfoOrCache(token.id);
+            return <ITokenGlob>{
+                name: token.name,
+                symbol: token.symbol,
+                platforms: alot
+                    .fromObject(info?.detail_platforms ?? {})
+                    .map(entry => {
+                        let platform = this.mapPlatform(entry.key);
+                        return {
+                            platform,
+                            decimals: entry.value.decimal_place,
+                            address: entry.value.contract_address,
+                        };
+                    })
+                    .filter(x => Boolean(x.platform) && Boolean(x.address) && Boolean(x.decimals))
+                    .toArray()
+            }
+        })
+        .filterAsync(x => x.platforms.length > 0)
+        .toArrayAsync();
+
+        await this.store.saveAll(tokens);
+        return tokens;
+    }
+
+
+    private async downloadList () {
+        let resp = await axios.get<{id, symbol, name}[]>(`https://api.coingecko.com/api/v3/coins/list`);
+        return resp.data;
+    }
+
+    private async downloadTokenInfoOrCache (id: string): Promise<TDetails> {
+        let cachePath = `./cache/coingecko/${id}.json`;
+        if (await File.existsAsync(cachePath)) {
+            let json = await File.readAsync<{info: TDetails, timestamp}>(cachePath);
+            return json.info;
+        }
+        let info = await this._downloadTokenInfo(id);
+        await File.writeAsync(cachePath, { info, id, timestamp: Date.now() });
+        return info;
+    }
+
+    // 50 per minute
+    @memd.deco.throttle(60 * 1000 / 50)
+    private async _downloadTokenInfo (id: string) {
+
+        let wait = 10_000;
+        async function fetch  () {
+            try {
+                let resp = await axios.get<TDetails>(`https://api.coingecko.com/api/v3/coins/${id}`);
+                return resp.data
+            } catch (error) {
+                let e = error as AxiosError;
+                if (e.response?.status === 404) {
+                    return <TDetails> { id, detail_platforms: {} };
+                }
+                if (e.response?.status === 429) {
+                    l`Throttled. Wait for ${wait}ms`;
+                    await $promise.wait(wait);
+                    wait *= 1.2;
+                    return fetch();
+                }
+                throw error;
+            }
+        }
+        return fetch();
+    }
+
+    private mapPlatform (platformName: string): TPlatform {
+        return this.mapping[platformName] ?? platformName;
+    }
+    private mapping = {
+        'ethereum': 'eth',
+        'polygon-pos': 'poly',
+        'xdai': 'xdai',
+        'binance-smart-chain': 'bsc',
+        'arbitrum-one': 'arbitrum'
+    };
+}
+
+type TDetails = {
+    id, symbol, name,
+    detail_platforms: Record<string, { decimal_place, contract_address }>
+}

package/src/tokens/TokenProviders/TPConfig.ts

@@ -0,0 +1,53 @@
+import { IToken } from '@dequanto/models/IToken';
+import { ITokenGlob } from '@dequanto/models/ITokenGlob';
+import { ITokenProvider } from './ITokenProvider';
+import { ATokenProvider } from './ATokenProvider';
+import { Config, config } from '@dequanto/Config';
+import { $require } from '@dequanto/utils/$require';
+
+
+export class TPConfig extends ATokenProvider implements ITokenProvider {
+
+
+    async getTokens(): Promise<ITokenGlob[]> {
+        return config.tokens ?? [];
+    }
+
+    async addToken (token: IToken) {
+        $require.Address(token.address);
+        $require.Number(token.decimals);
+        $require.notNull(token.platform, 'Not possible to add the token - platform is undefined');
+
+        let tokens = await this.getTokens();
+        let current = tokens.find(t => t.symbol === token.symbol);
+        if (current == null) {
+            current = <ITokenGlob> {
+                symbol: token.symbol,
+                platforms: []
+            };
+            tokens.push(current);
+        }
+        if (current.platforms == null) {
+            current.platforms = [];
+        }
+        let currentPlatform = current.platforms.find(x => x.platform == token.platform);
+        if (currentPlatform == null) {
+            current.platforms.push({
+                platform: token.platform,
+                decimals: token.decimals,
+                address: token.address,
+            });
+        } else {
+            currentPlatform.decimals = token.decimals;
+            currentPlatform.address = token.address;
+        }
+
+        await Config.extend({
+            tokens
+        });
+    }
+
+    async redownloadTokens(): Promise<any> {
+
+    }
+}

package/src/tokens/TokenProviders/TPExplorer.ts

@@ -0,0 +1,41 @@
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { IToken } from '@dequanto/models/IToken';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { ITokenProvider } from './ITokenProvider';
+
+export class TPExplorer implements ITokenProvider {
+
+    constructor (public platform: TPlatform, public explorer?: IBlockChainExplorer) {
+
+    }
+
+    async getByAddress(platform: TPlatform, address: TAddress) {
+        if (this.platform !== platform) {
+            return null;
+        }
+
+        try {
+            let source = await this.explorer?.getContractSource(address);
+            return <Partial<IToken>> {
+                address: address,
+                symbol: source
+                    .ContractName
+                    ?.replace(/bep20/i, ''),
+            };
+
+        } catch (error) {
+            // just ignore if not resolved
+            return null;
+        }
+    }
+    getBySymbol(platform: TPlatform, symbol: string) {
+        // Does not support by name
+        return null;
+    }
+
+    async redownloadTokens(): Promise<any> {
+        return [];
+    }
+
+}

package/src/tokens/TokenService.ts

@@ -1,5 +1,5 @@
 import di from 'a-di';
-import { ChainAccount } from '@dequanto/ChainAccounts';
+import { ChainAccount } from "@dequanto/models/TAccount";
 import { WXDaiTokenContract } from '@dequanto/chains/xdai/tokens/WXDaiTokenContract';
 import { Web3Client } from '@dequanto/clients/Web3Client';
 import { IToken } from '@dequanto/models/IToken';
@@ -18,13 +18,16 @@ export class TokenService {
 
     }
 
-    async balanceOf(address: TAddress, token: string | IToken): Promise<bigint> {
+    async balanceOf(address: TAddress, token: string | IToken, params?: { forBlock?: number }): Promise<bigint> {
         token = await this.getToken(token);
         let isNative = this.tokensProvider.isNative(token.address);
         if (isNative) {
-            return this.client.getBalance(address);
+            return this.client.getBalance(address, params?.forBlock);
         }
         let erc20 = await this.tokensProvider.erc20(token);
+        if (params?.forBlock != null) {
+            erc20 = erc20.forBlock(params.forBlock);
+        }
         let balance = await erc20.balanceOf(address);
         return balance;
     }

package/src/tokens/TokenSwapService.ts

@@ -1,4 +1,4 @@
-import { ChainAccount } from '@dequanto/ChainAccounts';
+import { ChainAccount } from "@dequanto/models/TAccount";
 import { ChainAccountsService } from '@dequanto/ChainAccountsService';
 import { Web3Client } from '@dequanto/clients/Web3Client';
 import { TxLoggerService } from '@dequanto/loggers/TxLoggerService';

package/src/tokens/TokenTransferService.ts

@@ -1,10 +1,11 @@
 import di from 'a-di';
-import { ChainAccount } from '@dequanto/ChainAccounts';
+
+import { ChainAccount, SafeAccount, TAccount } from "@dequanto/models/TAccount";
 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 { ITxWriterOptions, TxWriter } from '@dequanto/txs/TxWriter';
 import { $bigint } from '@dequanto/utils/$bigint';
 import { $is } from '@dequanto/utils/$is';
 import { TokensService } from './TokensService';
@@ -14,20 +15,27 @@ import { ITxConfig } from '@dequanto/txs/ITxConfig';
 import { $promise } from '@dequanto/utils/$promise';
 import { LoggerService } from '@dequanto/loggers/LoggerService';
 import { $logger } from '@dequanto/utils/$logger';
+import { $account } from '@dequanto/utils/$account';
 
 
 export class TokenTransferService {
 
     private gasPriorityFee?: number
-    private txConfig: ITxConfig
+    private builderConfig: ITxConfig
+    private writerConfig: ITxWriterOptions
     private tokenService = di.resolve(TokensService, this.client.platform)
 
     constructor (public client: Web3Client, private logger = di.resolve(LoggerService)) {
 
     }
 
-    $config (txConfig: ITxConfig): this {
-        this.txConfig = txConfig;
+    $config (builderConfig: ITxConfig): this {
+        this.builderConfig = builderConfig;
+        return this;
+    }
+
+    $configWriter (writerConfig: ITxWriterOptions): this {
+        this.writerConfig = writerConfig;
         return this;
     }
 
@@ -48,8 +56,8 @@ export class TokenTransferService {
         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;
+        let transfer = transfers.find(x => $address.eq(x.params.to, receiver));
+        return transfer?.params.value ?? 0n;
     }
 
     /** Returns NULL for transaction, if no balance to transfer */
@@ -71,7 +79,7 @@ export class TokenTransferService {
         }
         return this.transferErc20All(from, to, token, { remainder });
     }
-    async transfer (from: ChainAccount, to: TAddress, token: string | IToken, amount: number | bigint) : Promise<TxWriter> {
+    async transfer (from: TAccount, to: TAddress, token: string | IToken, amount: number | bigint) : Promise<TxWriter> {
         token = await this.getToken(token);
         amount = this.getAmount(amount, token);
 
@@ -109,13 +117,13 @@ export class TokenTransferService {
             }
 
             let $gasPrice = $bigint.multWithFloat(gasPrice.price, GAS_RATIO);
-            console.log('$gasPrice', $bigint.toGweiFromWei($gasPrice));
+            $logger.log(`GasPrice ${ $bigint.toGweiFromWei($gasPrice) }gwei`);
 
             let gasConsumed = BigInt(GAS) * $gasPrice;
             let transferValue = balance - gasConsumed;
             if (transferValue <= 0) {
                 if (--buildTxRetries > -1) {
-                    $logger.log(`No balance to transfer retry in 5s`);
+                    $logger.log(`No balance to transfer. Retry in 5s`);
                     await $promise.wait(5000);
                     return buildTx();
                 }
@@ -136,7 +144,7 @@ export class TokenTransferService {
             txBuilder.data.gasLimit = GAS;
             txBuilder.data.type = 1;
 
-            txBuilder.setConfig(this.txConfig);
+            txBuilder.setConfig(this.builderConfig);
 
             await Promise.all([
                 txBuilder.setNonce({ overriding: true }),
@@ -147,6 +155,7 @@ export class TokenTransferService {
         }
         let txBuilder = await buildTx();
         return TxWriter.write(this.client, txBuilder, from, {
+            ...(this.writerConfig ?? {}),
             retries: 3,
             async onErrorRebuild (tx, error, errCount) {
                 // In case we got `balance` value, but that one was outdated, then all our calculations where wrong.
@@ -161,19 +170,24 @@ export class TokenTransferService {
             }
         });
     }
-    private async transferNative (from: ChainAccount, to: TAddress, amount: bigint): Promise<TxWriter> {
-        let txBuilder = new TxDataBuilder(this.client, from, {
+    private async transferNative (from: TAccount, to: TAddress, amount: bigint): Promise<TxWriter> {
+        let sender = $account.getSender(from);
+
+        let txBuilder = new TxDataBuilder(this.client, sender, {
             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);
+        if (sender.address) {
+            await Promise.all([
+                txBuilder.setGas({ priceRatio: this.gasPriorityFee, gasEstimation: true, gasLimitRatio: 1, }),
+                txBuilder.setNonce(),
+            ]);
+        }
+
+
+        txBuilder.setConfig(this.builderConfig);
+        return TxWriter.write(this.client, txBuilder, from, this.writerConfig);
     }
 
     private async transferErc20All (from: ChainAccount, to: TAddress, token: IToken, opts?: { remainder?: number | bigint, retryCount?: number }): Promise<TxWriter> {
@@ -193,16 +207,18 @@ export class TokenTransferService {
                     retryCount: 0
                 });
             }
-            return null;
+            if (this.builderConfig.gasFunding == null) {
+                return null;
+            }
         }
         return erc20
-            .$config(this.txConfig)
+            .$config(this.builderConfig, this.writerConfig)
             .transfer(from, to, balance);
     }
-    private async transferErc20 (from: ChainAccount, to: TAddress, token: IToken, amount: bigint): Promise<TxWriter> {
+    private async transferErc20 (from: TAccount, to: TAddress, token: IToken, amount: bigint): Promise<TxWriter> {
         let erc20 = await TokensService.erc20(token, this.client.platform);
         return erc20
-            .$config(this.txConfig)
+            .$config(this.builderConfig, this.writerConfig)
             .transfer(from, to, amount);
     }
     private getAmount (amount: number | bigint, token: IToken): bigint