dequanto 0.2.36 → 0.2.38

package/src/contracts/deploy/Deployments.ts

@@ -7,8 +7,7 @@ import { TEth } from '@dequanto/models/TEth';
 import { $abiUtils } from '@dequanto/utils/$abiUtils';
 import { $contract } from '@dequanto/utils/$contract';
 import { $require } from '@dequanto/utils/$require';
-import { ParametersFromSecond } from '@dequanto/utils/types';
-import { Constructor } from '@dequanto/utils/types';
+import { Constructor, ParametersFromSecond } from '@dequanto/utils/types';
 
 import { BlockchainExplorerFactory } from '@dequanto/explorer/BlockchainExplorerFactory';
 import { ContractVerifier } from '@dequanto/explorer/ContractVerifier';
@@ -16,13 +15,12 @@ import { HardhatWeb3Client } from '@dequanto/hardhat/HardhatWeb3Client';
 import { LoggerService } from '@dequanto/loggers/LoggerService';
 import { $is } from '@dequanto/utils/$is';
 
-import { IBeacon, IBeaconProxy, IProxy, IProxyAdmin, ProxyDeployment } from './proxy/ProxyDeployment';
-import { DeploymentsStorage, IDeployment } from './storage/DeploymentsStorage';
+import { $bytecode } from '@dequanto/evm/utils/$bytecode';
 import { TAddress } from '@dequanto/models/TAddress';
-import { $promise } from '@dequanto/utils/$promise';
 import { l } from '@dequanto/utils/$logger';
-import { $bytecode } from '@dequanto/evm/utils/$bytecode';
-import { THex } from '@dequanto/models/THex';
+import { $promise } from '@dequanto/utils/$promise';
+import { IBeacon, IBeaconProxy, IProxy, IProxyAdmin, ProxyDeployment } from './proxy/ProxyDeployment';
+import { DeploymentsStorage, IDeployment } from './storage/DeploymentsStorage';
 
 
 
@@ -288,13 +286,11 @@ export class Deployments {
     }
 
     async ensureWithProxy<
-        T extends (TContract & { initialize?: TInit }),
-        TInit extends TInitializer
+        T extends (TContract & TInitializers<TInit>),
+        TInit extends TFunction
     >(
         CtorImpl: Constructor<T>,
-        opts?: TConstructorArgs<T> & TDeploymentOptions & {
-            initialize?: ParametersFromSecond<T['initialize']>
-        }
+        opts?: TConstructorArgs<T> & TDeploymentOptions & TInitializerParams<T>
     ): Promise<{
         // the Implementation Contract with the address set to Proxy
         contract: T
@@ -322,7 +318,8 @@ export class Deployments {
             deployment: opts?.deployment
         });
 
-        let data = serializeInitData(id, contractImpl, opts.initialize);
+        let initData = serializeInitData(id, contractImpl, opts.initialize);
+        let { migrationData, migrationV } = serializeMigrationData(id, contractImpl, opts);
         let implementationAddress = contractImplDeployment.implementation ?? contractImplDeployment.address;
 
         let {
@@ -337,7 +334,9 @@ export class Deployments {
             deployments: this,
             implementation: {
                 address: implementationAddress,
-                initData: data
+                initData,
+                migrationData,
+                migrationV,
             },
             upgradeImplementation: opts.deployment?.upgradeProxy ?? this.opts?.whenUpgradeRequired !== 'ignore'
         })
