dequanto 0.2.55 → 0.2.56

package/skills/dequanto/examples/hardhat-fork.spec.ts

@@ -1,9 +1,10 @@
+import { UTest } from 'atma-utest';
 import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
 import { ERC20 } from 'dequanto/prebuilt/openzeppelin/ERC20';
 import { $erc20 } from 'dequanto/utils/$erc20';
 import { $require } from 'dequanto/utils/$require';
 
-UTest({
+UTest.create({
     async 'set an ERC20 balance and transfer from an impersonated account on a fork' () {
         // Requires an accessible Ethereum RPC from the dequanto configuration.
         const client = await Web3ClientFactory.getAsync('hh:memory:eth');

package/skills/dequanto/examples/index-events.spec.ts

@@ -1,9 +1,10 @@
+import { UTest } from 'atma-utest';
 import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
 import { EventsIndexer } from 'dequanto/indexer/EventsIndexer';
 import { ERC20 } from 'dequanto/prebuilt/openzeppelin/ERC20';
 import { $require } from 'dequanto/utils/$require';
 
-UTest({
+UTest.create({
     async 'index stable USDC Transfer logs from live Ethereum RPC' () {
         const client = await Web3ClientFactory.getAsync('eth');
         const usdc = new ERC20('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', client);

package/skills/dequanto/examples/live-events.spec.ts

@@ -1,3 +1,4 @@
+import { UTest } from 'atma-utest';
 import { TEth } from 'dequanto/models/TEth';
 import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
 import { ERC20 } from 'dequanto/prebuilt/openzeppelin/ERC20';
@@ -9,7 +10,7 @@ import { $require } from 'dequanto/utils/$require';
 const USDC = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48' as const;
 const TRANSFER_AMOUNT = 1_000_000n; // 1 USDC (6 decimals).
 
-UTest({
+UTest.create({
     $config: {
         timeout: 60_000
     },

package/skills/dequanto/examples/revert-error.spec.ts

@@ -1,3 +1,4 @@
+import { UTest } from 'atma-utest';
 import { HardhatProvider } from 'dequanto/hardhat/HardhatProvider';
 import { $account } from 'dequanto/utils/$account';
 import { $promise } from 'dequanto/utils/$promise';
@@ -8,7 +9,7 @@ import { $require } from 'dequanto/utils/$require';
 // if it reverts, dequanto catches the revert, decodes any custom error bytecode using the ABI,
 // captures execution traces, and throws a standard JavaScript Error.
 // If gas estimation succeeds but the transaction reverts on-chain later, the error flow is identical.
-UTest({
+UTest.create({
     async 'catch automatic revert and decode custom error without manual simulation' () {
         const hh = new HardhatProvider();
         const client = hh.client();

package/skills/dequanto/examples/rpc-read.spec.ts

@@ -1,10 +1,11 @@
+import { UTest } from 'atma-utest';
 import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
 import { BlockDateResolver } from 'dequanto/blocks/BlockDateResolver';
 import { Config } from 'dequanto/config/Config';
 import { $date } from 'dequanto/utils/$date';
 import { $require } from 'dequanto/utils/$require';
 
-UTest({
+UTest.create({
     async 'read common RPC data via Web3Client directly' () {
         const cfg = await Config.fetch();
 
@@ -51,9 +52,22 @@ UTest({
         const info = await resolver.getBlockInfoFor(date);
         const blockDate = await resolver.getDate(blockNumber);
 
-        $require.eq(blockNumber, 24576295);
-        $require.eq(blockNumber, 24576295);
-        $require.lte(Math.abs($date.toUnixTimestamp(date) - info.timestamp), 1);
-        $require.eq(blockDate.toISOString(), new Date('2026-03-03T10:19:59Z').toISOString());
+        /* max ~1 block diff */
+        const block = {
+            24576294: {
+                nr: 24576294,
+                date: new Date('2026-03-03T10:19:47Z'),
+            },
+            24576295: {
+                nr: 24576295,
+                date: new Date('2026-03-03T10:19:59Z'),
+            }
+        };
+        const blockData = block[info.block];
+        $require.notNull(blockData, `No info for the fetched block ${info.block}`);
+        $require.eq(blockNumber, info.block);
+        $require.eq(blockDate.toISOString(), blockData.date.toISOString());
+        $require.lte(Math.abs($date.toUnixTimestamp(blockData.date) - info.timestamp), 1);
+
     }
 });

package/skills/dequanto/examples/safe-batch.spec.ts

@@ -1,12 +1,63 @@
+import { UTest } from 'atma-utest';
+import { Config } from 'dequanto/config/Config';
+import { GnosisSafeFactory } from 'dequanto/safe/GnosisSafeFactory';
+import { BatchAgent } from 'dequanto/txs/agents/BatchAgent';
+import { TxWriter } from 'dequanto/txs/TxWriter';
 import { HardhatProvider } from 'dequanto/hardhat/HardhatProvider';
 import { InMemoryServiceTransport } from 'dequanto/safe/transport/InMemoryServiceTransport';
 import { SafeTx } from 'dequanto/safe/SafeTx';
 import { $address } from 'dequanto/utils/$address';
 import { $require } from 'dequanto/utils/$require';
 import { SafeAccount } from 'dequanto/models/TAccount';
+import { Web3Client } from 'dequanto/clients/Web3Client';
+import { TEth } from 'dequanto/models/TEth';
 
-UTest({
-    async 'build a Safe batch from generated tx data' () {
+UTest.create({
+    async 'collect normal contract calls and execute one Safe batch'() {
+        let provider = new HardhatProvider();
+        let client = provider.client();
+        let owner = provider.deployer(0);
+        let receiver = provider.deployer(1);
+
+        // Local setup; on a live network, use an existing Safe and configured MultiSend.
+        let { safeAddress } = await deployLocalTestSafe(owner, provider, client);
+        let { token } = await deployLocalTestToken(provider, client);
+        let safe: SafeAccount = {
+            type: 'safe',
+            platform: client.platform,
+            address: safeAddress,
+            operator: owner,
+            owners: [owner]
+        };
+
+        // Dequanto signs and executes when available signers meet the Safe threshold.
+        // Otherwise, it submits to the Safe Service API and waits for confirmations.
+        TxWriter.DEFAULTS.safeTransport = new InMemoryServiceTransport(client, owner);
+
+        let batch = new BatchAgent().enable();
+        try {
+            // Normal write calls return mock receipts and queue transactions without submitting them.
+            await token.$receipt().transfer(safe, receiver.address, 50n);
+            await token.$receipt().transfer(safe, receiver.address, 25n);
+
+            $require.eq(batch.transactions.length, 2);
+            $require.eq(await token.received(receiver.address), 0n);
+
+            // Detects the Safe sender and submits both calls as one Safe batch transaction.
+            let writers = await batch.execute();
+
+            $require.eq(writers.length, 1);
+            $require.eq(await token.received(receiver.address), 75n);
+            $require.True($address.eq(await token.lastSender(), safe.address));
+
+        } finally {
+            batch.disable();
+            TxWriter.DEFAULTS.agent = null;
+            TxWriter.DEFAULTS.safeTransport = null;
+        }
+    },
+
+    async 'build a Safe batch from generated tx data'() {
         const provider = new HardhatProvider();
         const client = provider.client();
         const owner1 = provider.deployer(0);
@@ -53,4 +104,42 @@ UTest({
         });
         $require.notNull(safeTx);
     }
-});
+});
+
+
+async function deployLocalTestSafe(owner: TEth.EoAccount, provider: HardhatProvider, client: Web3Client) {
+    let config = await Config.get();
+    let { contract: singleton } = await provider.deploySol('/test/fixtures/gnosis/GnosisSafe.sol', { client });
+    let { contract: proxyFactory } = await provider.deploySol('/test/fixtures/gnosis/proxies/GnosisSafeProxyFactory.sol', { client });
+    let { contract: multiSend } = await provider.deploySol('/test/fixtures/gnosis/libraries/MultiSend.sol', { client });
+
+    config.safe.contracts[client.platform] = {
+        Safe: singleton.address,
+        SafeProxyFactory: proxyFactory.address,
+        MultiSend: multiSend.address
+    };
+
+    let handler = await GnosisSafeFactory.create(owner, client, {
+        owners: [owner.address]
+    });
+
+    return {
+        safeAddress: handler.safeAddress
+    };
+}
+
+async function deployLocalTestToken(provider: HardhatProvider, client: Web3Client) {
+    let { contract: token } = await provider.deployCode(`
+        contract Token {
+            mapping(address => uint256) public received;
+            address public lastSender;
+            function transfer(address to, uint256 amount) external returns (bool) {
+                received[to] += amount;
+                lastSender = msg.sender;
+                return true;
+            }
+        }
+    `, { client });
+
+    return { token };
+}

package/skills/dequanto/examples/send-transaction.spec.ts

@@ -1,3 +1,4 @@
+import { UTest } from 'atma-utest';
 import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
 import { TxDataBuilder } from 'dequanto/txs/TxDataBuilder';
 import { TxWriter } from 'dequanto/txs/TxWriter';
@@ -6,7 +7,7 @@ import { $address } from 'dequanto/utils/$address';
 import { $number } from 'dequanto/utils/$number';
 import { $require } from 'dequanto/utils/$require';
 
-UTest({
+UTest.create({
     async 'build native transfer tx data with gas fields' () {
         const client = await Web3ClientFactory.getAsync('hh:memory');
         const alice = $account.generate('alice');

package/skills/dequanto/examples/storage.spec.ts

@@ -1,3 +1,4 @@
+import { UTest } from 'atma-utest';
 import { AavePool } from '../../../0xc/eth/AavePool/AavePool';
 import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
 import { HardhatProvider } from 'dequanto/hardhat/HardhatProvider';
@@ -7,7 +8,7 @@ import { $require } from 'dequanto/utils/$require';
 
 // Generated classes include the storage layout: use instance.storage.$set(name, value).
 // SlotsParser and SlotsStorage provide the low-level alternative for Solidity source.
-UTest({
+UTest.create({
     async 'read and set AavePool storage by variable name on an Ethereum fork' () {
         const client = await Web3ClientFactory.getAsync('hh:memory:eth');
         const pool = new AavePool(undefined, client);

package/skills/dequanto/examples/token-transfer.spec.ts

@@ -1,3 +1,4 @@
+import { UTest } from 'atma-utest';
 import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
 import { ERC20 } from 'dequanto/prebuilt/openzeppelin/ERC20';
 import { $account } from 'dequanto/utils/$account';
@@ -8,7 +9,7 @@ const USDC = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48' as const;
 const INITIAL_SENDER_BALANCE = 100_000_000n;
 const TRANSFER_AMOUNT = 42_000_000n;
 
-UTest({
+UTest.create({
     async 'transfer USDC with a prebuilt ERC20 contract class' () {
         const client = await Web3ClientFactory.getAsync('hh:memory:eth');
         const sender = $account.generate('sender');

package/skills/dequanto/examples/utils.spec.ts

@@ -1,3 +1,4 @@
+import { UTest } from 'atma-utest';
 import { $abi } from 'dequanto/abi/$abi';
 import { $contract } from 'dequanto/utils/$contract';
 import { $date } from 'dequanto/utils/$date';
@@ -8,7 +9,7 @@ import { $sig } from 'dequanto/utils/$sig';
 
 const ACCOUNT = '0x0000000000000000000000000000000000000002';
 
-UTest({
+UTest.create({
     'encode and decode ABI values and calldata' () {
         const encoded = $abi.encode(['address', 'uint256'], [ACCOUNT, 5n]);
         const [account, amount] = $abi.decode(['address', 'uint256'], encoded);

package/skills/dequanto/references/safe-erc4337.md

@@ -1,6 +1,6 @@
-# Safe And ERC-4337
+# Safe, Zodiac Roles, And ERC-4337
 
-Use dequanto account-agent flows for Gnosis Safe and ERC-4337 instead of wiring external SDK calls directly.
+Use dequanto account-agent flows for Gnosis Safe, Zodiac Roles, and ERC-4337 instead of wiring external SDK calls directly.
 
 Key source files:
 
@@ -8,6 +8,8 @@ Key source files:
 - `src/safe/GnosisSafeFactory.ts`
 - `src/safe/GnosisSafeService.ts`
 - `src/safe/SafeTx.ts`
+- `src/zodiac/ZodiacTx.ts`
+- `src/txs/agents/ZodiacAgent.ts`
 - `src/safe/transport/InMemoryServiceTransport.ts`
 - `src/safe/transport/FileServiceTransport.ts`
 - `src/safe/transport/SafeServiceTransport.ts`
@@ -20,6 +22,8 @@ Key source files:
 Useful tests:
 
 - `test/safe/safe.spec.ts`
+- `test/zodiac/ZodiacTx.spec.ts`
+- `test/zodiac/ZodiacAgent.spec.ts`
 - `test/erc4337/erc4337.spec.ts`
 
 ## Safe Account Transaction
@@ -101,6 +105,49 @@ See `./transactions.md` for the full `BatchAgent` script pattern.
 
 Use `GnosisSafeService.decodeSafeTx(data, { decodeContractCall: true })`. Register ABIs on the explorer when decoding local or unknown contracts.
 
+## Zodiac Roles Account Transaction
+
+Use `ZodiacAccount` for a Zodiac Roles Modifier with the bytes32 role-key API:
+
+```ts
+import { ZodiacAccount } from 'dequanto/models/TAccount';
+
+let zodiacAccount: ZodiacAccount = {
+    type: 'zodiac',
+    platform: client.platform,
+    address: rolesModifierAddress,
+    operator,
+    roleKey,
+};
+
+let tx = await token.$receipt().transfer(zodiacAccount, receiver, amount);
+```
+
+`address` is the Roles Modifier address; `operator` is the EOA authorized for `roleKey`. Supply the role key as hex, not a role name; `ZodiacTx` pads it to 32 bytes. `ZodiacAgent` wraps the original call in `execTransactionWithRole(..., shouldRevert: true)` and the operator submits it directly on-chain. The Safe/avatar pays the inner call's native value; the operator pays gas.
+
+## Zodiac Batch
+
+Use `ZodiacTx` to compose a batch from generated `$data()` calls:
+
+```ts
+import { ZodiacTx } from 'dequanto/zodiac/ZodiacTx';
+
+let zodiac = new ZodiacTx(zodiacAccount, client);
+let tx = await zodiac.executeBatch(
+    await token.$data().approve(zodiacAccount, spender, amount),
+    await token.$data().transfer(zodiacAccount, receiver, amount)
+);
+await tx.wait();
+```
+
+Each inner transaction uses CALL. The Roles transaction uses DELEGATECALL to MultiSend. The helper resolves the deployment from `config.safe.contracts[client.network]`, preferring `MultiSendCallOnly` and falling back to `MultiSend`, just like `SafeTx`. Use `options.contracts` for deployment overrides; there is no MultiSend address field on the account.
+
+The Roles Modifier must have a transaction unwrapper registered for the selected MultiSend deployment to check each inner call's permissions.
+
+Use `execute(call)` for a single transaction. `getTxData(call)` and `getBatchTxData(...calls)` return the encoded transaction to the Roles Modifier without submitting it. These results are already wrapped; submit them as the operator, not as a Zodiac account.
+
+`BatchAgent` also collects ordinary contract writes with a Zodiac account and submits them through `ZodiacTx`. It keeps different roles, operators, and chains in separate groups. See `./transactions.md` for the script pattern.
+
 ## ERC-4337
 
 Use `Erc4337TxWriter` for the higher-level flow:
@@ -130,5 +177,5 @@ Use `Erc4337Service` for low-level operation creation, signing, decoding, and `h
 ## Avoid
 
 - Do not manually assemble Safe `execTransaction` signatures unless the task is explicitly low-level.
-- Do not bypass dequanto `TxWriter` account agents for Safe or ERC-4337 when generated contract writes can use account types.
+- Do not bypass dequanto `TxWriter` account agents for Safe, Zodiac, or ERC-4337 when generated contract writes can use account types.
 

package/skills/dequanto/references/tokens-accounts.md

@@ -93,6 +93,7 @@ Transaction APIs accept several account shapes:
 - named account: string resolved through `ChainAccountService`
 - impersonated account in Hardhat: `{ type: 'impersonated', address }` (no private key required)
 - Safe account: `{ type: 'safe', address, operator, owners? }`
+- Zodiac Roles account: `{ type: 'zodiac', platform, address: rolesModifierAddress, operator, roleKey }`; the operator is an EOA and the role key is hex. See [Zodiac Roles](safe-erc4337.md#zodiac-roles-account-transaction) for execution and batching.
 - ERC-4337 account: `{ type: 'erc4337', address, operator }`
 
 Inspect `src/models/TAccount.ts` before adding a new account shape.

package/skills/dequanto/references/transactions.md

@@ -72,6 +72,7 @@ Important behavior:
 - `batch.execute()` skips duplicate transactions by default; pass `{ includeDuplicates: true }` when duplicates are intentional.
 - Deployment transactions are ignored by default; pass `new BatchAgent({ ignoreContractCreation: false })` when contract creation should also be intercepted.
 - If the account being submitted is a Safe, `execute()` creates one Safe multicall/batch transaction from many cached single transactions.
+- If the account being submitted is Zodiac, `execute()` wraps each compatible group in MultiSend and submits it through `execTransactionWithRole`. Different roles, operators, and chains remain separate. See [Zodiac batching](safe-erc4337.md#zodiac-batch) for deployment configuration and the required unwrapper.
 - If the account being submitted is a Timelock, `execute()` creates one Timelock batch/scheduleBatch flow from many cached single transactions.
 - For normal EOA accounts, `execute()` sends each cached transaction on-chain.
 
@@ -165,5 +166,5 @@ See the [revert and custom error example](../examples/revert-error.spec.ts) for
 
 - Do not perform manual simulations with `$call()` or `$gas()` solely to catch reverts before sending; `TxWriter` automatically simulates via gas estimation, decodes custom errors, and throws standard JavaScript errors.
 - Do not manually manage gas and nonce unless the task needs it.
-- Do not use external wallet clients when a dequanto `TAccount`, `SafeAccount`, or `Erc4337Account` flow is available.
+- Do not use external wallet clients when a dequanto `TAccount`, `SafeAccount`, `ZodiacAccount`, or `Erc4337Account` flow is available.
 

package/src/abi/$abi.ts

@@ -4,6 +4,9 @@ import { TEth } from 'dequanto/models/TEth';
 import { $abiCoder } from './$abiCoder';
 import { $abiUtils } from 'dequanto/utils/$abiUtils';
 import { $abiParser } from 'dequanto/utils/$abiParser';
+import { $hex } from 'dequanto/utils/$hex';
+import alot from 'alot';
+import { $types } from 'dequanto/solidity/utils/$types';
 
 export namespace $abi {
     type TAbiType = string | ParamType | TAbiInput;
@@ -39,6 +42,39 @@ export namespace $abi {
         let outputs = typeof abi === 'string'
             ? ($abiParser.parseMethod(abi).outputs ?? [])
             : (Array.isArray(abi) ? abi : abi.outputs ?? []);
+        try {
+            return decodeReturnInner(outputs, hex);
+        } catch (error) {
+            if (outputs.length > 1) {
+                // Zero-pad missing trailing outputs only when all outputs are static
+                // and the data ends at an output boundary.
+                // Supports newer ABIs with trailing outputs that an older deployed contract does not return.
+                const receivedWords = $hex.getBytesLength(hex) / 32;
+                const abiWords = alot(outputs).sum($types.wordSizeOf);
+                if (Number.isFinite(abiWords)
+                    && Number.isInteger(receivedWords)
+                    && receivedWords > 0
+                    && receivedWords < abiWords
+                ) {
+                    let missingWords = abiWords - receivedWords;
+                    let boundaryWords = missingWords;
+                    for (let i = outputs.length - 1; i > -1; i--) {
+                        boundaryWords -= $types.wordSizeOf(outputs[i]);
+                        if (boundaryWords <= 0) {
+                            break;
+                        }
+                    }
+                    if (boundaryWords == 0) {
+                        let expanded = hex + '0'.repeat(64 * missingWords);
+                        return decodeReturnInner(outputs, expanded);
+                    }
+                }
+            }
+            throw error;
+        }
+    }
+
+    function decodeReturnInner<T = any>(outputs: TAbiOutput[], hex: string): T {
         let returnAbi = outputs;
         let isDynamic: boolean = null;
         if (outputs.length > 1) {

package/src/contracts/ContractReader.ts

@@ -302,9 +302,9 @@ export class ContractReader implements IContractReader {
         return filters as RpcTypes.Filter;
     }
 
-    static async read <TResult = any> (client: Web3Client, address: TAddress, methodAbi: string){
+    static async read <TResult = any> (client: Web3Client, address: TAddress, methodAbi: string, ...params){
         let reader = new ContractReader(client);
-        return reader.readAsync<TResult>(address, methodAbi);
+        return reader.readAsync<TResult>(address, methodAbi, ...params);
     }
 }
 

package/src/models/TAccount.ts

@@ -4,7 +4,12 @@ import { TEth } from './TEth';
 import { TPlatform } from './TPlatform';
 
 export interface IAccount {
-    type?: 'eoa' | 'safe' | 'erc4337' | 'timelock' | 'impersonated'
+    type?: 'eoa'
+        | 'safe'
+        | 'erc4337'
+        | 'timelock'
+        | 'impersonated'
+        | 'zodiac'
     name?: string
     platform?: TPlatform
 
@@ -68,4 +73,14 @@ export interface TimelockAccount extends IAccount {
     operator: IAccount
 }
 
-export type TAccount = string | IAccount | EoAccount | SafeAccount | Erc4337Account;
+export interface ZodiacAccount extends IAccount {
+    type: 'zodiac'
+    platform: TPlatform
+    /** Zodiac Roles Modifier address, not the Safe/avatar address. */
+    address: TAddress
+    operator: EoAccount
+    /** Roles v2 bytes32 role key. */
+    roleKey: TEth.Hex
+}
+
+export type TAccount = string | IAccount | EoAccount | SafeAccount | Erc4337Account | ZodiacAccount;

package/src/models/TEth.ts

@@ -1,3 +1,4 @@
+import type { ZodiacAccount as TZodiacAccount } from './TAccount';
 import type { RpcTypes } from 'dequanto/rpc/Rpc'
 import { TPlatform } from './TPlatform'
 
@@ -135,7 +136,7 @@ export namespace TEth {
 
 
     export interface IAccount {
-        type?: 'eoa' | 'safe' | 'erc4337' | 'timelock' | 'impersonated'
+        type?: 'eoa' | 'safe' | 'erc4337' | 'timelock' | 'impersonated' | 'zodiac'
         name?: string
         address?: Address
         platform?: Platform
@@ -154,6 +155,8 @@ export namespace TEth {
         personal_sign (challenge: string, address: TEth.Address): Promise<TEth.Hex>
     }
 
+    export interface ZodiacAccount extends TZodiacAccount {}
+
     export interface SafeAccount extends IAccount {
         type: 'safe'
         provider?: 'gnosis'

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);