dequanto 0.0.1 → 0.0.7

package/src/txs/TxWriter.ts

@@ -1,21 +1,33 @@
+import '../env/BigIntSerializer'
 import di from 'a-di';
-import { Web3Client } from '@dequanto/clients/Web3Client';
 import { class_Dfr, class_EventEmitter } from 'atma-utils';
-import { TransactionReceipt } from 'web3-core';
+
+import type { ProposeTransactionProps } from '@gnosis.pm/safe-service-client';
+import type { TransactionRequest } from '@ethersproject/abstract-provider';
+import { TransactionReceipt, type PromiEvent } from 'web3-core';
+
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $txData } from '@dequanto/utils/$txData';
+import { $sign } from '@dequanto/utils/$sign';
+import { $logger } from '@dequanto/utils/$logger';
+import { $promise } from '@dequanto/utils/$promise';
+import { $account } from '@dequanto/utils/$account';
+import { $gas } from '@dequanto/utils/$gas';
+import { Web3Client } from '@dequanto/clients/Web3Client';
 import { TxDataBuilder } from './TxDataBuilder';
 import { TxLogger } from './TxLogger';
-import '../env/BigIntSerializer'
-import { ChainAccount } from '@dequanto/ChainAccounts';
-import { $bigint } from '@dequanto/utils/$bigint';
+import { ChainAccount, IAccount, SafeAccount, TAccount } from "@dequanto/models/TAccount";
 import { TAddress } from '@dequanto/models/TAddress';
 import { ChainAccountsService } from '@dequanto/ChainAccountsService';
 import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
 import { TPlatform } from '@dequanto/models/TPlatform';
-import { $promise } from '@dequanto/utils/$promise';
 import { ClientErrorUtil } from '@dequanto/clients/utils/ClientErrorUtil';
-import { $logger } from '@dequanto/utils/$logger';
 import { ITxLogItem } from './receipt/ITxLogItem';
 import { TxLogParser } from './receipt/TxLogParser';
