dequanto 0.2.40 → 0.2.42

package/lib/types/contracts/deploy/Deployments.d.ts

@@ -127,6 +127,15 @@ export declare class Deployments {
     private isSameBytecode;
     private ensureVerification;
     fixBytecodeHashesByReread(): Promise<void>;
+    saveExisting(params: {
+        contractAddress: TEth.Address;
+        name: string;
+        id: string;
+        main: string;
+    }): Promise<void>;
+    private getContractDeploymentInfo;
+    private resolveMain;
+    private getSlotsForMain;
     private getBytecodeHash;
     /**
      * A simple method to configure contract state.

package/lib/types/contracts/deploy/storage/DeploymentsStorage.d.ts

@@ -19,6 +19,7 @@ export interface IDeployment {
     deployer: TEth.Address;
     timestamp: number;
     bytecodeHash: TEth.Hex;
+    gas?: number;
     history?: (Omit<IDeployment, 'id' | 'name'> & {
         version?: string;
     })[];
@@ -59,6 +60,7 @@ export declare class DeploymentsStorage {
     updateDeployment(deployment: IDeployment): Promise<void>;
     updateProxyDeployment(deploymentImplementation: IDeployment, deploymentProxy: IDeployment): Promise<void>;
     saveAll(deployments: IDeployment[]): Promise<void>;
+    upsertMany(deployments: IDeployment[]): Promise<void>;
     saveDeployment(contract: ContractBase, info: {
         id: string;
         name: string;

package/lib/types/txs/TxWriter.d.ts

@@ -104,6 +104,7 @@ export declare class TxWriter extends class_EventEmitter<ITxWriterEvents> implem
     toJSON(): TTxWriterJson;
     saveTxAndExit(additionalProperties?: any): Promise<void>;
     static fromJSON(json: TTxWriterJson, client?: Web3Client, account?: TAccount): Promise<TxWriter>;
+    static fromTxHash(client: Web3Client, hash: TEth.Hex): Promise<TxWriter>;
     static write(client: Web3Client, builder: TxDataBuilder, account: IAccount, options?: ITxWriterOptions): TxWriter;
     static create(client: Web3Client, builder: TxDataBuilder, account: TAccount, options?: ITxWriterOptions): TxWriter;
     static writeTxData(client: Web3Client, data: Partial<TEth.TxLike>, accountMix: TAccount, options?: ITxWriterOptions): Promise<TxWriter>;

package/lib/types/txs/agents/BatchAgent.d.ts

@@ -11,13 +11,18 @@ export declare class BatchAgent implements ITxWriterAgent {
     constructor(options?: {
         ignoreContractCreation?: boolean;
     });
-    enable(): void;
-    disable(): void;
+    enable(): this;
+    disable(): this;
     getTxData(): (Pick<TEth.TxLike, "to" | "data" | "value"> & {
         sender: TEth.EoAccount;
         account: TEth.IAccount;
     })[];
     process(senderMix: string | EoAccount, account: TEth.IAccount, outerWriter: TxWriter): Promise<MockTxWriter>;
+    execute(): Promise<TxWriter[]>;
+    private executeGroup;
+    private executeBatchSafe;
+    private executeBatchTimelock;
+    private getTitle;
 }
 export declare class MockTxWriter extends class_EventEmitter<ITxWriterEvents> implements ITxWriterEmitter {
     sender: TEth.EoAccount;

package/lib/types/utils/$address.d.ts

@@ -6,7 +6,7 @@ export declare namespace $address {
     function isValid(address: any): address is TEth.Address;
     function isEmpty(address: TEth.Address): boolean;
     function expectValid(address: TEth.Address, message: string): `0x${string}`;
-    function toBytes32(address: TEth.Address): string;
+    function toBytes32(address: TEth.Address): TEth.Hex;
     function fromBytes32(hex: string): TEth.Address;
     /** Supports https://eips.ethereum.org/EIPS/eip-1191 */
     function toChecksum(address_: TEth.Address, chainId?: number): TEth.Address;

package/lib/types/utils/$require.d.ts

@@ -1,26 +1,27 @@
 import { IToken } from '../models/IToken';
 import { TAddress } from '../models/TAddress';
+import { TEth } from '../models/TEth';
 export declare namespace $require {
     function Number<T>(val: T, message?: string, opts?: {
         min?: T;
         max?: T;
-    }): T;
+    }): number;
     function BigInt<T>(val: T, message?: string, opts?: {
         min?: T;
         max?: T;
-    }): T;
+    }): bigint;
     function Numeric<T>(val: T, message?: string, opts?: {
         min?: T;
         max?: T;
-    }): T;
-    function Function<T>(val: T, message: string): T;
-    function Array<T>(val: T, message: string): T;
-    function String<T>(val: T, message: string): T;
-    function notNull<T>(val: T, message: string, ...logs: any[]): T;
+    }): NonNullable<T>;
+    function Function<T>(val: T, message: string): NonNullable<T>;
+    function Array<T>(val: T, message: string): NonNullable<T>;
+    function String<T>(val: T, message: string): NonNullable<T>;
+    function notNull<T>(val: T, message: string, ...logs: any[]): NonNullable<T>;
     function Null<T>(val: T, message: string, ...logs: any[]): T;
     function notEmpty<T extends string | Array<any> | {
         length: number;
-    }>(val: T, message: string): T;
+    }>(val: T, message: string): NonNullable<T>;
     function resolved<T>(x: PromiseLike<T>, message: string): Promise<T>;
     function True(value: boolean, message?: string): void;
     function notEq<T = any>(a: T, b: T, message?: string): void;
