dequanto 0.1.78 → 0.1.81

package/lib/types/contracts/deploy/proxy/ProxyDeployment.d.ts

@@ -22,6 +22,7 @@ export interface IBeacon extends ContractBase {
 interface IDeploymentCtx {
     ImplementationContract: Constructor<ContractBase>;
     deployer: IAccount;
+    owner?: IAccount;
     deployments: Deployments;
     implementation: {
         address: TAddress;
@@ -30,6 +31,7 @@ interface IDeploymentCtx {
     options?: {
         skipStorageLayoutCheck?: boolean;
     };
+    upgradeImplementation?: boolean;
 }
 interface IProxyDeploymentCtx extends IDeploymentCtx {
     proxyId: string;

package/lib/types/hardhat/HardhatProvider.d.ts

@@ -35,6 +35,7 @@ export declare class HardhatProvider {
         deployer?: EoAccount;
         arguments?: any[];
         client?: Web3Client;
+        tx?: TEth.Hex;
     }): Promise<{
         contract: T;
         receipt: TEth.TxReceipt;

package/lib/types/services/TimelockService/TimelockService.d.ts

@@ -18,6 +18,10 @@ export declare class TimelockService implements ITimelockService {
         status: ETimelockTxStatus;
         schedule: ITimelockTx;
     }>;
+    getPendingFromTx(txHash: TEth.Hex): Promise<{
+        status: ETimelockTxStatus;
+        schedule: ITimelockTx;
+    }>;
     executePendingByTitle(sender: IAccount, title: string): Promise<{
         tx: TxWriter;
         schedule: ITimelockTx;

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

@@ -6,8 +6,9 @@ export declare namespace $bigint {
     function max(...args: bigint[]): bigint;
     function min(...args: bigint[]): bigint;
     function toBigInt(amount: string | number | bigint | Uint8Array): bigint;
+    function from(amount: number | bigint | string): bigint;
     /**
-     * @param amount e.g "2.4 ether", "10 gwei", "1.7^18", "123456"
+     * @param amount e.g "2.4 ether", "10 gwei", "1.7^18", "123456", "1.7e18"
      */
     function parse(amount: string): bigint;
     function ensureWei(amount: number | bigint, decimals: number): bigint;

package/package.json

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

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,15 @@ 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
+        // Owner, if differes from deployer
+        owner?: TEth.IAccount
+    }
 }
 type TVerificationOptions = TDeploymentOptions & {
     // otherwise will be fetched from the deployment TX
@@ -67,6 +77,7 @@ export class Deployments {
         }
 
     constructor(public client: Web3Client, public deployer: IAccount, public opts: {
+        owner?: IAccount
         Proxy?: Constructor<ContractBase>,
         ProxyAdmin?: Constructor<IProxyAdmin>
         directory?: string
@@ -252,6 +263,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 +316,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);
@@ -317,11 +330,13 @@ export class Deployments {
             ImplementationContract: CtorImpl,
             proxyId: proxyId,
             deployer: this.deployer,
+            owner: opts.deployment?.owner ?? this.opts?.owner ?? this.deployer,
             deployments: this,
             implementation: {
                 address: implementationAddress,
                 initData: data
-            }
+            },
+            upgradeImplementation: opts.deployment?.upgradeProxy ?? true
         })
 
         if (contractImplDeployment.implementation == null) {

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

@@ -37,6 +37,7 @@ export interface IBeacon extends ContractBase {
 interface IDeploymentCtx {
     ImplementationContract: Constructor<ContractBase>
     deployer: IAccount
+    owner?: IAccount
     deployments: Deployments
     implementation: {
         address: TAddress
@@ -45,6 +46,7 @@ interface IDeploymentCtx {
     options?: {
         skipStorageLayoutCheck?: boolean
     }
+    upgradeImplementation?: boolean
 }
 
 interface IProxyDeploymentCtx extends IDeploymentCtx {
@@ -151,6 +153,7 @@ export class ProxyDeployment {
 
 
         let hasProxy = await deployments.has(Proxy, proxyOpts);
+        let shouldUpdate = ctx.upgradeImplementation ?? true;
         let {
             contract: contractProxy,
             receipt: contractProxyReceipt,
@@ -201,18 +204,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(
+                        ctx.owner ?? 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/indexer/EventsIndexer.ts

@@ -106,7 +106,9 @@ export class EventsIndexer <TContract extends ContractBase> {
     > (
         event: TLogName | TLogName[] | '*',
         options?: {
+            // includes block
             fromBlock?: number
+            // includes block
             toBlock?: number
             blockRangeLimits?: WClient['blockRangeLimits']
             params?: Partial<TContract['Types']['Events'][TLogName]['outputParams']>
@@ -183,6 +185,10 @@ export class EventsIndexer <TContract extends ContractBase> {
         fromBlock?: number
         filterKey?: string
     }): Promise<TRange[]> {
+        let fromBlock = opts?.fromBlock ?? initialBlockNumber;
+        if (fromBlock != null) {
+            $require.lte(fromBlock, toBlock, `Invalid block range order`);
+        }
         let logsMetaArr = await this.storeMeta.fetch();
         let eventsBlock = alot(logsMetaArr)
             .filter(x => x.filterKey == opts?.filterKey)
@@ -198,15 +204,24 @@ export class EventsIndexer <TContract extends ContractBase> {
         if (hasInitialBlock === false) {
             let blockNr = opts?.fromBlock ?? await this.getInitialBlockNumber();
             logsMeta.filter(x => x.lastBlock == null).forEach(x => x.lastBlock = blockNr);
-        };
+        }
 
         let ranges = [] as TRange[];
-        let blockNumbers = [ ...logsMeta.map(x => x.lastBlock), toBlock ];
-        let blockNumberSteps = alot(blockNumbers).distinct().sortBy(x => x).toArray();
+        let blockNumbers = [ ...logsMeta.map(x => x.lastBlock), toBlock ].filter(x => x <= toBlock);
 
+        let blockNumberSteps = alot(blockNumbers).distinct().sortBy(x => x).toArray();
+        if (blockNumberSteps.length === 1) {
+            let [ block ] = blockNumberSteps;
+            ranges.push({
+                fromBlock: block,
+                toBlock: block,
+                events: events
+            });
+        }
         for (let i = 0; i < blockNumberSteps.length - 1; i++) {
             let from = blockNumberSteps[i];
             if (i > 0) {
+                // The range includes both blocks: [x, y], but we want (x, y], so we make [x + 1, y]
                 from += 1;
             }
             let to = blockNumberSteps[i + 1];

package/src/services/TimelockService/TimelockService.ts

@@ -57,6 +57,42 @@ export class TimelockService implements ITimelockService {
         return { status, schedule };
     }
 
+    async getPendingFromTx (txHash: TEth.Hex): Promise<{
+        status: ETimelockTxStatus;
+        schedule: ITimelockTx;
+    }> {
+        let receipt = await this.timelock.client.getTransactionReceipt(txHash);
+        $require.notNull(receipt, `Tx ${txHash} not found`);
+        let block = await this.timelock.client.getBlock(receipt.blockNumber);
+        let contract = new TimelockController(void 0, this.timelock.client);
+        let callScheduled = contract.extractLogsCallScheduled(receipt);
+        $require.gte(callScheduled.length, 1, `Expected at least 1 CallScheduled log`);
+
+        let callSaltArr = contract.extractLogsCallSalt(receipt);
+        $require.eq(callSaltArr.length, 1, `Expected 1 CallSalt log, but got ${callSaltArr.length}`);
+        let [ callSalt ] = callSaltArr;
+
+        let [ callScheduleFirst ] = callScheduled;
+        callScheduleFirst.params.delay
+
+        let schedule = {
+            sender: null,
+            key: callSalt.params.id,
+            id: callSalt.params.id,
+            salt: callSalt.params.salt,
+            to: callScheduled.map(x => x.params.target),
+            data: callScheduled.map(x => x.params.data),
+            value: callScheduled.map(x => $hex.ensure(x.params.value)),
+            predecessor: null,
+            createdAt: block.timestamp,
+            validAt: block.timestamp + Number(callScheduleFirst.params.delay),
+            status: 'pending',
+            txSchedule: txHash,
+        } as ITimelockTx;
+        let status = await this.getScheduleStatus(schedule);
+        return { status, schedule };
+    }
+
     async executePendingByTitle (sender: IAccount, title: string): Promise<{
         tx: TxWriter;
         schedule: ITimelockTx;

package/src/utils/$bigint.ts

@@ -49,8 +49,25 @@ export namespace $bigint {
         return BigInt(Math.round(amount));
     }
 
+    export function from (amount: number | bigint | string): bigint {
+        if (amount == null) {
+            return 0n;
+        }
+        switch (typeof amount) {
+            case 'bigint':
+                return amount;
+            case 'number':
+                return BigInt(amount);
+            case'string':
+                return parse(amount);
+            default:
+                break;
+        }
+        throw new Error(`Invalid $bigint.from type: ${amount}`);
+    }
+
     /**
-     * @param amount e.g "2.4 ether", "10 gwei", "1.7^18", "123456"
+     * @param amount e.g "2.4 ether", "10 gwei", "1.7^18", "123456", "1.7e18"
      */
     export function parse (amount: string): bigint {
         if (/^\d+$/.test(amount) || $is.Hex(amount) ) {
@@ -76,7 +93,7 @@ export namespace $bigint {
         }
 
         // 2.5^18
-        let rgxMantissa = /^(?<number>[\d.]+)\s*\^\s*(?<decimals>\d+)$/;
+        let rgxMantissa = /^(?<number>[\d.]+)\s*[\^e]\s*(?<decimals>\d+)$/;
         let rgxMantissaMatch = rgxMantissa.exec(amount);
         if (rgxMantissaMatch != null) {
             let number = Number(rgxMantissaMatch.groups.number);