+import { GnosisSafeHandler } from '@dequanto/safe/GnosisSafeHandler';
+import { ISafeServiceTransport } from '@dequanto/safe/transport/ISafeServiceTransport';
+import { SigFileTransport } from './sig-transports/SigFileTransport';
+import { $require } from '@dequanto/utils/$require';
 
 interface ITxWriterEvents {
     transactionHash (hash: string)
@@ -23,12 +35,26 @@ interface ITxWriterEvents {
     confirmation (confNumber: number, receipt: TransactionReceipt)
     error (error: Error)
     sent ()
-    log (message: string);
+    log (message: string)
+    safeTxProposed (safeTx: ProposeTransactionProps)
 }
 export interface ITxWriterOptions {
     timeout?: number | boolean
     retries?: number
     retryDelay?: number
+    safeTransport?: ISafeServiceTransport
+
+    /** Tx Data will be saved to the store(e.g. a File), and will wait until the signature appears in the store. */
+    sigTransport?: string
+
+    /** Optionally disable waiting for the transport response */
+    sigTransportWait?: boolean
+
+    /** Write the Tx Data to a JSON file, without submit to the blockchain */
+    txOutput?: string
+
+    /** Provide a pre-signed signature for this transaction data. */
+    signature?: string
 
     /**
      * The callback is executed on error, to give the opportunity to build a new Tx to resubmit the tx.
@@ -41,8 +67,11 @@ export interface ITxWriterOptions {
 
 export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
 
+    private isSafe = $account.isSafe(this.account);
+
     onSent = new class_Dfr<string>();
     onCompleted = new class_Dfr<TransactionReceipt>();
+    onSaved = new class_Dfr<string>();
     receipt: TransactionReceipt
 
     onConfirmed (waitForCount: number): Promise<string> {
@@ -58,6 +87,10 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
         return promise as any;
     }
 
+    wait (): Promise<TransactionReceipt> {
+        return this.onCompleted as any as Promise<TransactionReceipt>;
+    }
+
     id = Math.round(Math.random() * 10**10) + '';
     tx: {
         timestamp: number
@@ -75,16 +108,16 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
 
     private logger = new TxLogger(
         this.id,
-        this.account.name ?? this.account.key,
+        this.getSenderName(),
+
         this.builder
     );
     private confirmationAwaiters = [] as { count: number, promise }[]
 
-
     protected constructor (
         public client: Web3Client,
         public builder: TxDataBuilder,
-        public account: { name?: string, key: string, address: string }
+        public account: TAccount
     ) {
         super();
     }
@@ -109,9 +142,60 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
         }
     }
 
-    private sendTxInner () {
+    private async sendTxInner () {
+
+        if (this.options?.txOutput != null) {
+            // handle none blockchain
+            await this.saveTxAndExit()
+            return;
+        }
+
+        if (this.isSafe) {
+            let safeAccount = this.account as SafeAccount;
+            let sender = await this.getSender();
+            let safe = new GnosisSafeHandler({
+                safeAddress: safeAccount.address ?? safeAccount.safeAddress,
+                owner: sender,
+                client: this.client,
+                transport: this.options?.safeTransport
+            });
+            let innerWriter = await safe.execute(this);
+
+            this.pipeInnerWriter(innerWriter);
+            return;
+        }
+
         let time = Date.now();
-        let signedTxBuffer = this.builder.signToString(this.account.key);
+        let sender: ChainAccount = await this.getSender();
+
+        if (this.builder.data.nonce == null) {
+            await this.builder.setNonce();
+        }
+
+        let key = sender?.key;
+        let signedTxBuffer = key == null
+            ? null
+            : await this.builder.signToString(sender.key);
+
+
+        if (signedTxBuffer == null) {
+            if (this.options?.sigTransport != null) {
+                let transport = di.resolve(SigFileTransport);
+                let shouldWait = this.options?.sigTransportWait !== false;
+                let { signed, path } = await transport.create(this.options.sigTransport, this.builder, { wait: shouldWait });
+                if (path) {
+                    this.onSaved.resolve(path);
+                }
+                if (shouldWait === false) {
+                    return;
+                }
+            }
+            if (this.options?.signature) {
+                let tx = $txData.getJson(this.builder.data, this.client);
+                signedTxBuffer = await $sign.serializeTx(tx, this.options.signature);
+            }
+        }
+
 
         let tx = <TxWriter['tx']> {
             timestamp: Date.now(),
@@ -124,10 +208,22 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
         this.tx = tx;
         this.txs.push(tx);
 
-        let promiEvent = this
-            .client
-            .sendSignedTransaction(signedTxBuffer)
+        let promiEvent: PromiEvent<TransactionReceipt>;
+        if (signedTxBuffer != null) {
+            promiEvent = this
+                .client
+                .sendSignedTransaction(signedTxBuffer);
+        } else {
+            promiEvent = this
+                .client
+                .sendTransaction(this.builder.getTxData(this.client));
+        }
+
+        promiEvent
             .once('transactionHash', hash => {
+                if (tx.hash === hash) {
+                    return;
+                }
                 if (tx.hash && tx.timeout) {
                     // network has reaccepted the tx, restart previous timeout
                     this.clearTimer(tx);
@@ -137,18 +233,7 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
                 tx.hash = hash;
                 this.onSent.resolve(hash);
                 this.emit('transactionHash', hash);
-                this.emit('log', `Tx hash received: ${hash}`);
-            })
-            .once('receipt', receipt => {
-                tx.receipt = receipt;
-                tx.hash = receipt.transactionHash ?? tx.hash;
-
-                this.receipt = receipt;
-                this.clearTimer(tx);
-                this.logger.logReceipt(receipt, Date.now() - time);
-                this.onSent.resolve();
-                this.emit('receipt', receipt);
-                this.emit('log', `Tx receipt received for ${receipt.transactionHash}. Status: ${receipt.status}`);
+                this.emit('log', `Tx hash: ${hash}`);
             })
             // .on('confirmation', (confNumber, receipt) => {
             //     tx.hash = receipt.transactionHash ?? tx.hash;
@@ -166,6 +251,9 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
             //     }
             // })
             .on('error', error => {
+                this.onSent.reject(error);
+                this.onCompleted.reject(error);
+
                 this.clearTimer(tx);
                 this.logger.logError(error);
                 this.emit('error', error);
@@ -176,10 +264,33 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
 
                 try {
                     await this.extractLogs(receipt, tx);
-                } catch (error) { }
-                this.onCompleted.resolve(receipt);
+                } catch (error) {
+                    console.error('Logs error', error);
+                }
+
+                try {
+                    tx.receipt = receipt;
+                    tx.hash = receipt.transactionHash ?? tx.hash;
+
+                    this.receipt = receipt;
+                    this.logger.logReceipt(receipt, Date.now() - time);
+                    this.onSent.resolve();
+                    this.emit('receipt', receipt);
+
+                    let hash = tx.hash;
+                    let status = receipt.status;
+                    let gasFormatted = $gas.formatUsed(this.builder.data, <any>receipt);
+                    this.emit('log', `Tx receipt: ${hash}.\n\tStatus: ${status}.\n\tGas used: ${gasFormatted}`);
+
+                    this.onCompleted.resolve(receipt);
+                } catch (error) {
+                    console.error('FATAL ERROR', error);
+                    throw error;
+                }
 
             }, async (err: Error & { receipt?: TransactionReceipt }) => {
+                this.logger.log(`Tx errored ${err.message}`);
+
                 this.clearTimer(tx);
                 tx.error = err;
 
@@ -190,12 +301,12 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
                     // let client = await this.client.getWeb3();
                     // let tx = await this.client.getTransaction(err.receipt.transactionHash);
 
-                    // console.log('RECEIPT', err.receipt, tx);
+                    // $logger.log('RECEIPT', err.receipt, tx);
                     // try {
                     //     let result = await client.eth.call(tx, tx.blockNumber);
-                    //     console.log('RESULT', result);
+                    //     $logger.log('RESULT', result);
                     // } catch (err) {
-                    //     console.log('CALL ERROR', err);
+                    //     $logger.log('CALL ERROR', err);
                     // }
                     // throw new Error('asd');
                 }
@@ -244,6 +355,27 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
                 this.onCompleted.reject(err);
             });
     }
+
+    private async getSender (): Promise<ChainAccount> {
+        let account = this.account;
+
+        let sender = $account.getSender(account);
+        if (sender.key == null) {
+            /** check the encrypted storage. In case no key is found, assume the target node contains unlocked or locked account */
+            let addressOrName = sender.address ?? sender.name;
+            let service = di.resolve(ChainAccountsService);
+            let fromStorage = await service.get(addressOrName, this.client.platform);
+            if (fromStorage) {
+                sender = fromStorage as ChainAccount;
+            }
+        }
+        return sender;
+    }
+    private getSenderName () {
+        let sender = $account.getSender(this.account);
+        return sender.name ?? sender.address;
+    }
+
     private async extractLogs(receipt: TransactionReceipt, tx: TxWriter['tx']) {
         let parser = di.resolve(TxLogParser);
         let logs = await parser.parse(receipt);
@@ -251,16 +383,21 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
     }
 
     private async fundAccountAndResend () {
-        let account = this.builder.config.gasFunding;
+        let gasFunding = this.builder.config.gasFunding;
+        let sender = $account.getSender(this.account);
         await this.builder.setGas({
             gasEstimation: true,
-            from: this.account.address
+            from: sender.address
         });
-        let { gasPrice, gasLimit } = this.builder.data;
+
+        let { gasLimit } = this.builder.data;
+        let gasPrice = TxDataBuilder.getGasPrice(this.builder);
+
+
         let LITTLE_BIT_MORE = 1.3;
-        let wei = $bigint.multWithFloat(BigInt(gasPrice as any) * BigInt(gasLimit as any), LITTLE_BIT_MORE);
+        let wei = $bigint.multWithFloat(gasPrice * BigInt(gasLimit as any), LITTLE_BIT_MORE);
 
-        let fundTx = await this.transferNative(account, this.account.address, wei);
+        let fundTx = await this.transferNative(gasFunding, sender.address, wei);
         await fundTx.onCompleted;
         // account was funded resubmit the tx
         this.resubmit();
@@ -300,9 +437,21 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
         }
         this.sendTxInner();
     }
