dequanto 0.0.1 → 0.1.3

package/src/txs/TxWriter.ts

@@ -1,34 +1,68 @@
+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 { class_Dfr, class_EventEmitter, obj_extend } from 'atma-utils';
+
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $txData } from '@dequanto/utils/$txData';
+
+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 { $require } from '@dequanto/utils/$require';
+import { $contract } from '@dequanto/utils/$contract';
+import { $error } from '@dequanto/utils/$error';
+
+import type { 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 { EoAccount, Erc4337Account, 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 { ISafeServiceTransport } from '@dequanto/safe/transport/ISafeServiceTransport';
+import { SigFileTransport } from './sig-transports/SigFileTransport';
+import { TxWriterAccountAgents } from './agents/TxWriterAccountAgents';
+import { PromiseEvent } from '@dequanto/class/PromiseEvent';
+import { $sig } from '@dequanto/utils/$sig';
+import { TEth } from '@dequanto/models/TEth';
+import { SafeServiceTypes } from '@dequanto/safe/types/SafeServiceTypes';
+import { ChainAccountService } from '@dequanto/ChainAccountService';
+import { $is } from '@dequanto/utils/$is';
+
 interface ITxWriterEvents {
-    transactionHash (hash: string)
-    receipt (receipt: TransactionReceipt)
-    confirmation (confNumber: number, receipt: TransactionReceipt)
+    transactionHash (hash: TEth.Hex)
+    receipt (receipt: TEth.TxReceipt)
+    confirmation (confNumber: number, receipt: TEth.TxReceipt)
     error (error: Error)
     sent ()
-    log (message: string);
+    log (message: string)
+    safeTxProposed (safeTx: SafeServiceTypes.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
+
+    /** Save the tx data to the file (before agents run, if any) */
+    txOutput?: string
+
+    /** Proceed the Tx up to the signature */
+    signOnly?: boolean
+
+    /** Provide a pre-signed signature for this transaction data. */
+    signature?: TEth.Hex
 
     /**
      * The callback is executed on error, to give the opportunity to build a new Tx to resubmit the tx.
@@ -36,14 +70,25 @@ export interface ITxWriterOptions {
      * @param error - current Error with receipt(if any)
      * @param errCount - num of errors already handled
      */
-    onErrorRebuild? (tx: TxWriter, error: Error & { receipt?: TransactionReceipt }, errCount: number): Promise<TxDataBuilder>
+    onErrorRebuild? (tx: TxWriter, error: Error & { receipt?: TEth.TxReceipt }, errCount: number): Promise<TxDataBuilder>
+
+    /**
+     * Do not log Transaction states (start, receipt, etc)
+     */
+    silent?: boolean
 }
 
+const DEFAULTS: ITxWriterOptions = {};
+
 export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
 
-    onSent = new class_Dfr<string>();
-    onCompleted = new class_Dfr<TransactionReceipt>();
-    receipt: TransactionReceipt
+    onSent = new class_Dfr<string | TEth.Hex>();
+    onCompleted = new class_Dfr<TEth.TxReceipt>();
+    onSaved = new class_Dfr<string>();
+
+    onSigned = new class_Dfr<TEth.Hex>();
+
+    receipt: TEth.TxReceipt
 
     onConfirmed (waitForCount: number): Promise<string> {
         let promise = new class_Dfr();
@@ -58,13 +103,17 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
         return promise as any;
     }
 
+    wait (): Promise<TEth.TxReceipt> {
+        return this.onCompleted as any as Promise<TEth.TxReceipt>;
+    }
+
     id = Math.round(Math.random() * 10**10) + '';
     tx: {
         timestamp: number
         confirmations: number,
-        hash?: string
+        hash?: TEth.Hex
         timeout?: NodeJS.Timer
-        receipt?: TransactionReceipt
+        receipt?: TEth.TxReceipt
         error?: Error
         knownLogs?: ITxLogItem[]
     } = null
@@ -73,20 +122,18 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
     options: ITxWriterOptions;
 
 
-    private logger = new TxLogger(
-        this.id,
-        this.account.name ?? this.account.key,
-        this.builder
-    );
+    private logger: TxLogger;
     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();
+
+        this.options = obj_extend({}, DEFAULTS);
+        this.logger = new TxLogger(this.id, this.getSenderName(), this.builder);
     }
 
     public send (options?: ITxWriterOptions): this {
@@ -97,22 +144,75 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
             this.onSent.defer();
 
             // was not sent
-            this.options = options;
+            if (options) {
+                this.options = obj_extend(this.options, options);
+            }
             this.sendTxInner();
         }
         return this;
     }
 
+    public async call() {
+        let tx = await this.builder.getTxData(this.client);
+        let result = await this.client.call(tx);
+        return result;
+    }
+
     protected write (options?: ITxWriterOptions) {
         if (this.builder?.config?.send !== 'manual') {
             this.send(options);
         }
     }
 
-    private sendTxInner () {
+    private async sendTxInner () {
+        if (this.options?.txOutput != null) {
+            // handle none blockchain
+            await this.saveTxAndExit()
+            return;
+        }
+
+        let agent = TxWriterAccountAgents.get(this.account);
+        if (agent != null) {
+            let sender = await this.getSender();
+            let innerWriter = await agent.process(sender, this.account, this);
+            this.pipeInnerWriter(innerWriter);
+            return;
+        }
+
         let time = Date.now();
-        let signedTxBuffer = this.builder.signToString(this.account.key);
+        let sender: EoAccount = await this.getSender();
+        try {
+            await Promise.all([
+                this.builder.ensureNonce(),
+                this.builder.ensureGas(),
+            ]);
+        } catch (error) {
+            this.onCompleted.reject(error);
+            return;
+        }
 
+        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 $sig.TxSerializer.serialize(tx, this.options.signature);
+            }
+        }
         let tx = <TxWriter['tx']> {
             timestamp: Date.now(),
             confirmations: 0,
@@ -124,11 +224,31 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
         this.tx = tx;
         this.txs.push(tx);
 
-        let promiEvent = this
-            .client
-            .sendSignedTransaction(signedTxBuffer)
+        let promiseEvent: PromiseEvent<TEth.TxReceipt>;
+        if (signedTxBuffer != null) {
+
+            this.onSigned.resolve(signedTxBuffer);
+            if (this.options?.signOnly === true) {
+                this.onCompleted.reject(new Error(`SIGN_ONLY: Tx not completed as only signature is awaited`));
+                return;
+            }
+            promiseEvent = this
+                .client
+                .sendSignedTransaction(signedTxBuffer);
+
+        } else {
+            let txData = this.builder.getTxData(this.client);
+            promiseEvent = this
+                .client
+                .sendTransaction(txData);
+        }
+
+        promiseEvent
             .once('transactionHash', hash => {
-                if (tx.hash && tx.timeout) {
+                if (tx.hash === hash) {
+                    return;
+                }
+                if (tx.hash != null && tx.timeout != null) {
                     // network has reaccepted the tx, restart previous timeout
                     this.clearTimer(tx);
                     tx.timeout = this.startTimer(tx);
@@ -137,18 +257,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;
@@ -165,7 +274,11 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
             //         }
             //     }
             // })
-            .on('error', error => {
+            .on('error', (error: Error & {data?, transactionHash?}) => {
+
+                this.onSent.reject(error);
+                this.onCompleted.reject(error);
+
                 this.clearTimer(tx);
                 this.logger.logError(error);
                 this.emit('error', error);
@@ -176,28 +289,54 @@ 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?: TEth.TxReceipt, data, transactionHash? }) => {
+                if (err.data != null && this.builder.abi != null) {
+                    err.data = $contract.decodeCustomError(err.data, this.builder.abi);
+                    $error.normalizeEvmCustomError(err);
+                }
+
+                this.logger.log(`Tx errored ${err.message}`);
 
-            }, async (err: Error & { receipt?: TransactionReceipt }) => {
                 this.clearTimer(tx);
                 tx.error = err;
+                tx.hash = err.transactionHash ?? tx.receipt?.transactionHash ?? tx.hash;
 
                 const options = this.options ?? {};
 
-                if (err.receipt?.status === false) {
+                if (err.receipt?.status !== 1) {
                     // read reason
-                    // let client = await this.client.getWeb3();
+                    // let rpc = await this.client.getRpc();
                     // let tx = await this.client.getTransaction(err.receipt.transactionHash);
 
-                    // console.log('RECEIPT', err.receipt, tx);
                     // try {
-                    //     let result = await client.eth.call(tx, tx.blockNumber);
-                    //     console.log('RESULT', result);
+                    //     let result = await rpc.eth_call(tx, tx.blockNumber);
                     // } catch (err) {
-                    //     console.log('CALL ERROR', err);
+                    //     $logger.log('CALL ERROR', err);
                     // }
-                    // throw new Error('asd');
                 }
 
                 if (ClientErrorUtil.IsInsufficientFunds(err)) {
@@ -210,7 +349,7 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
                     if (options.retries == null) {
                         options.retries = 1;
                         options.retryDelay = 5000;
-                        // If insufficient funds this is can be due to the blockchain hasn't confirmed some incomming transactions
+                        // If insufficient funds this is can be due to the blockchain hasn't confirmed some incoming transactions
                     }
                 }
                 if (ClientErrorUtil.IsNonceTooLow(err)) {
@@ -220,7 +359,7 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
                     let nonce = this.builder.data.nonce;
                     // reset nonce
                     await this.builder.setNonce();
-                    this.logger.log(`Nonce was ${Number(nonce)} too low. Reetries left: ${options.retries}. New nonce: ${Number(this.builder.data.nonce)}`);
+                    this.logger.log(`Nonce was ${Number(nonce)} too low. Retries left: ${options.retries}. New nonce: ${Number(this.builder.data.nonce)}`);
                 }
 
                 let submitsCount = this.txs.length;
@@ -241,26 +380,60 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
                     this.resubmit({ increaseGas: false });
                     return;
                 }
+
                 this.onCompleted.reject(err);
             });
     }
-    private async extractLogs(receipt: TransactionReceipt, tx: TxWriter['tx']) {
+
+    public catch (fn) {
+        return this.onCompleted.catch(fn);
+    }
+
+    private async getSender (): Promise<EoAccount> {
+        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(ChainAccountService);
+            let fromStorage = await service.get(addressOrName, { platform: this.client.platform });
+            if (fromStorage) {
+                sender = fromStorage as EoAccount;
+            }
+        }
+        return sender;
+    }
+    private getSenderName () {
+        let sender = $account.getSender(this.account);
+        return (sender.name as any) ?? sender.address;
+    }
+
+    private async extractLogs(receipt: TEth.TxReceipt, tx: TxWriter['tx']) {
         let parser = di.resolve(TxLogParser);
-        let logs = await parser.parse(receipt);
+        let logs = await parser.parse(receipt, {
+            platform: this.client.network,
+            abi: this.builder.abi,
+        });
         tx.knownLogs = logs.filter(x => x != null);
     }
 
     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 { gas } = 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(gas 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();
@@ -281,16 +454,16 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
         return setTimeout(() => {
             if (this.txs.length > 3) {
                 let hashes = this.txs.map(x => x.hash).join(', ')
-                this.onCompleted.reject(new Error(`${this.txs.length} retries timeouted, with hashes: ${ hashes }`))
+                this.onCompleted.reject(new Error(`${this.txs.length} retries timed out, with hashes: ${ hashes }`))
                 return;
             }
-            tx.error = new Error(`Timeouted ${ms}ms`);
+            tx.error = new Error(`Timed out ${ms}ms`);
             this.resubmit()
         }, ms);
     }
     private clearTimer (tx: TxWriter['tx']) {
         if (tx.timeout) {
-            clearTimeout(tx.timeout);
+            clearTimeout(tx.timeout as any);
             tx.timeout = null;
         }
     }
@@ -300,9 +473,27 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
         }
         this.sendTxInner();
     }
+    private pipeInnerWriter (innerWriter: TxWriter) {
+        innerWriter.onCompleted.then(
+            (receipt) => {
+                this.tx = innerWriter.tx;
+                this.receipt = 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: EoAccount, to: TAddress, amount: bigint): Promise<TxWriter> {
         let txBuilder = new TxDataBuilder(this.client, from, {
             to: to,
             value: $bigint.toHex(amount)
@@ -317,25 +508,47 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
     }
 
     toJSON (): TTxWriterJson {
+        let account = this.account;
+        let accountJson: string | any;
+        if (typeof account !== 'string') {
+            accountJson = JSON.parse(JSON.stringify(account)) as (EoAccount | SafeAccount | Erc4337Account);
+            // Clean any KEY to prevent leaking. When resubmitted if one is required should be taken from the storage
+            if ('operator' in accountJson) {
+                delete accountJson.operator.key;
+            } else {
+                delete accountJson.key;
+            }
+        } else {
+            accountJson = account;
+        }
         return {
             id: this.id,
             platform: this.client.platform,
             options: this.options,
-            account: this.account.address,
+            account: accountJson,
             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 submitted 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 +562,73 @@ 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: IAccount,
+        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<TEth.TxLike>,
+        accountMix: TAccount,
+        options?: ITxWriterOptions
+    ): Promise<TxWriter> {
+        let account = await TxWriter.prepareAccount(accountMix);
+        let txBuilder = new TxDataBuilder(client, account, data);
+
+        await Promise.all([
+            txBuilder.ensureGas(),
+            txBuilder.ensureNonce(),
+        ]);
+
+        let w = new TxWriter(client, txBuilder, account);
+        w.send(options);
+        return w;
+    }
+
+    static async prepareAccount (account: TAccount): Promise<IAccount> {
+        if (typeof account !== 'string') {
+            return account;
+        }
+        let service = di.resolve(ChainAccountService);
+        let stored = await service.get(account);
+        if (stored != null) {
+            return stored;
+        }
+        if ($is.Address(account)) {
+            return {
+                address: account
+            };
+        }
+        throw new Error(`Account ${account} not found`);
+    }
+
+    static defaultOptions (options: ITxWriterOptions) {
+        obj_extend(DEFAULTS, options);
+    }
+    static DEFAULTS = DEFAULTS
 }
 
 export type TTxWriterJson = {
     id: string
     platform: TPlatform
     options: ITxWriterOptions
-    account: TAddress
+    account: TAccount
     txs: TxWriter['txs']
     builder: ReturnType<TxDataBuilder['toJSON']>
 };

package/src/txs/agents/Erc4337Agent.ts

@@ -0,0 +1,32 @@
+import type { TxWriter } from '../TxWriter';
+
+import { EoAccount, Erc4337Account, TAccount } from '@dequanto/models/TAccount';
+import { ITxWriterAccountAgent } from './TxWriterAccountAgents';
+import { $account } from '@dequanto/utils/$account';
+import { Erc4337Factory } from '@dequanto/erc4337/Erc4337Factory';
+
+export class Erc4337Agent implements ITxWriterAccountAgent {
+    supports (account: TAccount) {
+        return $account.isErc4337(account);
+    }
+    async process (sender: EoAccount, account: Erc4337Account, outerWriter: TxWriter) {
+
+        let { client, builder } = outerWriter;
+
+        let erc4337TxWriter = Erc4337Factory.createWriter({
+            client: client,
+            platform: client.platform,
+        });
+        let tx = builder.getTxData(client);
+        let { writer: opWriter } = await erc4337TxWriter.submitUserOpViaEntryPointWithOwner({
+            erc4337Account: {
+                address: account.address
+            },
+            tx,
+            owner: sender,
+            submitter: sender,
+        });
+
+        return opWriter;
+    }
+}

package/src/txs/agents/SafeAgent.ts

@@ -0,0 +1,20 @@
+import { EoAccount, SafeAccount, TAccount } from '@dequanto/models/TAccount';
+import { ITxWriterAccountAgent } from './TxWriterAccountAgents';
+import { $account } from '@dequanto/utils/$account';
+import { GnosisSafeHandler } from '@dequanto/safe/GnosisSafeHandler';
+import { TxWriter } from '../TxWriter';
+
+export class SafeAgent implements ITxWriterAccountAgent {
+    supports (account: TAccount) {
+        return $account.isSafe(account);
+    }
+    async process (senderMix: string | EoAccount, safeAccount: SafeAccount, outerWriter: TxWriter) {
+
+        let { client, options } = outerWriter;
+        let safe = await GnosisSafeHandler.getInstance(senderMix, safeAccount, client, {
+            transport: options?.safeTransport
+        });
+        let innerWriter = await safe.execute(outerWriter);
+        return innerWriter;
+    }
+}