dequanto 0.1.80 → 0.1.84

package/lib/types/blocks/BlockDateResolver.d.ts

@@ -2,14 +2,15 @@ import { Web3Client } from '../clients/Web3Client';
 export declare class BlockDateResolver {
     client: Web3Client;
     private AVG_INITIAL;
-    private closestTime;
-    private closestIdx;
-    private maxBlock;
-    private known;
-    private q;
+    private _known;
+    private _requestedDate;
     constructor(client: Web3Client);
     getDate(blockNumber: number): Promise<Date>;
     getBlockNumberFor(date: Date): Promise<number>;
+    getBlockInfoFor(date: Date): Promise<{
+        block: number;
+        timestamp: number;
+    }>;
     private moveNext;
     /**
      * Returns index of the first known block, which is most near to specified block (it can be before or after the specified date).
@@ -28,4 +29,5 @@ export declare class BlockDateResolver {
     private getAvgBlockCountBetween;
     /** With N>1 blocks we can better find out the AVG block time */
     private refineAvg;
+    private getBlock;
 }

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

@@ -18,12 +18,14 @@ type TDeploymentOptions = {
     deployment?: {
         tx?: TEth.Hex;
         upgradeProxy?: boolean;
+        owner?: TEth.IAccount;
     };
 };
 export declare class Deployments {
     client: Web3Client;
     deployer: IAccount;
     opts: {
+        owner?: IAccount;
         Proxy?: Constructor<ContractBase>;
         ProxyAdmin?: Constructor<IProxyAdmin>;
         directory?: string;
@@ -43,6 +45,7 @@ export declare class Deployments {
     private _proxyDeployment;
     private _config;
     constructor(client: Web3Client, deployer: IAccount, opts?: {
+        owner?: IAccount;
         Proxy?: Constructor<ContractBase>;
         ProxyAdmin?: Constructor<IProxyAdmin>;
         directory?: string;

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;

package/lib/types/models/TAccount.d.ts

@@ -3,7 +3,7 @@ import { TAddress } from './TAddress';
 import { TEth } from './TEth';
 import { TPlatform } from './TPlatform';
 export interface IAccount {
-    type?: 'eoa' | 'safe' | 'erc4337';
+    type?: 'eoa' | 'safe' | 'erc4337' | 'timelock';
     name?: string;
     platform?: TPlatform;
     address?: TAddress;
@@ -41,5 +41,11 @@ export interface Erc4337Account extends IAccount {
     platform: TPlatform;
     operator: EoAccount;
 }
+export interface TimelockAccount extends IAccount {
+    type: 'timelock';
+    provider?: 'default' | string;
+    platform: TPlatform;
+    operator: EoAccount;
+}
 export type TAccount = string | IAccount | EoAccount | SafeAccount | Erc4337Account;
 export {};

package/lib/types/prebuilt-factories/TimelockControllerFactory.d.ts

@@ -0,0 +1,188 @@
+import { TAddress } from '../models/TAddress';
+import type { TEth } from '../models/TEth';
+import type { TimelockController as TimelockControllerType } from '../prebuilt/openzeppelin/TimelockController';
+export declare function TimelockControllerFactory(): typeof TimelockControllerType;
+export type TTimelockControllerTypes = {
+    Events: {
+        CallExecuted: {
+            outputParams: {
+                id: TEth.Hex;
+                index: bigint;
+                target: TAddress;
+                value: bigint;
+                data: TEth.Hex;
+            };
+            outputArgs: [id: TEth.Hex, index: bigint, target: TAddress, value: bigint, data: TEth.Hex];
+        };
+        CallSalt: {
+            outputParams: {
+                id: TEth.Hex;
+                salt: TEth.Hex;
+            };
+            outputArgs: [id: TEth.Hex, salt: TEth.Hex];
+        };
+        CallScheduled: {
+            outputParams: {
+                id: TEth.Hex;
+                index: bigint;
+                target: TAddress;
+                value: bigint;
+                data: TEth.Hex;
+                predecessor: TEth.Hex;
+                delay: bigint;
+            };
+            outputArgs: [id: TEth.Hex, index: bigint, target: TAddress, value: bigint, data: TEth.Hex, predecessor: TEth.Hex, delay: bigint];
+        };
+        Cancelled: {
+            outputParams: {
+                id: TEth.Hex;
+            };
+            outputArgs: [id: TEth.Hex];
+        };
+        MinDelayChange: {
+            outputParams: {
+                oldDuration: bigint;
+                newDuration: bigint;
+            };
+            outputArgs: [oldDuration: bigint, newDuration: bigint];
+        };
+        RoleAdminChanged: {
+            outputParams: {
+                role: TEth.Hex;
+                previousAdminRole: TEth.Hex;
+                newAdminRole: TEth.Hex;
+            };
+            outputArgs: [role: TEth.Hex, previousAdminRole: TEth.Hex, newAdminRole: TEth.Hex];
+        };
+        RoleGranted: {
+            outputParams: {
+                role: TEth.Hex;
+                account: TAddress;
+                _sender: TAddress;
+            };
+            outputArgs: [role: TEth.Hex, account: TAddress, _sender: TAddress];
+        };
+        RoleRevoked: {
+            outputParams: {
+                role: TEth.Hex;
+                account: TAddress;
+                _sender: TAddress;
+            };
+            outputArgs: [role: TEth.Hex, account: TAddress, _sender: TAddress];
+        };
+    };
+    Methods: {
+        CANCELLER_ROLE: {
+            method: "CANCELLER_ROLE";
+            arguments: [];
+        };
+        DEFAULT_ADMIN_ROLE: {
+            method: "DEFAULT_ADMIN_ROLE";
+            arguments: [];
+        };
+        EXECUTOR_ROLE: {
+            method: "EXECUTOR_ROLE";
+            arguments: [];
+        };
+        PROPOSER_ROLE: {
+            method: "PROPOSER_ROLE";
+            arguments: [];
+        };
+        TIMELOCK_ADMIN_ROLE: {
+            method: "TIMELOCK_ADMIN_ROLE";
+            arguments: [];
+        };
+        cancel: {
+            method: "cancel";
+            arguments: [id: TEth.Hex];
+        };
+        execute: {
+            method: "execute";
+            arguments: [target: TAddress, value: bigint, payload: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex];
+        };
+        executeBatch: {
+            method: "executeBatch";
+            arguments: [targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex];
+        };
+        getMinDelay: {
+            method: "getMinDelay";
+            arguments: [];
+        };
+        getRoleAdmin: {
+            method: "getRoleAdmin";
+            arguments: [role: TEth.Hex];
+        };
+        getTimestamp: {
+            method: "getTimestamp";
+            arguments: [id: TEth.Hex];
+        };
+        grantRole: {
+            method: "grantRole";
+            arguments: [role: TEth.Hex, account: TAddress];
+        };
+        hasRole: {
+            method: "hasRole";
+            arguments: [role: TEth.Hex, account: TAddress];
+        };
+        hashOperation: {
+            method: "hashOperation";
+            arguments: [target: TAddress, value: bigint, data: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex];
+        };
+        hashOperationBatch: {
+            method: "hashOperationBatch";
+            arguments: [targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex];
+        };
+        isOperation: {
+            method: "isOperation";
+            arguments: [id: TEth.Hex];
+        };
+        isOperationDone: {
+            method: "isOperationDone";
+            arguments: [id: TEth.Hex];
+        };
+        isOperationPending: {
+            method: "isOperationPending";
+            arguments: [id: TEth.Hex];
+        };
+        isOperationReady: {
+            method: "isOperationReady";
+            arguments: [id: TEth.Hex];
+        };
+        onERC1155BatchReceived: {
+            method: "onERC1155BatchReceived";
+            arguments: [input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex];
+        };
+        onERC1155Received: {
+            method: "onERC1155Received";
+            arguments: [input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex];
+        };
+        onERC721Received: {
+            method: "onERC721Received";
+            arguments: [input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex];
+        };
+        renounceRole: {
+            method: "renounceRole";
+            arguments: [role: TEth.Hex, account: TAddress];
+        };
+        revokeRole: {
+            method: "revokeRole";
+            arguments: [role: TEth.Hex, account: TAddress];
+        };
+        schedule: {
+            method: "schedule";
+            arguments: [target: TAddress, value: bigint, data: TEth.Hex, predecessor: TEth.Hex, salt: TEth.Hex, delay: bigint];
+        };
+        scheduleBatch: {
+            method: "scheduleBatch";
+            arguments: [targets: TAddress[], values: bigint[], payloads: TEth.Hex[], predecessor: TEth.Hex, salt: TEth.Hex, delay: bigint];
+        };
+        supportsInterface: {
+            method: "supportsInterface";
+            arguments: [interfaceId: TEth.Hex];
+        };
+        updateDelay: {
+            method: "updateDelay";
+            arguments: [newDelay: bigint];
+        };
+    };
+};

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

@@ -1,11 +1,15 @@
-import { TimelockController } from '../../prebuilt/openzeppelin/TimelockController';
-import { ContractBase } from '../../contracts/ContractBase';
 import { IAccount } from '../../models/TAccount';
 import { TEth } from '../../models/TEth';
 import { TxWriter } from '../../txs/TxWriter';
 import { ITimelockTx, ITimelockTxParams, ITimelockService, ETimelockTxStatus } from './ITimelockService';
 import { TTxWriteMethodKeys } from '../../utils/types';
-type TTimelockController = ContractBase & Pick<TimelockController, 'schedule' | 'scheduleBatch' | 'execute' | 'executeBatch' | 'getMinDelay' | 'cancel'>;
+import type { TimelockController } from '../../prebuilt/openzeppelin/TimelockController';
+import type { ContractBase } from '../../contracts/ContractBase';
+import { TxDataBuilder } from '../../txs/TxDataBuilder';
+declare const CONFIG: {
+    dir: string;
+};
+type TTimelockController = ContractBase & Pick<TimelockController, 'schedule' | 'scheduleBatch' | 'execute' | 'executeBatch' | 'getMinDelay' | 'cancel' | 'extractLogsCallScheduled' | 'extractLogsCallSalt'>;
 export declare class TimelockService implements ITimelockService {
     private timelock;
     private options?;
@@ -18,6 +22,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;
@@ -39,6 +47,12 @@ export declare class TimelockService implements ITimelockService {
         schedule: ITimelockTx;
         tx?: TEth.Hex;
     }>;
+    processData(sender: IAccount, builder: TxDataBuilder): Promise<{
+        prevStatus: ETimelockTxStatus;
+        status: ETimelockTxStatus;
+        schedule: ITimelockTx;
+        tx?: TEth.Hex;
+    }>;
     /** Schedules-Wait-Execute a task distinguished by the unique task name
      *
      * 1. if schedule doesn't exist, create it
@@ -104,5 +118,6 @@ export declare class TimelockService implements ITimelockService {
     private getTxParamsNormalizedFromContract;
     private getTxParamsNormalizedFromContractBatch;
     private getStore;
+    static config(config: Partial<typeof CONFIG>): void;
 }
 export {};

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

@@ -9,7 +9,7 @@ import { ITxLogItem } from './receipt/ITxLogItem';
 import { ISafeServiceTransport } from '../safe/transport/ISafeServiceTransport';
 import { TEth } from '../models/TEth';
 import { SafeServiceTypes } from '../safe/types/SafeServiceTypes';
-interface ITxWriterEvents {
+export interface ITxWriterEvents {
     transactionHash(hash: TEth.Hex): any;
     receipt(receipt: TEth.TxReceipt): any;
     confirmation(confNumber: number, receipt: TEth.TxReceipt): any;
@@ -18,6 +18,22 @@ interface ITxWriterEvents {
     log(message: string): any;
     safeTxProposed(safeTx: SafeServiceTypes.ProposeTransactionProps): any;
 }
+export interface ITxWriterEmitter {
+    onSent: PromiseLike<string | TEth.Hex>;
+    onCompleted: PromiseLike<TEth.TxReceipt>;
+    tx: ITxWriterTransaction;
+    receipt: TEth.TxReceipt;
+    on(event: keyof ITxWriterEvents, callback: Function): any | this;
+}
+export interface ITxWriterTransaction {
+    timestamp: number;
+    confirmations: number;
+    hash?: TEth.Hex;
+    timeout?: NodeJS.Timer;
+    receipt?: TEth.TxReceipt;
+    error?: Error;
+    knownLogs?: ITxLogItem[];
+}
 export interface ITxWriterOptions {
     timeout?: number | boolean;
     retries?: number;
@@ -47,7 +63,7 @@ export interface ITxWriterOptions {
      */
     silent?: boolean;
 }
-export declare class TxWriter extends class_EventEmitter<ITxWriterEvents> {
+export declare class TxWriter extends class_EventEmitter<ITxWriterEvents> implements ITxWriterEmitter {
     client: Web3Client;
     builder: TxDataBuilder;
     account: TAccount;
@@ -59,16 +75,8 @@ export declare class TxWriter extends class_EventEmitter<ITxWriterEvents> {
     onConfirmed(waitForCount: number): Promise<string>;
     wait(): Promise<TEth.TxReceipt>;
     id: string;
-    tx: {
-        timestamp: number;
-        confirmations: number;
-        hash?: TEth.Hex;
-        timeout?: NodeJS.Timer;
-        receipt?: TEth.TxReceipt;
-        error?: Error;
-        knownLogs?: ITxLogItem[];
-    };
-    txs: TxWriter['tx'][];
+    tx: ITxWriterTransaction;
+    txs: ITxWriterTransaction[];
     options: ITxWriterOptions;
     private logger;
     private confirmationAwaiters;
@@ -106,4 +114,3 @@ export type TTxWriterJson = {
     txs: TxWriter['txs'];
     builder: ReturnType<TxDataBuilder['toJSON']>;
 };
-export {};

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

@@ -0,0 +1,26 @@
+import { EoAccount, TAccount, TimelockAccount } from '../../models/TAccount';
+import { ITxWriterAccountAgent } from './TxWriterAccountAgents';
+import { ITxWriterEmitter, ITxWriterEvents, ITxWriterTransaction, TxWriter } from '../TxWriter';
+import { class_Dfr, class_EventEmitter } from 'atma-utils';
+import { TEth } from '../../models/TEth';
+import { ITimelockTx } from '../../services/TimelockService/ITimelockService';
+import { Web3Client } from '../../clients/Web3Client';
+import { TimelockService } from '../../services/TimelockService/TimelockService';
+export declare class TimelockAgent implements ITxWriterAccountAgent {
+    supports(account: TAccount): account is TimelockAccount;
+    process(senderMix: string | EoAccount, timelockAccount: TimelockAccount, outerWriter: TxWriter): Promise<TimelockTxWriter>;
+}
+export declare class TimelockTxWriter extends class_EventEmitter<ITxWriterEvents> implements ITxWriterEmitter {
+    private client;
+    private sender;
+    private service;
+    private outerWriter;
+    onSent: class_Dfr<string>;
+    onCompleted: class_Dfr<TEth.TxReceipt>;
+    receipt: TEth.TxReceipt;
+    tx: ITxWriterTransaction;
+    schedule: ITimelockTx;
+    delayTimer: any;
+    constructor(client: Web3Client, sender: TEth.IAccount, service: TimelockService, outerWriter: TxWriter);
+    process(): Promise<this>;
+}

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

@@ -1,8 +1,8 @@
 import type { EoAccount, TAccount } from '../../models/TAccount';
-import type { TxWriter } from '../TxWriter';
+import type { ITxWriterEmitter, TxWriter } from '../TxWriter';
 export interface ITxWriterAccountAgent {
     supports(account: TAccount): boolean;
-    process(sender: EoAccount, account: TAccount, outerWriter: TxWriter): Promise<TxWriter>;
+    process(sender: EoAccount, account: TAccount, outerWriter: TxWriter): Promise<ITxWriterEmitter>;
 }
 export declare namespace TxWriterAccountAgents {
     function register(agent: ITxWriterAccountAgent): void;

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

@@ -1,6 +1,7 @@
-import { EoAccount, Erc4337Account, SafeAccount, TAccount } from "../models/TAccount";
+import { EoAccount, Erc4337Account, SafeAccount, TAccount, TimelockAccount } from "../models/TAccount";
 export declare namespace $account {
     function getSender(account: TAccount): EoAccount;
     function isSafe(account: TAccount): account is SafeAccount;
     function isErc4337(account: TAccount): account is Erc4337Account;
+    function isTimelock(account: TAccount): account is TimelockAccount;
 }

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/lib/types/utils/$date.d.ts

@@ -55,6 +55,7 @@ export declare namespace $date {
     function dayEnd(date?: Date): Date;
     function weekStart(date?: Date): Date;
     function weekEnd(date?: Date): Date;
+    function weekNumber(date?: Date): number;
     function monthStart(date?: Date): Date;
     function monthEnd(date?: Date): Date;
     /** date1 + X === date2 */

package/package.json

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

package/src/blocks/BlockDateResolver.ts

@@ -1,6 +1,9 @@
+import alot from 'alot';
+import memd from 'memd';
 import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TEth } from '@dequanto/models/TEth';
 import { $block } from '@dequanto/utils/$block';
-import alot from 'alot';
+import { $date } from '@dequanto/utils/$date';
 
 export class BlockDateResolver {
     private AVG_INITIAL = {
@@ -9,24 +12,22 @@ export class BlockDateResolver {
         polygon: 3_000,
     };
 
-    private closestTime: number;
-    private closestIdx: number;
-    private maxBlock: number;
 
-    private known = [] as IKnownBlock[]
-    private q: Date;
+
+    private _known = [] as IKnownBlock[]
+    private _requestedDate: Date;
 
     constructor(public client: Web3Client) {
 
     }
 
     async getDate (blockNumber: number): Promise<Date> {
-        let block = await this.client.getBlock(blockNumber);
+        let block = await this.getBlock(blockNumber);
         return new Date(block.timestamp * 1000);
     }
 
     async getBlockNumberFor (date: Date): Promise<number> {
-        this.q = date;
+        this._requestedDate = date;
 
         let avg = this.AVG_INITIAL[this.client.platform] ?? this.client.blockTimeAvg ?? this.AVG_INITIAL['eth'];
         let now = new Date();
@@ -36,38 +37,65 @@ export class BlockDateResolver {
             avg,
         };
 
-        this.maxBlock = topBlock.blockNumber;
-        this.known.push(topBlock);
-        return await this.moveNext(date, {
+
+        this._known.push(topBlock);
+        const result = await this.moveNext(date, {
             closestTime: null,
             blockNumber: null,
+            date: null
         });
+        return result.blockNumber;
+    }
+
+    async getBlockInfoFor (date: Date): Promise<{ block: number, timestamp: number }> {
+        this._requestedDate = date;
+
+        let avg = this.AVG_INITIAL[this.client.platform] ?? this.client.blockTimeAvg ?? this.AVG_INITIAL['eth'];
+        let now = new Date();
+        let topBlock = <IKnownBlock> {
+            blockNumber: await this.client.getBlockNumberCached(),
+            date: now,
+            avg,
+        };
+
+        this._known.push(topBlock);
+        const result = await this.moveNext(date, {
+            closestTime: null,
+            blockNumber: null,
+            date: null,
+        });
+        return {
+            block: result.blockNumber,
+            timestamp: result.date ? $date.toUnixTimestamp(result.date) : null,
+        };
     }
 
     private async moveNext (date: Date, ctx: {
         closestTime: number;
         blockNumber: number;
-    }) {
+        date: Date;
+    }): Promise<IKnownBlock> {
 
         let closestIndex = this.getClosest(date);
-        let block = this.known[closestIndex];
+        let block = this._known[closestIndex];
         let timeDiff = this.diffTime(block.date, date);
 
         let timeDistance = Math.abs(timeDiff);
         const BLOCKS_TOLERANCE = 2;
         if (timeDistance <= block.avg * BLOCKS_TOLERANCE) {
-            return block.blockNumber;
+            return block;
         }
         if (ctx.closestTime != null && timeDistance >= ctx.closestTime) {
-            return ctx.blockNumber;
+            return ctx;
         }
 
         ctx.closestTime = timeDistance;
         ctx.blockNumber = block.blockNumber;
+        ctx.date = block.date;
 
         let nextInfo = await this.checkPoint(block, timeDiff);
         if (nextInfo == null) {
-            return block.blockNumber;
+            return block;
         }
 
         return this.moveNext(date, ctx);
@@ -77,11 +105,11 @@ export class BlockDateResolver {
      * Returns index of the first known block, which is most near to specified block (it can be before or after the specified date).
      */
     private getClosest (date: Date) {
-        let entry = alot(this.known).map(x => [
+        let entry = alot(this._known).map(x => [
             this.diffTimeAbs(x.date, date),
             x
         ] as const).minItem(x => x[0])[1];
-        let i = this.known.indexOf(entry);
+        let i = this._known.indexOf(entry);
         return i;
     }
 
@@ -92,7 +120,7 @@ export class BlockDateResolver {
         }
         let blockNumber = anchor.blockNumber + diffCount;
         if (blockNumber < 0) {
-            throw new Error(`Date Out of range: ${ this.q.toISOString() }. Based on the AVG block time, the blockchain was not active on that date`);
+            throw new Error(`Date Out of range: ${ this._requestedDate.toISOString() }. Based on the AVG block time, the blockchain was not active on that date`);
         }
         let date = await this.getBlockDate(blockNumber);
         let info = {
@@ -106,18 +134,18 @@ export class BlockDateResolver {
 
     /** Add a know block to set */
     private push(info: IKnownBlock) {
-        for (let i = 0; i < this.known.length; i++) {
-            let x = this.known[i];
+        for (let i = 0; i < this._known.length; i++) {
+            let x = this._known[i];
             if (info.date < x.date) {
-                this.known.splice(i, 0, info);
+                this._known.splice(i, 0, info);
                 return;
             }
         }
-        this.known.push(info);
+        this._known.push(info);
     }
     /** Loads the block and gets the Date of the block */
     private async getBlockDate (blockNumber: number) {
-        let block = await this.client.getBlock(blockNumber);
+        let block = await this.getBlock(blockNumber);
         if (block == null) {
             throw new Error(`Block not loaded: ${blockNumber}`);
         }
@@ -139,16 +167,21 @@ export class BlockDateResolver {
     }
     /** With N>1 blocks we can better find out the AVG block time */
     private refineAvg () {
-        for (let i = 1; i < this.known.length; i++) {
-            let info = this.known[i];
-            let prev = this.known[i - 1];
+        for (let i = 1; i < this._known.length; i++) {
+            let info = this._known[i];
+            let prev = this._known[i - 1];
 
             info.avg = this.getAvgBlockCountBetween(prev, info);
             if (i === 1) {
-                this.known[0].avg = info.avg;
+                this._known[0].avg = info.avg;
             }
         }
     }
+
+    @memd.deco.memoize()
+    private getBlock (blockNumber: number): Promise<TEth.Block> {
+        return this.client.getBlock(blockNumber);
+    }
 }
 
 interface IKnownBlock {

package/src/contracts/deploy/Deployments.ts

@@ -44,6 +44,8 @@ type TDeploymentOptions = {
         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 & {
@@ -75,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
@@ -327,12 +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
+            upgradeImplementation: opts.deployment?.upgradeProxy ?? true
         })
 
         if (contractImplDeployment.implementation == null) {