+    private pipeInnerWriter (innerWriter: TxWriter) {
+        innerWriter.onCompleted.then(
+            (receipt) => this.onCompleted.resolve(receipt),
+            (error) => this.onCompleted.reject(error)
+        );
+        innerWriter.onSent.then(
+            (hash) => this.onSent.resolve(hash),
+            (error) => this.onSent.reject(error)
+        );
+        innerWriter.on('error', error => this.emit('error', error));
+        innerWriter.on('log', message => this.emit('log', message));
+    }
 
-    /** Use this transfer in case of additional account funding */
-    private async transferNative (from: ChainAccount, to: TAddress, amount: bigint): Promise<TxWriter> {
+    /** Use this transfer also in case of additional account funding */
+    public async transferNative (from: ChainAccount, to: TAddress, amount: bigint): Promise<TxWriter> {
         let txBuilder = new TxDataBuilder(this.client, from, {
             to: to,
             value: $bigint.toHex(amount)
@@ -317,25 +466,44 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
     }
 
     toJSON (): TTxWriterJson {
+        let account = this.account;
+        if (typeof account !== 'string') {
+            account = <ChainAccount | SafeAccount> JSON.parse(JSON.stringify(account));
+            // Clean any KEY to prevent leaking. When resubmitted if one is required should be taken from the storage
+            if ($account.isSafe(account)) {
+                delete account.operator?.key;
+            } else {
+                delete account.key;
+            }
+        }
         return {
             id: this.id,
             platform: this.client.platform,
             options: this.options,
-            account: this.account.address,
+            account: account,
             txs: this.txs,
             builder: this.builder.toJSON(),
         };
     }
 
-    static async fromJSON (json: TTxWriterJson, client?: Web3Client): Promise<TxWriter> {
+    //** We can save the Tx Data for later reuse/blockchain send */
+    async saveTxAndExit (additionalProperties?) {
+        let path = this.options?.txOutput;
+        $require.notNull(path, 'Save tx data to the file, but the path is undefined');
+        await this.builder.save(path, additionalProperties);
+        this.onSent.resolve(path);
+        this.onSaved.resolve(path);
+        this.onCompleted.reject(new Error(`Transaction is not submited to the blockchain. It has been saved to "${path}". Subscribe to the "onSaved" promise instead`))
+    }
+
+    static async fromJSON (json: TTxWriterJson, client?: Web3Client, account?: TAccount): Promise<TxWriter> {
         client = client ?? Web3ClientFactory.get(json.platform);
 
-        let service = di.resolve(ChainAccountsService);
-        let account = await service.get(json.account, json.platform);
+        account = account ?? json.account;
 
         let builder = TxDataBuilder.fromJSON(client, account, {
             config: json.builder.config,
-            data: json.builder.data,
+            tx: json.builder.tx,
         });
         let writer = TxWriter.create(client, builder, account, json.options);
         let txs = json.txs;
@@ -349,22 +517,51 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
     }
 
 
-    static write (client: Web3Client, builder: TxDataBuilder, account: ChainAccount, options?: ITxWriterOptions): TxWriter {
+    static write (
+        client: Web3Client,
+        builder: TxDataBuilder,
+        account: TAccount,
+        options?: ITxWriterOptions
+    ): TxWriter {
         let writer = new TxWriter(client, builder, account);
         writer.write(options);
         return writer;
     }
 
-    static create (client: Web3Client, builder: TxDataBuilder, account: ChainAccount, options?: ITxWriterOptions): TxWriter {
+    static create (
+        client: Web3Client,
+        builder: TxDataBuilder,
+        account: TAccount,
+        options?: ITxWriterOptions
+    ): TxWriter {
         return new TxWriter(client, builder, account);
     }
+
+    static async writeTxData (
+        client: Web3Client,
+        data: Partial<TransactionRequest>,
+        account: TAccount,
+        options?: ITxWriterOptions
+    ): Promise<TxWriter> {
+        let txBuilder = new TxDataBuilder(client, account as IAccount, data);
+
+        await Promise.all([
+            txBuilder.setGas(),
+            txBuilder.setNonce(),
+        ]);
+
+        let w = new TxWriter(client, txBuilder, account);
+        w.send(options);
+        return w;
+    }
 }
 
 export type TTxWriterJson = {
     id: string
     platform: TPlatform
     options: ITxWriterOptions
-    account: TAddress
+    account: TAccount
     txs: TxWriter['txs']
     builder: ReturnType<TxDataBuilder['toJSON']>
 };
+

package/src/txs/conditional/GasWatcherTx.ts

@@ -1,6 +1,5 @@
 import { $bigint } from '@dequanto/utils/$bigint';
 import { $logger } from '@dequanto/utils/$logger';
-import { id } from 'ethers/lib/utils';
 import { TTxWriterJson, TxWriter } from '../TxWriter';
 import { GasWatcherLogger } from './GasWatcherLogger';
 

package/src/txs/receipt/ITxLogItem.ts

@@ -1,14 +1,17 @@
 import { TAddress } from '@dequanto/models/TAddress';
 import { TPlatform } from '@dequanto/models/TPlatform';
-import { AbiItem } from 'web3-utils';
+import { type AbiItem } from 'web3-utils';
 
-export interface ITxLogItem {
-    contract: TAddress
-    name: string
+export interface ITxLogItem<TParams = { [name: string]: any }> {
+    blockNumber: number
+    transactionHash: string
+    address: TAddress
+    event: string
     arguments: {
         name?: string
         value: any
-    }[],
+    }[]
+    params: TParams
 }
 
 export interface ITxLogItemDescriptor {

package/src/txs/receipt/TxLogParser.ts

@@ -2,7 +2,7 @@ import alot from 'alot';
 import { $contract } from '@dequanto/utils/$contract';
 import { TransactionReceipt } from 'web3-core';
 import { TxTopicProvider } from './TxTopicProvider';
-
+import { TPlatform } from '@dequanto/models/TPlatform';
 
 export class TxLogParser {
 
@@ -13,7 +13,11 @@ export class TxLogParser {
 
     }
 
-    async parse (receipt: TransactionReceipt) {
+    /**
+     *  Sparse arrays will contain NULLs for unparsed log items.
+     *  Per default dense arrays - only with known logs - are returned
+     */
+    async parse (receipt: TransactionReceipt, opts?: { sparse?: boolean, platform?: TPlatform }) {
         let logs = await alot(receipt.logs).mapAsync(async log => {
             let topic = await this.topics.get(log.topics[0]);
             if (topic == null) {
@@ -21,9 +25,16 @@ export class TxLogParser {
             }
             let { abi, formatter } = topic;
             let parsed = $contract.parseLogWithAbi(log, abi);
+            if (formatter) {
+                return await formatter.extract(parsed, opts?.platform ?? 'eth');
+            }
             return parsed;
         }).toArrayAsync();
 
+        if (opts?.sparse !== true) {
+            logs = logs.filter(x => x != null);
+        }
+
         return logs;
     }
 }

package/src/txs/receipt/TxLogsTransfer.ts

@@ -1,15 +1,13 @@
 import alot from 'alot';
 import { TPlatform } from '@dequanto/models/TPlatform';
-import { TokensServiceFactory } from '@dequanto/tokens/TokensServiceFactory';
-import { TransactionReceipt } from 'web3-core';
 import { TxWriter } from '../TxWriter';
 import { IKnownLogFormatter, ITxLogItem } from './ITxLogItem';
-import { TxLogParser } from './TxLogParser';
-
 import { IToken } from '@dequanto/models/IToken';
 import { TAddress } from '@dequanto/models/TAddress';
+import { TokenDataProvider } from '@dequanto/tokens/TokenDataProvider';
 
 export interface ITxLogsTransferData {
+    event: string
     token: IToken
     from: TAddress
     to: TAddress
@@ -24,13 +22,14 @@ export class TxLogsTransfer implements IKnownLogFormatter {
 
     async extractFromParsed(knownLogs: ITxLogItem[], platform: TPlatform): Promise<ITxLogsTransferData[]> {
 
-        let transfers = knownLogs.filter(x => x.name === 'Transfer');
-        let tokenService = TokensServiceFactory.get(platform);
+        let transfers = knownLogs.filter(x => x.event === 'Transfer');
+        let tokenService = new TokenDataProvider(platform);
         return alot(transfers).mapAsync(async transfer => {
-            let erc20Address = transfer.contract;
+            let erc20Address = transfer.address;
             let token = await tokenService.getTokenOrDefault(erc20Address);
             let [ from, to, amount ] = transfer.arguments;
             return {
+                event: transfer.event,
                 token,
                 from: from.value,
                 to: to.value,
@@ -39,19 +38,20 @@ export class TxLogsTransfer implements IKnownLogFormatter {
         }).toArrayAsync();
     }
 
-    async extractFromReceipt (receipt: TransactionReceipt, platform: TPlatform): Promise<ITxLogsTransferData[]> {
-        let parser = new TxLogParser();
-        let logs = await parser.parse(receipt);
-        logs = logs.filter(x => x != null);
-        return this.extractFromParsed(logs, platform);
-    }
+    // async extractFromReceipt (receipt: TransactionReceipt, platform: TPlatform): Promise<ITxLogsTransferData[]> {
+    //     let parser = new TxLogParser();
+    //     let logs = await parser.parse(receipt);
+    //     logs = logs.filter(x => x != null);
+    //     return this.extractFromParsed(logs, platform);
+    // }
 
     async extract (transfer: ITxLogItem, platform: TPlatform): Promise<ITxLogsTransferData> {
-        let tokenService = TokensServiceFactory.get(platform);
-        let erc20Address = transfer.contract;
+        let tokenService = new TokenDataProvider(platform);
+        let erc20Address = transfer.address;
         let token = await tokenService.getTokenOrDefault(erc20Address);
         let [ from, to, amount ] = transfer.arguments;
         return {
+            event: transfer.event,
             token,
             from: from.value,
             to: to.value,

package/src/txs/receipt/TxTopicInMemoryProvider.ts

@@ -1,6 +1,6 @@
 import { $abiParser } from '@dequanto/utils/$abiParser';
 import { $abiUtils } from '@dequanto/utils/$abiUtils';
-import { AbiItem } from 'web3-utils';
+import { type AbiItem } from 'web3-utils';
 import { IAbiItemFormattable, IKnownLogFormatter, ITxLogItemDescriptor } from './ITxLogItem';
 
 

package/src/txs/receipt/TxTopicProvider.ts

@@ -1,7 +1,7 @@
 import di from 'a-di';
-import { AbiItem } from 'web3-utils';
+import { type AbiItem } from 'web3-utils';
 import { IAbiItemFormattable, ITxLogItemDescriptor } from './ITxLogItem';
-//import { TxLogsTransfer } from './TxLogsTransfer';
+import { TxLogsTransfer } from './TxLogsTransfer';
 import { TxTopicInMemoryProvider } from './TxTopicInMemoryProvider';
 
 export class TxTopicProvider {
@@ -10,11 +10,11 @@ export class TxTopicProvider {
 
     constructor () {
         this.register([
-            'event Transfer(address from, address to, uint256 amount)'
-            // {
-            //     abi: 'event Transfer(address from, address to, uint256 amount)',
-            //     formatter: di.resolve(TxLogsTransfer)
-            // }
+            //'event Transfer(address from, address to, uint256 amount)'
+            {
+                abi: 'event Transfer(address from, address to, uint256 amount)',
+                formatter: di.resolve(TxLogsTransfer)
+            }
         ]);
     }