dequanto 0.1.80 → 0.1.84

package/src/services/TimelockService/TimelockService.ts

@@ -1,6 +1,4 @@
 import memd from 'memd';
-import { TimelockController } from '@dequanto/prebuilt/openzeppelin/TimelockController';
-import { ContractBase } from '@dequanto/contracts/ContractBase';
 import { JsonArrayStore } from '@dequanto/json/JsonArrayStore';
 import { IAccount } from '@dequanto/models/TAccount';
 import { TAddress } from '@dequanto/models/TAddress';
@@ -19,10 +17,25 @@ import { File } from 'atma-io';
 import { ITimelockTx, ITimelockTxParamsNormalized, ITimelockTxParams, ITimelockService, ETimelockTxStatus } from './ITimelockService';
 import { TTxWriteMethodKeys } from '@dequanto/utils/types';
 
+import type { TimelockController } from '@dequanto/prebuilt/openzeppelin/TimelockController';
+import type { ContractBase } from '@dequanto/contracts/ContractBase';
+
+import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
+
+const CONFIG = {
+    dir: `0x/data`
+};
 
 
 type TTimelockController = ContractBase & Pick<TimelockController,
-    'schedule' | 'scheduleBatch' | 'execute' | 'executeBatch' | 'getMinDelay' | 'cancel'
+    'schedule'
+    | 'scheduleBatch'
+    | 'execute'
+    | 'executeBatch'
+    | 'getMinDelay'
+    | 'cancel'
+    | 'extractLogsCallScheduled'
+    | 'extractLogsCallSalt'
 >;
 
 export class TimelockService implements ITimelockService {
@@ -37,7 +50,7 @@ export class TimelockService implements ITimelockService {
             // Only for hardhat client. Default: false
             execute?: boolean
 
-            // Directory to store the submitted schedules, default: `./0x/data/`
+            // Directory to store the submitted schedules, default: `./0x/data/`, or use `TimelockService.config` to override it globally
             dir?: string
         }
     ) {
@@ -57,6 +70,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 = this.timelock;
+        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;
@@ -103,11 +152,32 @@ export class TimelockService implements ITimelockService {
         schedule: ITimelockTx
         tx?: TEth.Hex
     }> {
-
         let txParams = await this.getTxParamsNormalizedFromContract(uniqueTaskName, sender, contract, method, ...params);
         return await this.processTxParams(txParams);
     }
 
+    async processData (
+        sender: IAccount,
+        builder: TxDataBuilder
+    ): Promise<{
+        prevStatus: ETimelockTxStatus
+        status: ETimelockTxStatus
+        schedule: ITimelockTx
+        tx?: TEth.Hex
+    }> {
+        let { to, data, value } = builder.data;
+        let titleKey = `${to}${data}`;
+        let params = <ITimelockTxParams> {
+            title: $contract.keccak256(titleKey, 'hex'),
+            sender: sender,
+            to: to,
+            data: data,
+            value: value
+        };
+        let txParams = await this.getTxParamsNormalized (params);
+        return await this.processTxParams(txParams);
+    }
+
     /** Schedules-Wait-Execute a task distinguished by the unique task name
      *
      * 1. if schedule doesn't exist, create it
@@ -485,7 +555,7 @@ export class TimelockService implements ITimelockService {
     private async getUniqueByKey (key: TEth.Hex): Promise<ITimelockTx> {
         let store = await this.getStore();
         let all = await store.getAll();
-        let arr = all.filter(x => x.key === key);
+        let arr = all.filter(x => x.key === key && x.status === 'pending');
         $require.lt(arr.length, 2, `Timelock service expects ${key} to be unique. Found ${arr.length}`);
         return arr.length === 1 ? arr[0] : null;
     }
@@ -577,7 +647,7 @@ export class TimelockService implements ITimelockService {
     @memd.deco.memoize({ perInstance: true })
     private async getStore () {
         let { platform, network } = this.timelock.client;
-        let dir = this.options?.dir ?? `0x/data`;
+        let dir = this.options?.dir ?? CONFIG.dir;
 
         let path = getPath(platform, dir);
         if (platform === 'hardhat' && network !== platform) {
@@ -595,6 +665,12 @@ export class TimelockService implements ITimelockService {
             key: x => x.id
         });
     }
+
+    static config (config: Partial<typeof CONFIG>) {
+        if (config.dir) {
+            CONFIG.dir = CONFIG.dir;
+        }
+    }
 }
 
 namespace util {

package/src/txs/TxWriter.ts

@@ -26,15 +26,17 @@ import { TxLogParser } from './receipt/TxLogParser';
 
 import { ISafeServiceTransport } from '@dequanto/safe/transport/ISafeServiceTransport';
 import { SigFileTransport } from './sig-transports/SigFileTransport';
-import { TxWriterAccountAgents } from './agents/TxWriterAccountAgents';
 import { PromiseEvent } from '@dequanto/class/PromiseEvent';
 import { $sig } from '@dequanto/utils/$sig';
 import { TEth } from '@dequanto/models/TEth';
 import { SafeServiceTypes } from '@dequanto/safe/types/SafeServiceTypes';
 import { ChainAccountService } from '@dequanto/ChainAccountService';
 import { $is } from '@dequanto/utils/$is';
+import { TxWriterAccountAgents } from './agents/TxWriterAccountAgents';
+
 
-interface ITxWriterEvents {
+
+export interface ITxWriterEvents {
     transactionHash (hash: TEth.Hex)
     receipt (receipt: TEth.TxReceipt)
     confirmation (confNumber: number, receipt: TEth.TxReceipt)
@@ -43,6 +45,25 @@ interface ITxWriterEvents {
     log (message: string)
     safeTxProposed (safeTx: SafeServiceTypes.ProposeTransactionProps)
 }
+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
@@ -80,7 +101,7 @@ export interface ITxWriterOptions {
 
 const DEFAULTS: ITxWriterOptions = {};
 
-export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
+export class TxWriter extends class_EventEmitter<ITxWriterEvents> implements ITxWriterEmitter {
 
     onSent = new class_Dfr<string | TEth.Hex>();
     onCompleted = new class_Dfr<TEth.TxReceipt>();
@@ -108,17 +129,9 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
     }
 
     id = Math.round(Math.random() * 10**10) + '';
-    tx: {
-        timestamp: number
-        confirmations: number,
-        hash?: TEth.Hex
-        timeout?: NodeJS.Timer
-        receipt?: TEth.TxReceipt
-        error?: Error
-        knownLogs?: ITxLogItem[]
-    } = null
-
-    txs: TxWriter['tx'][] = []
+    tx: ITxWriterTransaction = null
+
+    txs: ITxWriterTransaction[] = []
     options: ITxWriterOptions;
 
 
@@ -173,9 +186,8 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
 
         let agent = TxWriterAccountAgents.get(this.account);
         if (agent != null) {
-
             let sender = await this.getSender();
-            let innerWriter: TxWriter;
+            let innerWriter: ITxWriterEmitter;
             try {
                 innerWriter = await agent.process(sender, this.account, this);
             } catch (error) {
@@ -479,7 +491,7 @@ export class TxWriter extends class_EventEmitter<ITxWriterEvents> {
         }
         this.sendTxInner();
     }
-    private pipeInnerWriter (innerWriter: TxWriter) {
+    private pipeInnerWriter (innerWriter: ITxWriterEmitter) {
         innerWriter.onCompleted.then(
             (receipt) => {
                 this.tx = innerWriter.tx;

package/src/txs/agents/TimelockAgent.ts

@@ -0,0 +1,116 @@
+import { EoAccount, TAccount, TimelockAccount } from '@dequanto/models/TAccount';
+import { ITxWriterAccountAgent } from './TxWriterAccountAgents';
+import { $account } from '@dequanto/utils/$account';
+import { ITxWriterEmitter, ITxWriterEvents, ITxWriterTransaction, TxWriter } from '../TxWriter';
+
+import { ChainAccountService } from '@dequanto/ChainAccountService';
+import { $promise } from '@dequanto/utils/$promise';
+import { class_Dfr, class_EventEmitter } from 'atma-utils';
+import { TEth } from '@dequanto/models/TEth';
+import { $require } from '@dequanto/utils/$require';
+import { $date } from '@dequanto/utils/$date';
+import { ITimelockTx } from '@dequanto/services/TimelockService/ITimelockService';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+
+import { TimelockService } from '@dequanto/services/TimelockService/TimelockService';
+import { TimelockControllerFactory } from '@dequanto/prebuilt-factories/TimelockControllerFactory';
+
+
+export class TimelockAgent implements ITxWriterAccountAgent {
+    supports (account: TAccount) {
+        return $account.isTimelock(account);
+    }
+    async process (senderMix: string | EoAccount, timelockAccount: TimelockAccount, outerWriter: TxWriter) {
+
+        let { client, options } = outerWriter;
+        let TimelockController = TimelockControllerFactory();
+        let timelock = new TimelockController(timelockAccount.address, client);
+        let service = new TimelockService(timelock, {
+            simulate: false,
+        });
+        let sender = typeof senderMix === 'string'
+            ? await ChainAccountService.get(senderMix) as EoAccount
+            : senderMix;
+
+        let inner = new TimelockTxWriter(
+            client,
+            sender,
+            service,
+            outerWriter,
+        );
+
+        await inner.process();
+        return inner;
+    }
+}
+
+export class TimelockTxWriter extends class_EventEmitter<ITxWriterEvents> implements ITxWriterEmitter {
+
+    onSent = new class_Dfr<string | TEth.Hex>()
+    onCompleted = new class_Dfr<TEth.TxReceipt>()
+    receipt: TEth.TxReceipt
+    tx: ITxWriterTransaction
+
+    schedule: ITimelockTx
+    delayTimer: any
+
+    constructor (
+        private client: Web3Client,
+        private sender: TEth.IAccount,
+        private service: TimelockService,
+        private outerWriter: TxWriter,
+    ) {
+        super();
+    }
+
+    async process () {
+        let { sender, service, client, outerWriter } = this;
+
+        let { error, result } = await $promise.caught(service.processData(sender, outerWriter.builder));
+        if (error) {
+            this.onCompleted.reject(error);
+            this.emit('error', error);
+            return this;
+        }
+        if (result.status === 'completed') {
+            $require.Hex(result.tx, 'Timelock transaction hash expected');
+            let receipt = await client.getTransactionReceipt(result.tx);
+            let block = await client.getBlock(receipt.blockNumber);
+            let latestBlock = await client.getBlockNumber();
+            $require.notNull(receipt, `Receipt for ${result.tx} not found`);
+
+            let tx = {
+                timestamp: block.timestamp,
+                confirmations: latestBlock - block.number,
+                hash: receipt.transactionHash,
+                receipt: receipt,
+                error: null,
+                knownLogs: null,
+            } as ITxWriterTransaction;
+
+            this.tx = tx;
+            this.emit('transactionHash', receipt.transactionHash);
+            this.emit('receipt', receipt);
+            this.onCompleted.resolve(receipt);
+            return this;
+        }
+        if (result.status === 'pending') {
+            let readyAt = $date.fromUnixTimestamp(result.schedule.validAt);
+            let readyAtF = $date.format(readyAt, 'yyyy-MM-DD HH:mm:ss');
+            this.emit('log', `Timelock transaction pending: ${result.schedule.id}, ready at: ${readyAtF}`);
+            this.onSent.resolve(result.schedule.id);
+
+            let ms = readyAt.valueOf() - Date.now();
+            $require.gt(ms, 0, `The transaction must be in 'ready' state`);
+            this.delayTimer = setTimeout(() => {
+                this.process();
+            }, ms);
+            return this;
+        }
+        if (result.status === 'ready') {
+            throw new Error(`[TimelockAgent] Service emits 'ready' status, however it should execute the transaction directly`);
+        }
+
+        throw new Error(`[TimelockAgent] Unsupported status: ${result.status}`);
+    }
+}

package/src/txs/agents/TxWriterAccountAgents.ts

@@ -1,13 +1,14 @@
 import type { EoAccount, TAccount } from '@dequanto/models/TAccount';
-import type { TxWriter } from '../TxWriter';
+import type { ITxWriterEmitter, TxWriter } from '../TxWriter';
 import { SafeAgent } from './SafeAgent';
 import { Erc4337Agent } from './Erc4337Agent';
+import { TimelockAgent } from './TimelockAgent';
 
 
 
 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 namespace TxWriterAccountAgents {
@@ -15,6 +16,7 @@ export namespace TxWriterAccountAgents {
     const agents: ITxWriterAccountAgent[] = [
         new SafeAgent(),
         new Erc4337Agent(),
+        new TimelockAgent(),
     ];
 
     export function register (agent: ITxWriterAccountAgent) {

package/src/utils/$account.ts

@@ -1,5 +1,6 @@
-import { EoAccount, Erc4337Account, SafeAccount, TAccount } from "@dequanto/models/TAccount";
+import { EoAccount, Erc4337Account, SafeAccount, TAccount, TimelockAccount } from "@dequanto/models/TAccount";
 import { $address } from './$address';
+import { $require } from './$require';
 
 export namespace $account {
 
@@ -11,10 +12,11 @@ export namespace $account {
             return { name: account };
         }
 
-        let acc = isSafe(account) || isErc4337 (account)
+        let acc = isSafe(account) || isErc4337 (account) || isTimelock(account)
             ? account.operator
             : account;
 
+        $require.notNull(acc, `Sender not resolved for ${ account?.address ?? account }`);
         return acc as EoAccount;
     }
 
@@ -45,4 +47,18 @@ export namespace $account {
         }
         return false;
     }
+
+    export function isTimelock (account:TAccount): account is TimelockAccount {
+        if (account == null) {
+            return false;
+        }
+        let rgx = /^timelock\//;
+        if (typeof account === 'string') {
+            return rgx.test(account);
+        }
+        if (account.type === 'timelock' || rgx.test(account.name)) {
+            return true;
+        }
+        return false;
+    }
 }

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);

package/src/utils/$date.ts

@@ -250,6 +250,17 @@ export namespace $date {
         result.setHours(23, 59, 59, 999);
         return result;
     }
+    export function weekNumber(date = new Date()) {
+        date = new Date(date);
+        date.setHours(0, 0, 0, 0);
+
+        // Set to nearest Thursday: current date + 4 - current day number
+        const dayNum = date.getDay() || 7;
+        date.setDate(date.getDate() + 4 - dayNum);
+        // Calculate week number
+        const yearStart = new Date(Date.UTC(date.getFullYear(), 0, 1));
+        return Math.ceil((((date.getTime() - yearStart.getTime()) / 86400000) + 1) / 7);
+    }
     export function monthStart(date = new Date()) {
         let result = new Date(date);
         result.setDate(1);
@@ -264,7 +275,6 @@ export namespace $date {
         return result;
     }
 
-
     /** date1 + X === date2 */
     export function daysBetween(a: Date, b: Date, abs: boolean = true) {
         let aStart = dayStart(a);