@@ -370,7 +369,7 @@ export class Deployments {
      **/
     async ensureWithBeacon<
         T extends (TContract & { initialize?: TInit }),
-        TInit extends TInitializer
+        TInit extends TFunction
     >(
         CtorImpl: Constructor<T>,
         opts: TConstructorArgs<T> & TDeploymentOptions & {
@@ -426,7 +425,9 @@ export class Deployments {
             deployments: this,
             implementation: {
                 address: implementationAddress,
-                initData: data
+                initData: data,
+                // @TODO implement migrations for Beacons
+                migrationData: null
             }
         });
 
@@ -612,8 +613,26 @@ export class Deployments {
 }
 
 
-type TInitializer = (...args: any[]) => any
-
+type TFunction = (...args: any[]) => any
+type TInitializerName = 'initialize' | `initializeV${number}`
+type TInitializers<TInit extends TFunction> = {
+    [K in TInitializerName]?: TInit
+}
+type TInitializerParams<T extends TInitializers<TFunction>> = {
+    initialize?: T['initialize'] extends TFunction
+        ? ParametersFromSecond<T['initialize']>
+        : never
+    initializeV2?: T['initializeV2'] extends TFunction
+        ? ParametersFromSecond<T['initializeV2']>
+        : never
+    initializeV3?: T['initializeV3'] extends TFunction
+        ? ParametersFromSecond<T['initializeV3']>
+        : never
+} & {
+    [K in Extract<keyof T, `initializeV${number}`>]?: T[K] extends TFunction
+        ? ParametersFromSecond<T[K]>
+        : any
+}
 
 type TContract = ContractBase & { $constructor?: (...args: any[]) => any }
 type TConstructorArgs<T extends TContract> = T['$constructor'] extends Function ? {
@@ -678,6 +697,31 @@ function serializeInitData(id: string, contract: ContractBase, initializeParams:
 }
 
 
+function serializeMigrationData(id: string, contract: ContractBase, opts: any) {
+    let rgx = /^initializeV(?<version>[\d+])$/;
+    let migrations = contract
+        .abi
+        .map(x => rgx.exec(x.name))
+        .filter(x => x != null)
+        .map(match => Number(match.groups.version))
+        ;
+    if (migrations.length === 0) {
+        return { migrationData: null, migrationV: 1 };
+    }
+    let v = alot(migrations).max(x => x);
+    let key = `initializeV${v}`;
+    let migrationAbi = contract.abi.find(x => x.name === key);
+    let migrationParams = opts?.[key] ?? [];
+    if (migrationParams?.length !== migrationAbi.inputs.length) {
+        throw new Error(`Wrong number of arguments (${migrationParams?.length}) for initializer method (${migrationAbi.inputs.length}) in ${id}.`);
+    }
+    return {
+        migrationData: $abiUtils.serializeMethodCallData(migrationAbi, migrationParams ?? []),
+        migrationV: v
+    };
+}
+
+
 /**
  * Normalize the contract name by removing any versions from name
  * "FooV1" is actually the "Foo" contract

package/src/contracts/deploy/proxy/ProxyDeployment.ts

@@ -15,6 +15,9 @@ import { $proxyDeploy } from './$proxyDeploy';
 import { File } from 'atma-io';
 import { IContractWrapped } from '@dequanto/contracts/ContractClassFactory';
 import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+import { $hex } from '@dequanto/utils/$hex';
+import { SlotsStorage } from '@dequanto/solidity/SlotsStorage';
+import { SlotsParser } from '@dequanto/solidity/SlotsParser';
 
 export interface IProxy extends ContractBase {
     changeAdmin?
@@ -24,14 +27,14 @@ export interface IProxyAdmin extends ContractBase {
 }
 
 export interface IBeaconProxy extends ContractBase {
-    $constructor (deployer: IAccount, beacon: TEth.Address, initData: TEth.Hex)
+    $constructor(deployer: IAccount, beacon: TEth.Address, initData: TEth.Hex)
 }
 export interface IBeacon extends ContractBase {
-    $constructor (deployer: IAccount, implementation: TEth.Address, initialOwner?: TEth.Address)
+    $constructor(deployer: IAccount, implementation: TEth.Address, initialOwner?: TEth.Address)
 
 
     implementation(): Promise<TEth.Address>
-    upgradeTo (sender: IAccount, newImplementation: TAddress)
+    upgradeTo(sender: IAccount, newImplementation: TAddress)
 }
 
 interface IDeploymentCtx {
@@ -42,6 +45,8 @@ interface IDeploymentCtx {
     implementation: {
         address: TAddress
         initData: TEth.Hex
+        migrationData: TEth.Hex
+        migrationV?: number
     }
     options?: {
         skipStorageLayoutCheck?: boolean
@@ -117,7 +122,9 @@ export class ProxyDeployment {
         } = deployments;
         let {
             address: implAddress,
-            initData
+            initData,
+            migrationData,
+            migrationV,
         } = ctx.implementation;
         let {
             Proxy,
@@ -134,7 +141,7 @@ export class ProxyDeployment {
         $require.notNull(ProxyAdmin, 'TransparentProxy.ProxyAdmin is required');
 
 
-        let proxyOpts = <Parameters<Deployments['ensure']>[1]> {
+        let proxyOpts = <Parameters<Deployments['ensure']>[1]>{
             id: proxyId,
             // will not compare the contract updates, once deployed. As proxies normally not updated
             latest: false,
@@ -150,8 +157,6 @@ export class ProxyDeployment {
         let v = proxyAbi.some(x => x.name === 'upgradeToAndCall') || !proxyAbi.some(x => x.type === 'error') ? 'V4' : 'V5';
         /** OpenZeppelin V5 hides admin/upgrade public methods and introduces "error" types*/
 
-
-
         let hasProxy = await deployments.has(Proxy, proxyOpts);
         let shouldUpdate = ctx.upgradeImplementation ?? true;
         let {
@@ -206,6 +211,13 @@ export class ProxyDeployment {
             if ($address.eq(address, implAddress) === false) {
                 if (shouldUpdate) {
                     await this.requireCompatibleStorageLayout(proxyId, ctx);
+                    if ($hex.isEmpty(migrationData) === false) {
+                        let version = await Interfaces.TransparentProxy[v].contractProxy.version(contractProxy);
+                        if (migrationV <= version) {
+                            // Clear migration call; This upgrade is raw implementation upgrade
+                            migrationData = null;
+                        }
+                    }
                     $logger.log(`Upgrading ProxyAdmin(${contractProxyAdmin.address}) to ${implAddress} (${v}) from ${address}`);
                     let receipt = await Interfaces.call(
                         ctx.owner ?? deployer,
@@ -213,7 +225,7 @@ export class ProxyDeployment {
                         Interfaces.TransparentProxy[v].contractProxyAdmin.upgradeAndCall,
                         contractProxy.address,
                         implAddress,
-                        null // data
+                        migrationData,
                     );
                     await this.saveStorageLayout(proxyId, ctx);
                 } else {
@@ -232,7 +244,7 @@ export class ProxyDeployment {
         }
     }
 
-    private async getOpenzeppelinUpgradable (opts?: { proxy?: boolean, beacon?: boolean }) {
+    private async getOpenzeppelinUpgradable(opts?: { proxy?: boolean, beacon?: boolean }) {
         // We can't compile OpenZeppelin's contracts directly from node_modules folder, so create the wrappers
         const baseSource = `./node_modules/@openzeppelin/contracts/proxy`;
         const baseOutput = `./contracts/oz`;
@@ -250,7 +262,7 @@ export class ProxyDeployment {
                     import \"${deps.TransparentUpgradeableProxy}\";
                 `,
                 //install: `TransparentUpgradeableProxy,ProxyAdmin`,
-                contracts: [`TransparentUpgradeableProxy`,`ProxyAdmin`]
+                contracts: [`TransparentUpgradeableProxy`, `ProxyAdmin`]
             },
             Beacon: {
                 source: `${baseSource}/beacon/UpgradeableBeacon.sol`,
@@ -260,7 +272,7 @@ export class ProxyDeployment {
                     import \"${deps.BeaconProxy}\";
                 `,
                 //install: `UpgradeableBeacon,BeaconProxy`,
-                contracts: [`UpgradeableBeacon`,`BeaconProxy`],
+                contracts: [`UpgradeableBeacon`, `BeaconProxy`],
             }
         };
 
@@ -271,7 +283,7 @@ export class ProxyDeployment {
             delete paths.TransparentUpgradeableProxy;
         }
 
-        function fmt (template: string) {
+        function fmt(template: string) {
             let match = /^ +/m.exec(template);
             return template.trim().replace(new RegExp(`^${match[0]}`, 'gm'), '');
         }
@@ -342,12 +354,12 @@ export class ProxyDeployment {
                 ? [
                     // address implementation
                     implAddress
-                ] as [ TEth.Address ]
+                ] as [TEth.Address]
                 : [
                     // address implementation_, address initialOwner
                     implAddress,
                     deployer.address
-                ] as [ TEth.Address, TEth.Address ]
+                ] as [TEth.Address, TEth.Address]
         };
         let hasBeacon = await deployments.has(Beacon, beaconOpts);
         let {
@@ -428,7 +440,7 @@ export class ProxyDeployment {
         }
     }
 
-    private getOzVersionByBeacon (Beacon: Constructor<IBeacon>): 5 | 4 {
+    private getOzVersionByBeacon(Beacon: Constructor<IBeacon>): 5 | 4 {
         let $constructor = new Beacon().abi?.find(x => x.type === 'constructor');
         $require.notNull($constructor, `Invalid Beacon contract: constructor not found`);
 
@@ -465,9 +477,31 @@ namespace Interfaces {
         export const V4 = {
             contractProxy: {
                 changeAdmin: 'changeAdmin(address newAdmin) external',
+                async version(contract: ContractBase) {
+                    const slots = await SlotsParser.slotsFromAbi(`
+                        (uint8 _version, bool initializing)
+                    `);
+                    const storage = SlotsStorage.createWithClient(
+                        contract.client,
+                        contract.address,
+                        slots
+                    );
+                    let v = await storage.get('_version');
+                    return v;
+                },
             },
             contractProxyAdmin: {
                 async upgradeAndCall(account, contract, proxyAddress, implementationAddress, data) {
+                    if (data != null && $hex.isEmpty(data) === false) {
+                        return call(
+                            account,
+                            contract,
+                            'upgradeAndCall(address proxy, address implementation, bytes data) external',
+                            proxyAddress,
+                            implementationAddress,
+                            data,
+                        );
+                    }
                     return call(
                         account,
                         contract,
@@ -480,7 +514,18 @@ namespace Interfaces {
         }
         export const V5 = {
             contractProxy: {
-
+                async version(contract: ContractBase) {
+                    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
+                    const position = '0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00';
+                    const slots = await SlotsParser.slotsFromAbi(`
+                        (uint8 initialized, bool initializing)
+                    `);
+                    const storage = SlotsStorage.createWithClient(contract.client, contract.address, slots, {
+                        storageOffset: position
+                    });
+                    const v = await storage.get('initialized');
+                    return v;
+                },
             },
             contractProxyAdmin: {
                 upgradeAndCall: 'upgradeAndCall(address proxy, address implementation, bytes memory data) external'

package/src/gen/Generator.ts

@@ -108,6 +108,23 @@ export class Generator {
         return generator.generate();
     }
 
+    static async generateFromJson (artifact: string) {
+        $require.True(await File.existsAsync(artifact), `${artifact} does not exist`);
+        let name = /(?<contractName>[^\\/]+).json$/.exec(artifact)?.groups?.contractName;
+        $require.notEmpty(name, `Contract name not resolved from the path ${artifact}`);
+
+        let generator = new Generator({
+            platform: 'hardhat',
+            name: name,
+            source: {
+                path: artifact
+            },
+            output: './0xc/hardhat/',
+            saveSources: false,
+        });
+        return generator.generate();
+    }
+
     /**
      * @deprecated Was possible to generate the Contract Class based on the meta information header in TS file
      */

package/src/utils/$crypto.ts

@@ -49,7 +49,7 @@ abstract class CryptoBase implements ICrypto {
         const buffer = utils.toBuffer(mix);
         $require.gt(buffer.length, 0, `Buffer to encrypt must be a non-empty`);
         const secret = opts.secret;
-        $require.gt(secret.length, 0, `Secret must be a non-empty`);
+        $require.notEmpty(secret, `Secret must be a non-empty`);
         const bufferSecret = await this.prepareSecret(secret);
 
         let encrypted = await this.encryptInner(buffer, bufferSecret);

package/src/utils/$require.ts

@@ -74,14 +74,20 @@ export namespace $require {
         }
         return val;
     }
-    export function notEmpty<T extends string | Array<any>> (val: T, message: string): T {
+    export function notEmpty<T extends string | Array<any> | { length: number }> (val: T, message: string): T {
         if (val == null) {
             throw new Error(`Value is undefined. ${message}`);
         }
-        if (typeof val === 'string' && val.trim().length === 0) {
-            throw new Error(`Value is empty string. ${message}`);
-        } else if ($Array.isArray(val) && val.length === 0) {
-            throw new Error(`Value is empty array. ${message}`);
+        if (typeof val === 'string') {
+            if (val.trim().length === 0) {
+                throw new Error(`Value is empty string. ${message}`);
+            }
+        } else if (typeof val ==='object' && 'length' in val) {
+            if (val.length === 0) {
+                throw new Error(`Value is empty array. ${message}`);
+            }
+        } else {
+            throw new Error(`Invalid type for notEmpty check: ${typeof val}: ${val}`);
         }
         return val;
     }