dequanto 0.2.55 → 0.2.56

package/src/txs/agents/BatchAgent.ts

@@ -12,6 +12,7 @@ import { $date } from 'dequanto/utils/$date';
 import { $address } from 'dequanto/utils/$address';
 import { $logger } from 'dequanto/utils/$logger';
 import { SafeTx } from 'dequanto/safe/SafeTx';
+import { ZodiacTx } from 'dequanto/zodiac/ZodiacTx';
 import { TimelockController } from 'dequanto/prebuilt/openzeppelin/TimelockController';
 import { TimelockService } from 'dequanto/services/TimelockService/TimelockService';
 import { TxDataBuilder } from '../TxDataBuilder';
@@ -86,7 +87,7 @@ export class BatchAgent implements ITxWriterAgent {
     /**
      * Executes the queued transactions.
      *
-     * By default, duplicate transactions are skipped. If the account is Safe or Timelock,
+     * By default, duplicate transactions are skipped. If the account is Safe, Zodiac, or Timelock,
      * prepares the corresponding calldata and submits it as a batch transaction.
      *
      * @param options.includeDuplicates Include duplicate transactions in the execution batch.
@@ -100,10 +101,10 @@ export class BatchAgent implements ITxWriterAgent {
         if (options?.includeDuplicates !== true) {
             txs = alot(txs).distinctBy(x => {
                 const data = x.outerWriter.builder.data;
-                const acc = x.account ?? x.sender;
-                // remove duplicates by [from,to,data]
+                // Remove duplicates by account, value, target, and calldata.
                 return [
-                    acc.address.toLowerCase(),
+                    this.getAccountKey(x),
+                    String(data.value ?? 0),
                     data.to?.toLowerCase() ?? '',
                     data.data ?? ''
                 ].join('');
@@ -117,10 +118,10 @@ export class BatchAgent implements ITxWriterAgent {
                 ? txs[i + 1]
                 : null;
 
-            let acc0 = tx.account?.address ?? tx.sender?.address;
-            let acc1 = next?.account?.address ?? next?.sender?.address;
+            let acc0 = this.getAccountKey(tx);
+            let acc1 = next == null ? null : this.getAccountKey(next);
 
-            if (next == null || $address.eq(acc0, acc1) === false) {
+            if (next == null || acc0 !== acc1) {
                 let arr = await this.executeGroup(txs.slice(groupStart, i + 1));
                 writers.push(...arr);
                 groupStart = i + 1;
@@ -175,9 +176,34 @@ export class BatchAgent implements ITxWriterAgent {
         return lines.join('\n');
     }
 
+    private getAccountKey (tx: MockTxWriter): string {
+        let account = tx.account ?? tx.sender;
+        let address = (account.address ?? tx.sender?.address)?.toLowerCase();
+        if ($account.isZodiac(account)) {
+            let roleKey = account.roleKey?.toLowerCase() ?? '';
+            return `${address}-${roleKey}`;
+        }
+        return address;
+    }
+
     private async executeGroup (txs: MockTxWriter[]) {
         let { account, sender } = txs[0];
         let acc = account ?? sender;
+        if ($account.isZodiac(acc)) {
+            let first = txs[0].outerWriter;
+            let { client, builder, options } = first;
+            let zodiac = new ZodiacTx({
+                ...acc,
+                operator: sender ?? acc.operator
+            }, client, {
+                builder: builder.config,
+                writer: options,
+            });
+            let calls = txs.map(x => x.outerWriter.builder.getTxData());
+            let writer = await zodiac.executeBatch(...calls);
+            await writer.wait();
+            return [writer];
+        }
         if ($account.isSafe(acc)) {
             let tx = await this.executeBatchSafe(acc, txs);
             return [ tx ];

package/src/txs/agents/TxWriterAccountAgents.ts

@@ -3,6 +3,7 @@ import type { ITxWriterEmitter, TxWriter } from '../TxWriter';
 import { SafeAgent } from './SafeAgent';
 import { Erc4337Agent } from './Erc4337Agent';
 import { TimelockAgent } from './TimelockAgent';
+import { ZodiacAgent } from './ZodiacAgent';
 
 
 export interface ITxWriterAgent {
@@ -17,6 +18,7 @@ export namespace TxWriterAccountAgents {
 
     const agents: ITxWriterAccountAgent[] = [
         new SafeAgent(),
+        new ZodiacAgent(),
         new Erc4337Agent(),
         new TimelockAgent(),
     ];

package/src/txs/agents/ZodiacAgent.ts

@@ -0,0 +1,19 @@
+import { EoAccount, TAccount, ZodiacAccount } from 'dequanto/models/TAccount';
+import { $account } from 'dequanto/utils/$account';
+import { ZodiacTx } from 'dequanto/zodiac/ZodiacTx';
+import { TxWriter } from '../TxWriter';
+import { ITxWriterAccountAgent } from './TxWriterAccountAgents';
+
+export class ZodiacAgent implements ITxWriterAccountAgent {
+    supports (account: TAccount) {
+        return $account.isZodiac(account);
+    }
+
+    async process (sender: EoAccount, account: ZodiacAccount, outerWriter: TxWriter) {
+        let zodiac = new ZodiacTx({ ...account, operator: sender }, outerWriter.client, {
+            builder: outerWriter.builder.config,
+            writer: outerWriter.options,
+        });
+        return zodiac.execute(outerWriter.builder.getTxData());
+    }
+}

package/src/utils/$account.ts

@@ -1,4 +1,4 @@
-import { EoAccount, Erc4337Account, SafeAccount, TAccount, TimelockAccount } from "dequanto/models/TAccount";
+import { EoAccount, Erc4337Account, SafeAccount, TAccount, TimelockAccount, ZodiacAccount } from "dequanto/models/TAccount";
 import { $address } from './$address';
 import { $require } from './$require';
 import { $sig } from './$sig';
@@ -13,7 +13,7 @@ export namespace $account {
             return { name: account };
         }
 
-        let acc = isSafe(account) || isErc4337 (account) || isTimelock(account)
+        let acc = isSafe(account) || isErc4337 (account) || isTimelock(account) || isZodiac(account)
             ? account.operator
             : account;
 
@@ -21,6 +21,10 @@ export namespace $account {
         return acc as EoAccount;
     }
 
+    export function isZodiac (account: TAccount): account is ZodiacAccount {
+        return account != null && typeof account === 'object' && account.type === 'zodiac';
+    }
+
     export function isSafe (account:TAccount): account is SafeAccount {
         if (account == null) {
             return false;

package/src/zodiac/ZodiacTx.ts

@@ -0,0 +1,99 @@
+import { Web3Client } from 'dequanto/clients/Web3Client';
+import { ZodiacAccount } from 'dequanto/models/TAccount';
+import { TEth } from 'dequanto/models/TEth';
+import { config } from 'dequanto/config/Config';
+import { ITxBuilderOptions } from 'dequanto/txs/ITxBuilderOptions';
+import { TxDataBuilder } from 'dequanto/txs/TxDataBuilder';
+import { ITxWriterOptions, TxWriter } from 'dequanto/txs/TxWriter';
+import { $abi } from 'dequanto/abi/$abi';
+import { $abiUtils } from 'dequanto/utils/$abiUtils';
+import { $hex } from 'dequanto/utils/$hex';
+import { $require } from 'dequanto/utils/$require';
+
+type TCall = Pick<TEth.TxLike, 'to' | 'data' | 'value'>;
+
+/** Roles v2 execution. Inner values are paid by the avatar, not the operator. */
+export class ZodiacTx {
+    constructor (
+        public account: ZodiacAccount,
+        public client: Web3Client,
+        public options?: {
+            contracts?: typeof config.safe.contracts
+            builder?: ITxBuilderOptions
+            writer?: ITxWriterOptions
+        }
+    ) {}
+
+    /** Encode a transaction to the Roles Modifier without submitting it. */
+    getTxData (call: TCall, operation: 0 | 1 = 0): TEth.TxLike {
+        $require.Address(this.account.address, 'Zodiac Roles Modifier address');
+        $require.Hex(this.account.roleKey, 'Zodiac roleKey must be hex');
+        $require.Address(call.to, 'Zodiac transaction target');
+        return {
+            to: this.account.address,
+            value: 0n,
+            data: $abi.encodeCall('execTransactionWithRole(address to,uint256 value,bytes data,uint8 operation,bytes32 roleKey,bool shouldRevert)', [
+                call.to,
+                call.value ?? 0n,
+                call.data ?? '0x',
+                operation,
+                $hex.padBytes(this.account.roleKey ?? '0x0', 32),
+                true
+            ])
+        };
+    }
+
+    /** The Roles Modifier must have an unwrapper registered for this MultiSend deployment. */
+    getBatchTxData (...calls: TCall[]): TEth.TxLike {
+        $require.gt(calls.length, 0, 'Zodiac batch must not be empty');
+        let getAddress = (key: 'MultiSend' | 'MultiSendCallOnly') => {
+            return this.options?.contracts?.[this.client.network]?.[key]
+                ?? config.safe?.contracts?.[this.client.network]?.[key];
+        };
+        let multiSendAddress = getAddress('MultiSendCallOnly') ?? getAddress('MultiSend');
+        $require.Address(multiSendAddress, 'Zodiac MultiSend contract');
+        let transactions = calls.map(call => {
+            $require.Address(call.to, 'Zodiac batch transaction target');
+            let data = call.data ?? '0x';
+            return $abiUtils.encodePacked(
+                ['uint8', 0],
+                ['address', call.to],
+                ['uint256', call.value ?? 0n],
+                ['uint256', $hex.getBytesLength(data)],
+                ['bytes', data]
+            );
+        });
+        return this.getTxData({
+            to: multiSendAddress,
+            value: 0n,
+            data: $abi.encodeCall('multiSend(bytes transactions)', [$hex.concat(transactions)])
+        }, 1);
+    }
+
+    async execute (call: TCall) {
+        return this.send(this.getTxData(call));
+    }
+
+    async executeBatch (...calls: TCall[]) {
+        return this.send(this.getBatchTxData(...calls));
+    }
+
+    private async send (data: TEth.TxLike) {
+        $require.notNull(this.account.operator, 'Zodiac operator is required');
+        let sender = await TxWriter.prepareAccount(this.account.operator);
+        let builder = new TxDataBuilder(this.client, sender, data, this.options?.builder);
+        let config = this.options?.builder;
+        await builder.setGas({
+            price: config?.gasPrice,
+            priceRatio: config?.gasPriceRatio,
+            gasLimit: config?.gasLimit,
+            gasLimitRatio: config?.gasLimitRatio,
+            gasEstimation: config?.gasEstimation,
+            from: config?.from ?? sender.address,
+            type: config?.type,
+        });
+        return TxWriter
+            .create(this.client, builder, sender)
+            .send(this.options?.writer);
+    }
+}

package/typings/index.d.ts

@@ -1,5 +1,2 @@
 /// <reference path="globals/assertion/index.d.ts" />
-/// <reference path="globals/atma-utest/index.d.ts" />
-/// <reference path="globals/mask/index.d.ts" />
-/// <reference path="globals/axios/index.d.ts" />
-
+/// <reference path="globals/mocha/index.d.ts" />

package/typings/globals/atma-utest/index.d.ts

@@ -1,53 +0,0 @@
-// Generated by typings
-// Source: https://raw.githubusercontent.com/atmajs/utest/master/types/index.d.ts
-declare module "atma-utest-global" {
-    export = UTest;
-}
-
-declare var UTest: IUtest;
-
-declare interface IUtest {
-    (definition: IUTestDefinition): void
-
-    domtest: IDomTest
-    request (url, method, headers, data, callback)
-    server: {
-        render (template: string, ...args)
-    }
-
-    benchmark (model: IUTestDefinition)
-    benchmarkVersions (model: IUTestDefinition)
-
-}
-
-interface IDomTest {
-    (subject: HTMLElement | JQuery | any, testMarkup: string | any): PromiseLike<any>
-    use (astName: string): IDomTest
-    process (subject: HTMLElement | JQuery | any, testMarkup: string | any): PromiseLike<any>
-}
-
-interface IUTestDefinition {
-    $config?: {
-        timeout?: number
-        errorableCallbacks?: boolean
-        breakOnError?: boolean
-
-        'http.config'?: any
-        'http.eval'?: string
-        'http.include'?: any
-        'http.service'?: any
-        'http.process'?: any
-        'util.process'?: any   
-    }
-    $before?: (done?: Function) => void | PromiseLike<any>
-    $after?: (done?: Function) => void | PromiseLike<any>
-    $teardown?: (done?: Function) => void | PromiseLike<any>
-
-    
-
-    [key: string]: ITestCase | IUTestDefinition | any
-}
-
-interface ITestCase {
-    (done?: Function, ...args: any[]): void | PromiseLike<any> | any
-}

package/typings/globals/atma-utest/typings.json

@@ -1,10 +0,0 @@
-{
-  "resolution": "main",
-  "tree": {
-    "src": "https://raw.githubusercontent.com/atmajs/utest/master/typings.json",
-    "raw": "github:atmajs/utest",
-    "main": "types/index.d.ts",
-    "global": true,
-    "name": "atma-utest-global"
-  }
-}

package/typings/globals/axios/index.d.ts

@@ -1,6 +0,0 @@
-///<reference path="../../../node_modules/axios/index.d.ts"/>
-import { AxiosInstance } from 'axios';
-
-declare global {
-    const axios: AxiosInstance
-}

package/typings/globals/mask/index.d.ts

@@ -1,6 +0,0 @@
-///<reference path="../../../node_modules/maskjs/lib/mask.d.ts"/>
-import { Mask } from 'mask';
-
-declare global {
-    const mask: typeof Mask
-}

package/typings/globals/mask/typings.json

@@ -1,9 +0,0 @@
-{
-  "resolution": "main",
-  "tree": {
-    "src": "https://raw.githubusercontent.com/atmajs/maskjs/master/typings.json",
-    "raw": "github:atmajs/maskjs/typings.json",
-    "main": "types/index.d.ts",
-    "name": "mask"
-  }
-}