@@ -33,7 +34,7 @@ export declare namespace $require {
     function AddressNotEmpty(val: TAddress | string, message?: string): TAddress;
     function AddressChecked(val: TAddress, message?: string): TAddress;
     function TxHash(val: string, message?: string): string;
-    function Hex(val: string, message?: string): string;
+    function Hex(val: string, message?: string): TEth.Hex;
     function Token(token: IToken, message?: string): IToken;
     /**
      * must be a > b, throws when a <= b

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dequanto",
-    "version": "0.2.40",
+    "version": "0.2.42",
     "author": {
         "name": "Alex Kit",
         "email": "alex.kit@atmajs.com"

package/src/contracts/deploy/Deployments.ts

@@ -21,6 +21,10 @@ import { l } from '@dequanto/utils/$logger';
 import { $promise } from '@dequanto/utils/$promise';
 import { IBeacon, IBeaconProxy, IProxy, IProxyAdmin, ProxyDeployment } from './proxy/ProxyDeployment';
 import { DeploymentsStorage, IDeployment } from './storage/DeploymentsStorage';
+import { $address } from '@dequanto/utils/$address';
+import { $date } from '@dequanto/utils/$date';
+import { TransparentUpgradeableProxy } from '@dequanto/prebuilt/openzeppelin/compiled/TransparentUpgradeableProxy/TransparentUpgradeableProxy';
+import { Directory, File, env } from 'atma-io';
 
 
 
@@ -178,7 +182,7 @@ export class Deployments {
             : new CtorWrapped(deployment.address, this.client);
     }
 
-    async verify (params: {
+    async verify(params: {
         id: string
         address?: TAddress,
         Ctor: Constructor<ContractBase>
@@ -193,7 +197,6 @@ export class Deployments {
             constructorParams: params.constructorParams,
             proxyFor: deployment.proxyFor,
         });
-
     }
 
 
@@ -489,7 +492,7 @@ export class Deployments {
 
                 let { bytecode: bytecodeOnchain } = $bytecode.splitToMetadata(bytecode);
                 let { bytecode: bytecodeLocal } = $bytecode.splitToMetadata(deployedBytecode);
-                let [ localDiff, onchainDiff ] = Str.getDifference(bytecodeLocal, bytecodeOnchain);
+                let [localDiff, onchainDiff] = Str.getDifference(bytecodeLocal, bytecodeOnchain);
                 if (localDiff === '' || /^0+$/.test(localDiff)) {
                     this._logger.log(`${deployment.id} bytecode has only immutable data diff, assume unchanged`);
                     // Local deployedBytecode does not contain immutable data.
@@ -504,7 +507,7 @@ export class Deployments {
     }
 
 
-    private async ensureVerification <T extends TContract> (Ctor: Constructor<T>, deployment: IDeployment, opts: TVerificationOptions) {
+    private async ensureVerification<T extends TContract>(Ctor: Constructor<T>, deployment: IDeployment, opts: TVerificationOptions) {
         if (this.client.platform === 'hardhat' || opts?.verification === false || this.opts.verification === false) {
             return;
         }
@@ -563,6 +566,154 @@ export class Deployments {
         await this.store.saveAll(deployments);
     }
 
+    public async saveExisting(params: {
+        contractAddress: TEth.Address
+        name: string
+        id: string
+
+        // The generated 0xc contract to save the deployment for
+        main: string
+    }) {
+        $require.AddressNotEmpty(params.contractAddress);
+
+        const main = await this.resolveMain(params.main);
+
+        let deployments = await this.store.getDeployments();
+        let current = deployments.find(x => $address.eq(x.address, params.contractAddress));
+        $require.Null(current, `Contract already exists in deployments`);
+
+        let explorer = await BlockchainExplorerFactory.getAsync(this.client.network);
+        let abiInfo = await explorer.getContractAbi(params.contractAddress);
+        if ($is.Address(abiInfo.implementation)) {
+            // Is proxy
+            const deployments = [] as IDeployment[];
+
+            const contractInfo = await this.getContractDeploymentInfo(abiInfo.implementation);
+            deployments.push({
+                id: params.id,
+                name: params.name,
+                main: main,
+                ...contractInfo,
+
+                address: params.contractAddress,
+                implementation: abiInfo.implementation,
+            });
+
+            const proxyInfo = await this.getContractDeploymentInfo(params.contractAddress);
+            const proxy = {
+                id: `${params.id}Proxy`,
+                name: 'TransparentUpgradeableProxy',
+                main: 'artifacts/@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol/TransparentUpgradeableProxy.json',
+                ...proxyInfo,
+                address: params.contractAddress,
+                proxyFor: params.contractAddress,
+            };
+            deployments.push(proxy);
+
+            const proxyReceipt = await this.client.getTransactionReceipt(proxy.tx);
+            const proxyAdmin = new TransparentUpgradeableProxy($address.ZERO, this.client);
+            const [proxyAdminLog] = proxyAdmin.extractLogsAdminChanged(proxyReceipt);
+            if (proxyAdminLog) {
+                deployments.push({
+                    id: `${params.id}ProxyAdmin`,
+                    name: 'ProxyAdmin',
+                    main: 'artifacts/@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol/ProxyAdmin.json',
+                    address: proxyAdminLog.params.newAdmin,
+                    block: proxy.block,
+                    tx: proxy.tx,
+                    gas: proxy.gas,
+                    timestamp: proxy.timestamp,
+
+                    // Not required for the proxyadmin contract
+                    deployer: null,
+                    bytecodeHash: null,
+                });
+            }
+
+            let slots = await this.getSlotsForMain(main);
+            if (slots != null) {
+                this.store.saveStorageLayoutInfo({
+                    id: proxy.id,
+                    slots
+                });
+            }
+            await this.store.upsertMany(deployments);
+            return;
+        }
+
+        const contractInfo = await this.getContractDeploymentInfo(params.contractAddress);
+        const deployment = {
+            id: params.id,
+            name: params.name,
+            main: main,
+            ...contractInfo,
+        };
+        await this.store.upsertMany([ deployment ]);
+    }
+
+    private async getContractDeploymentInfo(address: TAddress) {
+        const client = this.client;
+        const explorer = await BlockchainExplorerFactory.getAsync(client.network);
+        const creation = await explorer.getContractCreation(address);
+        const receipt = await this.client.getTransactionReceipt(creation.txHash);
+        const block = await this.client.getBlock(receipt.blockNumber);
+        const bytecode = await this.client.getCode(address);
+        const info = {
+            address: address,
+            bytecodeHash: this.getBytecodeHash(bytecode),
+            block: receipt.blockNumber,
+            tx: receipt.transactionHash,
+            timestamp: block.timestamp,
+            gas: Number(receipt.gasUsed),
+            deployer: receipt.from,
+            verified: $date.fromUnixTimestamp(block.timestamp).toISOString()
+        };
+        return info;
+    }
+
+    private async resolveMain(main: string) {
+        let extMatch = /\.\w+$/.exec(main);
+        if (extMatch != null) {
+            let exists = await File.existsAsync(main);
+            $require.True(exists, `The main file "${main}" must exist`);
+            return main;
+        }
+        let files = await Directory.readFilesAsync('./0xc/hardhat/', main);
+        if (files.length > 1) {
+            throw new Error(`Multiple contracts found: ${files.map(x => x.uri.toLocalFile())} by the match "${main}"`);
+        }
+        if (files.length === 0) {
+            throw new Error(`No files found by the match "${main}"`);
+        }
+        let [file] = files;
+        return file.uri.toRelativeString(env.currentDir);
+    }
+
+    private async getSlotsForMain(main: string) {
+        let code = await File.readAsync<string>(main, { skipHooks: true });
+        // parse from ts-generated code (consider to output slots in extra file like abi json)
+        let rgxStart = /^\s*\$slots\s*=\s*\[/mg;
+        let rgxStartMatch = rgxStart.exec(code);
+        if (rgxStartMatch == null) {
+            console.error(`${main} has no generated $slots field`);
+            return null;
+        }
+        let rgxEnd = /^\s*\]/mg;
+        rgxEnd.lastIndex = rgxStartMatch.index;
+        let rgxEndMatch = rgxEnd.exec(code);
+        if (rgxEndMatch == null) {
+            console.error(`${main}: End not found of the $slots value`);
+            return null;
+        }
+        let json = code.substring(rgxStartMatch.index + rgxStartMatch[0].length - 1, rgxEndMatch.index + 1);
+        try {
+            return JSON.parse(json);
+        } catch (error) {
+            console.error(`Slots not parsed from ${main}: ${error.message}`)
+            return null;
+        }
+    }
+
     private getBytecodeHash(bytecode: TEth.Hex) {
         let { bytecode: bytecodeRaw } = $bytecode.splitToMetadata(bytecode);
         return $contract.keccak256(bytecodeRaw);
@@ -614,7 +765,7 @@ export class Deployments {
                 return;
             }
         }
-        if (opts.title!= null) {
+        if (opts.title != null) {
             let currentStr = currentVal == null || typeof currentVal === 'object'
                 ? ''
                 : ` from ${currentVal}`;
@@ -628,14 +779,14 @@ type TFunction = (...args: any[]) => any;
 type TInitializerName = 'initialize' | `initializeV${number}`;
 type TInitializerParams<T> = {
     initialize?: T extends { initialize: infer TInit }
-        ? TInit extends TFunction
-            ? ParametersFromSecond<TInit>
-            : never
-        : any[];
+    ? TInit extends TFunction
+    ? ParametersFromSecond<TInit>
+    : never
+    : any[];
 } & {
     [K in Extract<keyof T, TInitializerName>]?: T[K] extends TFunction
-        ? ParametersFromSecond<T[K]>
-        : never;
+    ? ParametersFromSecond<T[K]>
+    : never;
 };
 
 type TContract = ContractBase & { $constructor?: (...args: any[]) => any }
@@ -652,7 +803,7 @@ function isEqual(a, b) {
     }
     if (typeof a !== 'object' && typeof b !== 'object') {
 
-        if (typeof a === 'string' && typeof b ==='string') {
+        if (typeof a === 'string' && typeof b === 'string') {
             if (a.startsWith('0x') && b.startsWith('0x') && $is.Hex(a) && $is.Hex(b)) {
                 a = a.toLowerCase();
                 b = b.toLowerCase();
@@ -730,7 +881,7 @@ function serializeMigrationData(id: string, contract: ContractBase, opts: any) {
  * Normalizes the contract name by removing any version suffix from the name.
  * "FooV1" is actually the "Foo" contract.
  */
-function getImplementationId (Ctor: Constructor<TContract>) {
+function getImplementationId(Ctor: Constructor<TContract>) {
     let id = Ctor.name;
     let version = /V?(?<version>\d)$/i.exec(id);
     if (version) {
@@ -740,7 +891,7 @@ function getImplementationId (Ctor: Constructor<TContract>) {
 }
 
 
-function getImmutablesKey (args: any[]) {
+function getImmutablesKey(args: any[]) {
     if (args == null || args.length === 0) {
         return null;
     }
@@ -749,9 +900,9 @@ function getImmutablesKey (args: any[]) {
 }
 
 namespace Str {
-    export function getDifference (a: TEth.Hex, b: TEth.Hex) {
+    export function getDifference(a: TEth.Hex, b: TEth.Hex) {
         if (a === b) {
-            return [ '', '' ];
+            return ['', ''];
         }
 
         let start = -1;

package/src/contracts/deploy/storage/DeploymentsStorage.ts

@@ -39,6 +39,7 @@ export interface IDeployment {
     deployer: TEth.Address
     timestamp: number
     bytecodeHash: TEth.Hex
+    gas?: number
 
     history?: (Omit<IDeployment, 'id' | 'name'> & { version?: string })[]
 }
@@ -156,6 +157,11 @@ export class  DeploymentsStorage {
         await store.saveAll(deployments);
     }
 
+    async upsertMany (deployments: IDeployment[]) {
+        let store = await this.getDeploymentsStore();
+        await store.upsertMany(deployments);
+    }
+
     async saveDeployment (contract: ContractBase, info: {
         id: string
         name: string
@@ -176,7 +182,7 @@ export class  DeploymentsStorage {
             address: contract.address,
             block: receipt.blockNumber,
             tx: receipt.transactionHash,
-            gas: receipt.gasUsed,
+            gas: Number(receipt.gasUsed),
             deployer: this.deployer.address,
             timestamp: $date.toUnixTimestamp(new Date()),
 

package/src/txs/TxWriter.ts

@@ -619,6 +619,28 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> implements ITx
         return writer;
     }
 
+    static async fromTxHash (client: Web3Client, hash: TEth.Hex): Promise<TxWriter> {
+        let txData = await client.getTransaction(hash);
+        let txReceipt = await client.getTransactionReceipt(hash);
+        let account = await TxWriter.prepareAccount(txData.from);
+
+        let builder = TxDataBuilder.fromJSON(client, account, {
+            config: null,
+            tx: txData
+        });
+        let writer = TxWriter.create(client, builder, account);
+        writer.tx = {
+            hash: hash,
+            receipt: txReceipt,
+            confirmations: null,
+            timestamp: null,
+        };
+        writer.txs = [ writer.tx ];
+        writer.receipt = txReceipt;
+
+        return writer;
+    }
+
 
     static write (
         client: Web3Client,

package/src/txs/agents/BatchAgent.ts

@@ -1,3 +1,4 @@
+import alot from 'alot';
 import { EoAccount } from '@dequanto/models/TAccount';
 import { ITxWriterAgent } from './TxWriterAccountAgents';
 import { ITxWriterEmitter, ITxWriterEvents, ITxWriterTransaction, TxWriter } from '../TxWriter';
@@ -7,11 +8,13 @@ import { class_Dfr, class_EventEmitter } from 'atma-utils';
 import { TEth } from '@dequanto/models/TEth';
 import { $date } from '@dequanto/utils/$date';
 
-
-import { $require } from '@dequanto/utils/$require';
 import { $address } from '@dequanto/utils/$address';
 import { $logger } from '@dequanto/utils/$logger';
-
+import { SafeTx } from '@dequanto/safe/SafeTx';
+import { TimelockController } from '@dequanto/prebuilt/openzeppelin/TimelockController';
+import { TimelockService } from '@dequanto/services/TimelockService/TimelockService';
+import { TxDataBuilder } from '../TxDataBuilder';
+import { $contract } from '@dequanto/utils/$contract';
 
 export class BatchAgent implements ITxWriterAgent {
 
@@ -26,10 +29,12 @@ export class BatchAgent implements ITxWriterAgent {
 
     enable () {
         TxWriter.DEFAULTS.agent = this;
+        return this;
     }
 
     disable () {
         TxWriter.DEFAULTS.agent = null;
+        return this;
     }
 
     getTxData (): (Pick<TEth.TxLike, "to" | "data" | "value"> & { sender: TEth.EoAccount, account: TEth.IAccount })[] {
@@ -39,11 +44,12 @@ export class BatchAgent implements ITxWriterAgent {
                 to: data.to,
                 value: data.value,
                 data: data.data,
+                chainId: data.chainId,
 
                 sender: tx.sender,
                 account: tx.account,
             };
-        })
+        });
     }
 
     async process (senderMix: string | EoAccount, account: TEth.IAccount, outerWriter: TxWriter) {
@@ -62,13 +68,86 @@ export class BatchAgent implements ITxWriterAgent {
             outerWriter,
         );
 
-        let methodInfo = await outerWriter.builder.getInputDataInfo();
-        $logger.log(`[BatchAgent] ${outerWriter.builder.data.to} (${methodInfo?.method})`);
+        let title = await this.getTitle(outerWriter.builder);
+        $logger.log(`[BatchAgent] ${title}`);
 
         this.transactions.push(inner);
         await inner.process();
         return inner;
     }
+
+    async execute (): Promise<TxWriter[]> {
+        this.disable();
+
+        let groupStart = 0;
+        let writers = [];
+        for (let i = 0; i < this.transactions.length; i++) {
+            let tx = this.transactions[i];
+            let next = i < this.transactions.length - 1
+                ? this.transactions[i + i]
+                : null;
+
+            if (next == null || $address.eq(tx.account.address, next.account.address) === false) {
+                let arr = await this.executeGroup(this.transactions.slice(groupStart, i + 1));
+                writers.push(...arr);
+            }
+        }
+        this.enable();
+        return writers;
+    }
+
+    private async executeGroup (txs: MockTxWriter[]) {
+        let { account, sender } = txs[0];
+        if (account.name.includes('safe/')) {
+            let tx = await this.executeBatchSafe(sender, account, txs);
+            return [ tx ];
+        }
+        if (account.name.includes('timelock/')) {
+            let tx = await this.executeBatchTimelock(sender, account, txs);
+            return [ tx ];
+        }
+        let writers = [];
+        for (let i = 0; i < txs.length; i++) {
+            let tx = txs[i];
+            let writer = tx.outerWriter.send();
+            await writer.wait();
+            writers.push(writer);
+        }
+        return writers;
+    }
+    private async executeBatchSafe (sender: TEth.EoAccount, account: TEth.IAccount, txs: MockTxWriter[]) {
+        let client = txs[0].outerWriter.client;
+        let safe = new SafeTx(account as TEth.SafeAccount, client);
+
+        let calls = txs.map(x => x.outerWriter.builder.getTxData());
+        let writer = await safe.executeBatch(...calls);
+        await writer.wait();
+        return writer;
+    }
+    private async executeBatchTimelock (sender: TEth.EoAccount, account: TEth.IAccount, txs: MockTxWriter[]) {
+        let client = txs[0].outerWriter.client;
+        let timelock = new TimelockController(account.address, client);
+        let service = new TimelockService(timelock, {
+
+        });
+        let titles = await alot(txs)
+            .map(x => this.getTitle(x.outerWriter.builder))
+            .toArrayAsync();
+        let taskName = $contract.keccak256(titles.join(','), 'hex');
+        let calls = txs.map(x => x.outerWriter.builder.getTxData());
+
+        let { tx } = await service.processBatch(taskName, sender, calls);
+        if (tx == null) {
+            // No transactions
+            return null;
+        }
+        return TxWriter.fromTxHash(client, tx);
+    }
+
+    private async getTitle (builder: TxDataBuilder) {
+        let methodInfo = await builder.getInputDataInfo();
+        return `${builder.data.to} [${methodInfo?.method}(${JSON.stringify(methodInfo?.params ?? [])})]`
+    }
 }
 
 export class MockTxWriter extends class_EventEmitter<ITxWriterEvents> implements ITxWriterEmitter {

package/src/utils/$address.ts

@@ -36,7 +36,7 @@ export namespace $address {
     }
 
     export function toBytes32(address: TEth.Address) {
-        return address.toLowerCase().substring(2).padStart(32, '0');
+        return address.toLowerCase().substring(2).padStart(32, '0') as TEth.Hex;
     }
     export function fromBytes32(hex: string): TEth.Address {
         const SIZE = 40;