dequanto 0.1.75 → 0.1.80

package/src/contracts/deploy/Deployments.ts

@@ -22,6 +22,7 @@ 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';
 
 
 
@@ -37,6 +38,13 @@ type TDeploymentOptions = {
 
     // Will be used for verification process
     proxyFor?: TAddress
+
+    deployment?: {
+        // Pending deployment transaction will be re-checked
+        tx?: TEth.Hex
+        // When false, the implementation won't be updated in proxy
+        upgradeProxy?: boolean
+    }
 }
 type TVerificationOptions = TDeploymentOptions & {
     // otherwise will be fetched from the deployment TX
@@ -252,6 +260,7 @@ export class Deployments {
             arguments: constructorArgs,
             client: this.client,
             deployer: this.deployer as any,
+            tx: opts.deployment?.tx
         });
 
         let deployment = await this.store.saveDeployment(deployedContract, {
@@ -304,6 +313,7 @@ export class Deployments {
             force: opts?.force,
             latest: this.opts?.checkBytecode !== false,
             verification: opts?.verification,
+            deployment: opts?.deployment
         });
 
         let data = serializeInitData(id, contractImpl, opts.initialize);
@@ -321,7 +331,8 @@ export class Deployments {
             implementation: {
                 address: implementationAddress,
                 initData: data
-            }
+            },
+            upgradeImplementation: opts?.deployment?.upgradeProxy ?? true
         })
 
         if (contractImplDeployment.implementation == null) {

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

@@ -45,6 +45,7 @@ interface IDeploymentCtx {
     options?: {
         skipStorageLayoutCheck?: boolean
     }
+    upgradeImplementation?: boolean
 }
 
 interface IProxyDeploymentCtx extends IDeploymentCtx {
@@ -151,6 +152,7 @@ export class ProxyDeployment {
 
 
         let hasProxy = await deployments.has(Proxy, proxyOpts);
+        let shouldUpdate = ctx.upgradeImplementation ?? true;
         let {
             contract: contractProxy,
             receipt: contractProxyReceipt,
@@ -201,18 +203,21 @@ export class ProxyDeployment {
             let slotValue = await client.getStorageAt(contractProxy.address, SLOT);
             let address = `0x` + slotValue.slice(-40);
             if ($address.eq(address, implAddress) === false) {
-                await this.requireCompatibleStorageLayout(proxyId, ctx);
-
-                $logger.log(`Upgrading ProxyAdmin(${contractProxyAdmin.address}) to ${implAddress} (${v}) from ${address}`);
-                let receipt = await Interfaces.call(
-                    deployer,
-                    contractProxyAdmin,
-                    Interfaces.TransparentProxy[v].contractProxyAdmin.upgradeAndCall,
-                    contractProxy.address,
-                    implAddress,
-                    null // data
-                );
-                await this.saveStorageLayout(proxyId, ctx);
+                if (shouldUpdate) {
+                    await this.requireCompatibleStorageLayout(proxyId, ctx);
+                    $logger.log(`Upgrading ProxyAdmin(${contractProxyAdmin.address}) to ${implAddress} (${v}) from ${address}`);
+                    let receipt = await Interfaces.call(
+                        deployer,
+                        contractProxyAdmin,
+                        Interfaces.TransparentProxy[v].contractProxyAdmin.upgradeAndCall,
+                        contractProxy.address,
+                        implAddress,
+                        null // data
+                    );
+                    await this.saveStorageLayout(proxyId, ctx);
+                } else {
+                    $logger.log(`Skip upgrade ProxyAdmin(${contractProxyAdmin.address}) to ${implAddress} (${v}) from ${address}`);
+                }
             }
         }
         if (hasProxy === false && contractProxyReceipt != null) {

package/src/hardhat/HardhatProvider.ts

@@ -142,6 +142,7 @@ export class HardhatProvider {
         deployer?: EoAccount
         arguments?: any[]
         client?: Web3Client
+        tx?: TEth.Hex
     }): Promise<{
         contract: T
         receipt: TEth.TxReceipt
@@ -155,7 +156,9 @@ export class HardhatProvider {
         let receipt: TEth.TxReceipt;
 
         try {
-            receipt = await factory.deploy();
+            receipt = options?.tx
+                ? await client.getTransactionReceipt(options.tx)
+                : await factory.deploy();
         } catch (error) {
             let wrapped = new Error(`Deploy ${Ctor.name} failed: ` + error.message + `\n ${error.stack}`);
             (wrapped as any).data = error.data;

package/src/safe/GnosisSafeHandler.ts

@@ -304,7 +304,8 @@ export class GnosisSafeHandler {
                     if (typeof mix === 'object') {
                         return mix;
                     }
-                    return await ChainAccountService.get(mix)
+                    let account = await ChainAccountService.get(mix);
+                    return $require.notNull(account, `Account not found: ${mix}`);
                 })
                 .toArrayAsync();
 

package/src/solidity/SlotsStorage.ts

@@ -104,12 +104,9 @@ export class SlotsStorage {
 
         if (is_Object(value)) {
             // object
-            await alot
-                .fromObject(value)
-                .mapAsync(async entry => {
-                    await this.set([{ key: entry.key, type: 'key' }], entry.value);
-                })
-                .toArrayAsync();
+            for (let key in value) {
+                await this.set([{ key: key, type: 'key' }], value[key]);
+            }
             return;
         }
 

package/src/solidity/SolidityParser.ts

@@ -55,6 +55,18 @@ export namespace SolidityParser {
             })
             .toArrayAsync({ threads: 1 });
 
+        // fix: remove duplicates due to interfaces and multiple inheritance.
+        abisDef = alot(abisDef)
+            .map(def => {
+                let key = `${def.type} ${def.name} ${def.inputs?.map(input => input.type).join(',')}`;
+                return {
+                    key,
+                    def,
+                }
+            })
+            .distinctBy(x => x.key)
+            .map(x => x.def)
+            .toArray();
         return abisDef;
     }
 
@@ -91,7 +103,6 @@ export namespace SolidityParser {
             .mapAsync(async $event => Ast.getAbi($event, ctx, inheritanceChain))
             .toArrayAsync();
 
-
         return [
             ...abiFns,
             ...abiGetters,

package/src/solidity/storage/SlotsStorageTransport.ts

@@ -169,13 +169,13 @@ export class SlotsStorageTransportForMapping implements ISlotsStorageTransport {
 
     }
 
-    async getStorageAt (slot: string | number | bigint) {
+    async getStorageAt (slot: string | number | bigint, position: number, size: number) {
         let isValidType = typeof slot === 'number' || typeof slot === 'bigint' || $is.Hex(slot);
         if (isValidType === false) {
             throw new Error(`Mapping Slot reader supports only numbers for position ${slot}`);
         }
         let location = this.mapToGlobalSlot(BigInt(slot));
-        let memory = await this.getUnderlyingTransport().getStorageAt(location, 0, 256);
+        let memory = await this.getUnderlyingTransport().getStorageAt(location, position, size);
         return memory;
     }
 

package/src/solidity/storage/handlers/SlotBytesHandler.ts

@@ -122,7 +122,7 @@ export class SlotBytesHandler extends ASlotsStorageHandler {
                 let slotValue = await this.transport.setStorageAt(this.getSlot(i), 0, 256, buf);
                 return slotValue;
             })
-            .toArrayAsync()
+            .toArrayAsync({ threads: 1 })
     }
 
     protected getSlot (idx: number) {

package/src/solidity/storage/handlers/SlotMappingHandler.ts

@@ -30,7 +30,7 @@ export class SlotMappingHandler extends ASlotsStorageHandler {
         }
         let key = keys.shift();
         let storage = await this.getStorageInner(key);
-        storage.set(keys, value);
+        await storage.set(keys, value);
     }
 
     async fetchAll () {