dequanto 0.2.53 → 0.2.56

package/src/safe/GnosisSafeHandler.ts

@@ -45,10 +45,10 @@ export class GnosisSafeHandler {
         this.client = config.client ?? di.resolve(EthWeb3Client);
         this.transport = config.transport ?? (
             config.owners.length > 1
-            // when multiple owners are provided assume the transport is InMemory
-            ? new InMemoryServiceTransport(this.client, this.owners[0])
-            // otherwise use the default Safe Transaction Service
-            : new SafeServiceTransport(this.client, this.owners)
+                // when multiple owners are provided assume the transport is InMemory
+                ? new InMemoryServiceTransport(this.client, this.owners[0])
+                // otherwise use the default Safe Transaction Service
+                : new SafeServiceTransport(this.client, this.owners)
         )
 
         $require.Address(this.safeAddress, `Safe address ${this.safeAddress} is not valid`);
@@ -147,7 +147,7 @@ export class GnosisSafeHandler {
         return tx;
     }
 
-    async executeTxData (txData: TEth.TxLike, owner: EoAccount, safeTxParams?: {
+    async executeTxData(txData: TEth.TxLike, owner: EoAccount, safeTxParams?: {
         // 0 - Call (default)
         // 1 - DelegateCall
         operation?: 0 | 1
@@ -158,7 +158,7 @@ export class GnosisSafeHandler {
         return tx;
     }
 
-    async createTxHash (builder: TxDataBuilder, value?: bigint, safeTxParams?: {
+    async createTxHash(builder: TxDataBuilder, value?: bigint, safeTxParams?: {
         operation?: 0 | 1
     }) {
         let txData = builder.getTxData(this.client);
@@ -234,7 +234,7 @@ export class GnosisSafeHandler {
         let txProps: SafeServiceTypes.ProposeTransactionProps = {
             safeAddress: $address.toChecksum(this.safeAddress),
             senderAddress: $address.toChecksum(owner.address),
-            safeTransaction: <SafeServiceTypes.SafeTransaction> {
+            safeTransaction: <SafeServiceTypes.SafeTransaction>{
                 data: safeTxData,
                 signatures: signatures,
             },
@@ -286,11 +286,11 @@ export class GnosisSafeHandler {
         })
     }
 
-    static parseSafeTx(buffer: TEth.Hex, value?): { name, args: any[]} {
-        return $abiUtils.parseMethodCallData([ SafeAbi.execTransaction ], { input: buffer, value });
+    static parseSafeTx(buffer: TEth.Hex, value?): { name, args: any[] } {
+        return $abiUtils.parseMethodCallData([SafeAbi.execTransaction], { input: buffer, value });
     }
 
-    static async getInstance (senderMix: string | EoAccount, safeAccount: SafeAccount, client: Web3Client, options: {
+    static async getInstance(senderMix: string | EoAccount, safeAccount: SafeAccount, client: Web3Client, options: {
         transport?: ISafeServiceTransport
         contracts?: typeof config.safe.contracts
     }): Promise<GnosisSafeHandler> {
@@ -298,7 +298,7 @@ export class GnosisSafeHandler {
             ? await ChainAccountService.get(senderMix) as EoAccount
             : senderMix;
 
-        let owners = [ sender ];
+        let owners = [sender];
 
         if (safeAccount.owners) {
             let others = await alot(safeAccount.owners)
@@ -408,7 +408,7 @@ const SafeAbi = {
             }
         ]
     },
-    getTransactionHash: <TAbiItem> {
+    getTransactionHash: <TAbiItem>{
         "type": "function",
         "stateMutability": "view",
         "outputs": [

package/src/services/TimelockService/ITimelockService.ts

@@ -67,6 +67,8 @@ export interface ITimelockService {
 }
 
 export interface ITimelockTx {
+    timelock?: TEth.Address
+
     // operation hash, unique as includes random salt
     id: TEth.Hex
     // operation key, should be unique only within pending operations

package/src/services/TimelockService/TimelockService.ts

@@ -86,10 +86,10 @@ export class TimelockService implements ITimelockService {
         let [ callSalt ] = callSaltArr;
 
         let [ callScheduleFirst ] = callScheduled;
-        callScheduleFirst.params.delay
 
         let schedule = {
             sender: null,
+            timelock: callScheduleFirst.address,
             key: callSalt.params.id,
             id: callSalt.params.id,
             salt: callSalt.params.salt,

package/src/solidity/utils/$types.ts

@@ -2,6 +2,7 @@ import { $abiParser } from 'dequanto/utils/$abiParser';
 import { $abiType } from 'dequanto/utils/$abiType';
 import { $abiUtils } from 'dequanto/utils/$abiUtils';
 import alot from 'alot';
+import { type TAbiInput } from 'dequanto/types/TAbi';
 
 export namespace $types {
     export function isFixedArray (type: string) {
@@ -23,6 +24,11 @@ export namespace $types {
     }
 
 
+    /**
+     * Returns the type size in bits, excluding ABI padding.
+     * Sums element sizes for fixed arrays and tuple declarations.
+     * Returns Infinity for dynamic or unknown types.
+     */
     export function sizeOf(type: string) {
         if (type === 'address') {
             // 20bytes
@@ -58,4 +64,25 @@ export namespace $types {
         }
         return Infinity;
     }
+
+    /** Number of 32-byte ABI words; Infinity for dynamic or unknown types. */
+    export function wordSizeOf(type: string | TAbiInput): number {
+        let input = typeof type === 'string' ? { type } : type;
+        let name = input.type.trim();
+        if (isFixedArray(name)) {
+            let baseType = $abiType.array.getBaseType(name);
+            let words = wordSizeOf({ ...input, type: baseType });
+            return Number.isFinite(words) ? words * $abiType.array.getLength(name) : Infinity;
+        }
+        if (isDynamicArray(name)) {
+            return Infinity;
+        }
+        if (name === 'tuple') {
+            return input.components == null ? Infinity : alot(input.components).sum(x => wordSizeOf(x));
+        }
+        if (isStruct(name) || name === '()') {
+            return alot($abiParser.parseArguments(name)).sum(x => wordSizeOf(x));
+        }
+        return Math.ceil(sizeOf(name) / 256);
+    }
 }

package/src/txs/TxWriter.ts

@@ -673,10 +673,12 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> implements ITx
         let account = await TxWriter.prepareAccount(accountMix);
         let txBuilder = new TxDataBuilder(client, account, data);
 
-        await Promise.all([
-            txBuilder.ensureGas(),
-            txBuilder.ensureNonce(),
-        ]);
+        if (await TxWriter.hasAgent(account) === false) {
+            await Promise.all([
+                txBuilder.ensureGas(),
+                txBuilder.ensureNonce(),
+            ]);
+        }
 
         let w = new TxWriter(client, txBuilder, account);
         w.send(options);

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"
-  }
-}