dequanto 0.2.53 → 0.2.56

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

@@ -1,7 +1,8 @@
+import { UTest } from 'atma-utest';
 import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
 import { $require } from 'dequanto/utils/$require';
 
-UTest({
+UTest.create({
     async 'change balances, storage, and time on Hardhat and roll back'() {
         const client = await Web3ClientFactory.getAsync('hh:memory');
         const address = '0x0000000000000000000000000000000000001234';

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/gen/Generator.ts

@@ -56,6 +56,9 @@ export interface IGenerateOptions {
      */
     implementation?: TEth.Hex | TEth.Address | string
 
+    /** When false: no files will be saved. Use "files" in result */
+    save?: boolean
+
     /** ABI will be save alongside with TS classes */
     saveAbi?: boolean
 
@@ -240,6 +243,7 @@ export class Generator {
             implementation: implementation,
             sources: sources?.files,
             sourceMain: sourceMain,
+            save: this.options.save,
             saveAbi: this.options.saveAbi,
             saveSources: this.options.saveSources,
             client: this.client,

package/src/gen/GeneratorFromAbi.ts

@@ -33,6 +33,8 @@ export class GeneratorFromAbi {
         output: string
         outputFileExt?: string
         implementation: TAddress
+        /** No FS writes, use files in response  */
+        save?: boolean
         saveAbi?: boolean
         saveSources?: boolean
         sources?: {
@@ -320,24 +322,45 @@ export class GeneratorFromAbi {
             .replace(`/* $METHOD_TYPES$ */`, () => Str.indent(methodTypings.map(x => x.code).join('\n'), '        '))
             ;
 
+        if (opts.save !== false) {
+            await File.writeAsync(outputPath, code, { skipHooks: true });
+        }
+        const files = [
+            {
+                kind: 'binding',
+                path: outputPath,
+                content: code,
+            }
+        ];
 
-        await File.writeAsync(outputPath, code, { skipHooks: true });
         if (outputSourceType === 'js') {
             let outputPathDts = outputPath.replace(/\.\w+$/, '.d.ts');
-            await File.writeAsync(outputPathDts, codeDts, { skipHooks: true });
+            if (opts.save !== false) {
+                await File.writeAsync(outputPathDts, codeDts, { skipHooks: true });
+            }
+            files.push({
+                kind: 'declaration',
+                path: outputPathDts,
+                content: codeDts,
+            });
         }
 
 
-        if (opts.saveAbi) {
-            let path = class_Uri.combine(opts.output, outputDirectory, `${outputFilename}Abi.json`);
-            await File.writeAsync(path, abiJson);
+        let outputPathAbi = class_Uri.combine(opts.output, outputDirectory, `${outputFilename}Abi.json`);
+        if (opts.saveAbi && opts.save !== false) {
+            await File.writeAsync(outputPathAbi, abiJson);
         }
+        files.push({
+            kind: 'abi',
+            path: outputPathAbi,
+            content: JSON.stringify(abiJson),
+        });
 
         $logger.log(`bold<green<${className}>> ABI wrapper class created: bold<${outputPath}>`);
 
         let sources = opts.sources;
         let sourceFiles = [];
-        if (sources && opts.saveSources !== false) {
+        if (sources) {
             sourceFiles = await alot.fromObject(sources).mapAsync(async entry => {
                 let sourceFilename = /\/?([^/]+$)/.exec(entry.key)[1];
                 let sourcePath = entry.key;
@@ -351,9 +374,15 @@ export class GeneratorFromAbi {
                 //     sourcePath = `node_modules/${ sourcePath }`;
                 // }
                 let path = class_Uri.combine(opts.output, outputDirectory, outputFilename, sourcePath);
-                await File.writeAsync(path, entry.value.content, { skipHooks: true });
-
-                $logger.log(`Source code saved: ${path}`);
+                if (opts.saveSources !== false && opts.save !== false) {
+                    await File.writeAsync(path, entry.value.content, { skipHooks: true });
+                    $logger.log(`Source code saved: ${path}`);
+                }
+                files.push({
+                    kind: 'source',
+                    path: path,
+                    content: entry.value.content,
+                });
                 return path;
             }).toArrayAsync();
         }
@@ -363,7 +392,8 @@ export class GeneratorFromAbi {
             platform: opts.network,
             address: opts.address,
             implementation: opts.implementation,
-            contractName: opts.contractName
+            contractName: opts.contractName,
+            files
         };
     }
 

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'