dequanto 0.1.4 → 0.1.7

package/package.json

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

package/readme.md

@@ -3,92 +3,85 @@
 [![Documentation Link](https://img.shields.io/badge/%E2%9D%93-documentation-green.svg)](https://docs.0xweb.org/dequanto)
 [![CircleCI](https://circleci.com/gh/0xweb-org/dequanto.svg?style=svg)](https://circleci.com/gh/0xweb-org/dequanto)
 
-![dequanto](https://github.com/0xweb-org/dequanto/assets/550353/d7542ede-8392-44ea-b552-7c3e960ac8fb)
-
-Here we share our library to work with Ethereum Virtual Machine RPC Nodes: Ethereum, Polygon, BSC, Arbitrum, etc. We use web3 and ethers to provide new Features and to simplify the API.
-
-1. RPC Client Pool
-2. Transaction Builder
-3. Generated TypeScript classes for contracts
-4. Etherscan & Co clients
-5. Tokens provider - get token data by symbol, address, platform.
-6. Tokens service - transfer and swap
-7. Transaction **Indexers** - listens to blocks and parse new transactions to simplify further processing
-8. Native **`BigInt`** types and various utility methods
-9. OpenZeppelin contracts
-
-
-###  **`Source-Code`** Distribution
-
-Not as a library, but as the source code. Clone or fork it and use it as a **submodule**. Means:
-a) you can `import` any `class`, `namespace` and `utility` method.
-b) you can easily extend and modify any `class`, `namespace` and `utility` method.
-c) you get the documentation direct from the code. _We don't have much time yet to document all the parts_
-
-And path prefix (alias) to your `tsconfig.json`
-```json
-{
-    "compilerOptions": {
-        "paths": {
-            "@dequanto/*": [ "your-sub-module-folder/src/*" ],
-            "@dequanto-contract/*": [ "your-sub-module-folder/contract/*" ]
-        }
-    }
-}
-```
+<p align='center'>
+    <img src='assets/background.jpg'/>
+</p>
 
-### Configuration
 
-Before you use the code, you should prepare the configuration for it: Node RPC URLs, Accounts, Blockchain Explorer API Keys, etc.
+A versatile library for EVM Blockchain Developers and Consumers. Based on your requirements and expertise, this library can either fully abstract the Blockchain Layer with autogenerated classes for contract communication or give you direct access to low-level methods.
 
-## 1. RPC Client Pool
+This library includes numerous classes to cover all facets of blockchain development. Here’s a summary of some key features:
 
-Provide multiple RPC Node URLs, this will make your application much more reliable. Even if one of the Nodes goes down or for some reason is not in-sync, all your RPC calls will still work.
+### TypeScript and ES6 Class Generation
 
-[Web3Client](src/clients/Web3Client.ts) is the base class for all the EVM Platforms. This wraps web3 to provide pool-based communication with nodes. It handles also Gas and Nonce Values.
+Generate contract clients based on ABI or source code, which can be automatically retrieved from blockchain explorers by address.
 
+> This can serve as an all-in-one tool for submitting transactions, querying contracts, or fetching events, as the contract clients handle the underlying steps.
 
-## 2. Transaction Builder
+---
 
-[TxDataBuilder](src/txs/TxDataBuilder.ts) and [TxWriter](src/txs/TxWriter.ts) to create and submit transaction.
+### RPC Clients
 
+A robust communication layer to connect to blockchain nodes. You can add multiple nodes (private or public) to the pool to manage **request balancing**, **throttling**, **rate limits**, and **automatic retries**.
 
-## 3. Generated TypeScript classes for contracts
+### Transaction Builder
 
-With auto-generated classes you can
+Provides fine-tuning for transaction submission. Supports Gnosis {Safe} and Account Abstraction Transactions.
 
-a) type-safe method read and write(transaction) calls to blockchain
-b) parse receipts of the contract transactions
-c) easily subscribe to event streams of the contract
+### Etherscan & Co Clients
 
-## 4. Etherscan&Co clients
+An integrated API for blockchain explorers.
 
-Ready to use Etherscan&Co classes to consume their API. Just drop-in the KEYs.
+### Event Indexer
 
-## 5. Tokens provider
+An easy-to-use indexer for fetching contract events.
 
-Get Tokens Data (`address`, `decimals`, etc) by `symbol` and `platform`
+### Event and Transaction Watcher
 
-## 6. Tokens service
+Listen to events and monitor transactions in real-time.
 
-One-liners to transfer tokens from A to B, or swap the tokens using popular DEXes
+### Native **`BigInt`** Types with **`BigFloat`** Support for Mantissa Math
 
-## 7. Transaction **Indexers**
+### Pre-generated OpenZeppelin Contracts
 
-Start listening the blockchain with less code
+### Flashbots Support
 
-## 8. Utils
+## Installation
 
-Lots of Utility methods. BigInt are the first-class citizens in the code.
+### Using 0xweb CLI
 
+You can use the [0xweb](https://github.com/0xweb-org/0xweb) tool to install contracts and dependencies.
 
-### 9. OpenZeppelin contracts
+### NPM
 
-We prebuild generic OpenZeppelin contracts
+Install the library using npm:
 
 ```
-import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20
-
-let erc20 = new ERC20(`0x...`);
-let balance = await erc20.balanceOf('0x...');
+npm i dequanto
 ```
+
+The package includes three types of source files:
+
+1. **TypeScript Sources**: Configure paths in your `tsconfig.json` like so:
+
+   ```json
+   {
+       "compilerOptions": {
+           "paths": {
+               "@dequanto/*": [ "node_modules/dequanto/src/*" ],
+               "@dequanto-contract/*": [ "node_modules/dequanto/src/prebuilt/*" ]
+           }
+       }
+   }
+   ```
+
+2. **Compiled CommonJS (CJS) Files**: Located at `node_modules/dequanto/lib/cjs/*/**.js`
+3. **Compiled ESM (Modules)**: Located at `node_modules/dequanto/lib/esm/*/**.mjs`
+
+### Configuration
+
+While the library includes configurations for various blockchains and {Safe} infrastructure, you may need to set custom RPC URLs, Blockchain Explorer API Keys, and other settings. This can be done in a **YAML** configuration file that loads when the application starts.
+
+----
+
+(c) 2024 0xweb.org

package/src/gen/Generator.ts

@@ -335,7 +335,12 @@ export class Generator {
 
         if (typeof path === 'string' && path.endsWith('.json')) {
             let json = await this.readFile(path);
+            if (Array.isArray(json)) {
+                return { abi: json, bytecode: null, artifact: null, source: null }
+            }
             let { abi, bytecode, sourceName, contractName } = json
+            $require.True(Array.isArray(abi), `Invalid abi json: ${path}. Expected the "abi" property to be the array.`);
+
             let source = await this.getSources(contractName, {
                 sourcePath: sourceName,
                 contractName,

package/src/gen/GeneratorFromAbi.ts

@@ -1,7 +1,7 @@
 import alot from 'alot';
 import { type TAbiItem } from '@dequanto/types/TAbi';
 import { TAddress } from '@dequanto/models/TAddress';
-import { File } from 'atma-io';
+import { env, File } from 'atma-io';
 import { class_Uri } from 'atma-utils';
 import { $abiType } from '@dequanto/utils/$abiType';
 import { $date } from '@dequanto/utils/$date';
@@ -19,11 +19,11 @@ import { $str } from '@dequanto/solidity/utils/$str';
 
 export class GeneratorFromAbi {
 
-    static get Gen () {
+    static get Gen() {
         return Gen;
     }
 
-    async generate (abiJson: TAbiItem[], opts: {
+    async generate(abiJson: TAbiItem[], opts: {
         network: TPlatform
         name: string
         contractName: string
@@ -88,7 +88,6 @@ export class GeneratorFromAbi {
             .map(x => Gen.serializeEvent(x))
             .filter(Boolean)
             .map(Str.formatMethod);
-            ;
 
         let eventTypes = alot(abiJson)
             .filter(x => x.type === 'event')
@@ -120,7 +119,6 @@ export class GeneratorFromAbi {
         //     .map(x => Gen.serializeEventInterface(x))
         //     .filter(Boolean)
         //     .map(Str.formatMethod);
-            ;
 
         let methods = methodsArr.join('\n\n');
         let events = eventsArr.join('\n\n');
@@ -223,7 +221,7 @@ export class GeneratorFromAbi {
                 : void 0,
             class: this.getRelativePath(outputPath)
         };
-        let metaProperty = `$meta = ${ JSON.stringify(meta, null, 4) }` ;
+        let metaProperty = `$meta = ${JSON.stringify(meta, null, 4)}`;
 
 
         let storageReaderInitializer = '';
@@ -297,7 +295,17 @@ export class GeneratorFromAbi {
         if (sources && opts.saveSources !== false) {
             sourceFiles = await alot.fromObject(sources).mapAsync(async entry => {
                 let sourceFilename = /\/?([^/]+$)/.exec(entry.key)[1];
-                let path = class_Uri.combine(opts.output, outputDirectory, outputFilename, sourceFilename);
+                let sourcePath = entry.key;
+                let cwd = env.currentDir.toString().toLowerCase();
+                if (sourcePath.toLowerCase().startsWith(cwd)) {
+                    sourcePath = sourcePath.substring(cwd.length + 1);
+                }
+                // Remove: solc should load deps also from the root directory
+                // if (sourcePath.startsWith('@')) {
+                //     // handle @openzeppelin and other npm packages
+                //     sourcePath = `node_modules/${ sourcePath }`;
+                // }
+                let path = class_Uri.combine(opts.output, outputDirectory, outputFilename, sourcePath);
                 await File.writeAsync(path, entry.value.content, { skipHooks: true });
 
                 $logger.log(`Source code saved: ${path}`);
@@ -315,7 +323,7 @@ export class GeneratorFromAbi {
     }
 
 
-    private getRelativePath (path: string) {
+    private getRelativePath(path: string) {
         if (path == null) {
             return path;
         }
@@ -330,7 +338,7 @@ export class GeneratorFromAbi {
 
 namespace Gen {
 
-    export function serializeMethodTs (abi: TAbiItem) {
+    export function serializeMethodTs(abi: TAbiItem) {
         if (abi.type === 'constructor') {
             return serializeConstructorMethodTs(abi);
         }
@@ -340,7 +348,7 @@ namespace Gen {
         }
         return serializeWriteMethodTs(abi);
     }
-    export function serializeMethodTsOverloads (abis: TAbiItem[]) {
+    export function serializeMethodTsOverloads(abis: TAbiItem[]) {
         let isRead = abis.every(abi => $abiUtils.isReadMethod(abi));
         if (isRead) {
             return serializeReadMethodTsOverloads(abis);
@@ -349,7 +357,7 @@ namespace Gen {
     }
 
     // abi.length > 1 if has method overloads
-    export function serializeMethodInterfacesTs (name: string, abis: TAbiItem[]) {
+    export function serializeMethodInterfacesTs(name: string, abis: TAbiItem[]) {
         let args = abis.map(abi => {
             let { fnInputArguments } = serializeArgumentsTs(abi);
             return `[ ${fnInputArguments} ]`;
@@ -369,7 +377,7 @@ namespace Gen {
         };
     }
 
-    export function serializeMethodTypeTs (name: string, abis: TAbiItem[]) {
+    export function serializeMethodTypeTs(name: string, abis: TAbiItem[]) {
         let args = abis.map(abi => {
             let { fnInputArguments } = serializeArgumentsTs(abi);
             return `[ ${fnInputArguments} ]`;
@@ -389,7 +397,7 @@ namespace Gen {
         };
     }
 
-    export function serializeMethodInterfacesAllTs (methods: { method: string, interface: string }[] ) {
+    export function serializeMethodInterfacesAllTs(methods: { method: string, interface: string }[]) {
         let fields = methods.map(method => {
             return `  ${method.method}: ${method.interface}`;
         });
@@ -403,7 +411,7 @@ namespace Gen {
             code: code.join('\n')
         };
     }
-    export function serializeEventsInterfacesAllTs (events: TAbiItem[] ) {
+    export function serializeEventsInterfacesAllTs(events: TAbiItem[]) {
         let fields = events.map(item => {
             return `  ${item.name}: TLog${item.name}Parameters`;
         });
@@ -417,14 +425,14 @@ namespace Gen {
             code: code.join('\n')
         };
     }
-    export function serializeEventType (event: TAbiItem ) {
+    export function serializeEventType(event: TAbiItem) {
         let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(event);
         let outputParams = `{ ${fnInputArguments} }`;
         let outputArgs = `[ ${fnInputArguments.replace('\n', '')} ]`;
         let code = [
             `${event.name}: {`,
-            `    outputParams: ${ outputParams },`,
-            `    outputArgs:   ${ outputArgs },`,
+            `    outputParams: ${outputParams},`,
+            `    outputArgs:   ${outputArgs},`,
             `}`
         ];
         return {
@@ -432,7 +440,7 @@ namespace Gen {
         };
     }
 
-    export function serializeEvent (abi: TAbiItem) {
+    export function serializeEvent(abi: TAbiItem) {
         let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
         return `
             on${abi.name} (fn?: (event: TClientEventsStreamData<TEventArguments<'${abi.name}'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'${abi.name}'>>> {
@@ -440,7 +448,7 @@ namespace Gen {
             }
         `;
     }
-    export function serializeEventExtractor (abi: TAbiItem) {
+    export function serializeEventExtractor(abi: TAbiItem) {
         return `
             extractLogs${abi.name} (tx: TEth.TxReceipt): ITxLogItem<TEventParams<'${abi.name}'>>[] {
                 let abi = this.$getAbiItem('event', '${abi.name}');
@@ -448,10 +456,10 @@ namespace Gen {
             }
         `;
     }
-    export function serializeEventFetcher (abi: TAbiItem) {
+    export function serializeEventFetcher(abi: TAbiItem) {
         let inputs = abi.inputs;
         let indexed = alot(inputs).takeWhile(x => x.indexed).toArray();
-        let indexedParams = indexed.map(param => `${param.name}?: ${ $abiType.getTsType(param.type, param) }`)
+        let indexedParams = indexed.map(param => `${param.name}?: ${$abiType.getTsType(param.type, param)}`)
         return `
             async getPastLogs${abi.name} (options?: {
                 fromBlock?: number | Date
@@ -488,7 +496,7 @@ namespace Gen {
         return `function ${abi.name}(${params}) ${returnsStr}`.trim();
     }
 
-    function serializeReadMethodTs (abi: TAbiItem) {
+    function serializeReadMethodTs(abi: TAbiItem) {
         let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
         if (callInputArguments) {
             callInputArguments = `, ${callInputArguments}`;
@@ -500,7 +508,7 @@ namespace Gen {
             }
         `;
     }
-    function serializeReadMethodTsOverloads (abis: TAbiItem[]) {
+    function serializeReadMethodTsOverloads(abis: TAbiItem[]) {
         let overrides = abis.map(abi => {
             let { fnInputArguments, fnResult } = serializeArgumentsTs(abi);
             return `
@@ -513,7 +521,7 @@ namespace Gen {
         let { fnResult } = serializeArgumentsTs(abi);
         let sigs = abis.map(abi => serializeMethodAbi(abi)).map(x => `'${x}'`).join(', ');
         return `
-            ${ overrides }
+            ${overrides}
             async ${abi.name} (...args): ${fnResult} {
                 let abi = this.$getAbiItemOverload([ ${sigs} ], args);
                 return this.$read(abi, ...args);
@@ -521,7 +529,7 @@ namespace Gen {
         `;
     }
 
-    function serializeWriteMethodTs (abi: TAbiItem) {
+    function serializeWriteMethodTs(abi: TAbiItem) {
         let { fnInputArguments, callInputArguments } = serializeArgumentsTs(abi);
         if (callInputArguments) {
             callInputArguments = `, ${callInputArguments}`;
@@ -534,7 +542,7 @@ namespace Gen {
             }
         `;
     }
-    function serializeConstructorMethodTs (abi: TAbiItem) {
+    function serializeConstructorMethodTs(abi: TAbiItem) {
         let { fnInputArguments, callInputArguments } = serializeArgumentsTs(abi);
         if (callInputArguments) {
             callInputArguments = `, ${callInputArguments}`;
@@ -545,7 +553,7 @@ namespace Gen {
             }
         `;
     }
-    function serializeWriteMethodTsOverloads (abis: TAbiItem[]) {
+    function serializeWriteMethodTsOverloads(abis: TAbiItem[]) {
         let overrides = abis.map(abi => {
             let { fnInputArguments, fnResult } = serializeArgumentsTs(abi);
             return `
@@ -557,7 +565,7 @@ namespace Gen {
         let abi = abis[0];
         let sigs = abis.map(abi => serializeMethodAbi(abi)).map(x => `'${x}'`).join(', ');
         return `
-            ${ overrides }
+            ${overrides}
             async ${abi.name} (sender: TSender, ...args): Promise<TxWriter> {
                 let abi = this.$getAbiItemOverload([ ${sigs} ], args);
                 return this.$write(abi, sender, ...args);
@@ -565,7 +573,7 @@ namespace Gen {
         `;
     }
 
-    function serializeArgumentsTs (abi: TAbiItem) {
+    function serializeArgumentsTs(abi: TAbiItem) {
         let inputs = abi.inputs.map((input, i) => {
             let result = { ...input };
             if (result.name == null || result.name === '') {
@@ -599,10 +607,10 @@ namespace Gen {
         return { fnInputArguments, callInputArguments, fnResult };
     }
 
-    function isObjectParams (params: { name?, type }[]) {
+    function isObjectParams(params: { name?, type }[]) {
         return params?.every(x => Boolean(x.name));
     }
-    function serializeMethodAbiReturns (params: { name?, type, components? }[]) {
+    function serializeMethodAbiReturns(params: { name?, type, components?}[]) {
         if (params == null) {
             return '';
         }
@@ -611,23 +619,23 @@ namespace Gen {
         // }
         return params?.map(x => serializeMethodAbiReturnsSingle(x)).join(',');
     }
-    function serializeMethodAbiReturnsSingle (param: { name?, type, components? }) {
+    function serializeMethodAbiReturnsSingle(param: { name?, type, components?}) {
         if (param == null) {
             return null;
         }
         if (param.components) {
             // tuple, tuple[]
             let fields = serializeMethodAbiReturns(param.components);
-            return `[${fields}]${ param.type === 'tuple[]' ? '[]' : '' }`;
+            return `[${fields}]${param.type === 'tuple[]' ? '[]' : ''}`;
         }
         // if (param.name && param.type) {
         //     return `${param.type} ${param.name}`;
         // }
         return param.type;
     }
-    function serializeMethodTsReturns (params: { name?, type }[]) {
+    function serializeMethodTsReturns(params: { name?, type }[]) {
         if (params == null || params.length === 0) {
-            params = [ { name: '', type: 'uint256' } ];
+            params = [{ name: '', type: 'uint256' }];
         }
 
         let tsTypes = params.map(param => {
@@ -668,19 +676,19 @@ namespace Gen {
             lines.push(`        type: '${error.name}'`);
             lines.push(`        params: {`);
             error.inputs.forEach(input => {
-                lines.push(`            ${input.name}: ${ $abiType.getTsType( input.type, input ) }`);
+                lines.push(`            ${input.name}: ${$abiType.getTsType(input.type, input)}`);
             });
             lines.push(`        }`);
             lines.push(`    }`);
         });
 
-        lines.push(`    export type Error = ${ errors.map(x => x.name).join(' | ') }`);
+        lines.push(`    export type Error = ${errors.map(x => x.name).join(' | ')}`);
         lines.push(`}`);
 
         return lines.join('\n');
     }
 
-    export function serializeTxCallerMethods (className: string, abiJson: TAbiItem[]): string {
+    export function serializeTxCallerMethods(className: string, abiJson: TAbiItem[]): string {
         let methods = abiJson.filter(x => x.type === 'function');
         let writeMethods = methods.filter(abi => $abiUtils.isReadMethod(abi) === false);
         let lines = [];
@@ -691,16 +699,16 @@ namespace Gen {
         return lines.join('\n');
 
 
-        function serializeMethodTs (abi: TAbiItem) {
+        function serializeMethodTs(abi: TAbiItem) {
             let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
             if (callInputArguments) {
                 callInputArguments = `, ${callInputArguments}`;
             }
-            return  `    ${abi.name} (sender: TSender, ${fnInputArguments}): Promise<{ error?: Error & { data?: { type: string, params } }, result? }>`;
+            return `    ${abi.name} (sender: TSender, ${fnInputArguments}): Promise<{ error?: Error & { data?: { type: string, params } }, result? }>`;
         }
     }
 
-    export function serializeTxDataMethods (className: string, abiJson: TAbiItem[]): string {
+    export function serializeTxDataMethods(className: string, abiJson: TAbiItem[]): string {
         let methods = abiJson.filter(x => x.type === 'function');
         let writeMethods = methods.filter(abi => $abiUtils.isReadMethod(abi) === false);
         let lines = [];
@@ -711,7 +719,7 @@ namespace Gen {
         return lines.join('\n');
 
 
-        function serializeInterfaceMethodTs (abi: TAbiItem) {
+        function serializeInterfaceMethodTs(abi: TAbiItem) {
             let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
             if (callInputArguments) {
                 callInputArguments = `, ${callInputArguments}`;

package/src/hardhat/HardhatProvider.ts

@@ -30,6 +30,8 @@ import { $address } from '@dequanto/utils/$address';
 import { $promise } from '@dequanto/utils/$promise';
 import { $date } from '@dequanto/utils/$date';
 import { $hex } from '@dequanto/utils/$hex';
+import { TAddress } from '@dequanto/models/TAddress';
+import { $contract } from '@dequanto/utils/$contract';
 
 export class HardhatProvider {
 
@@ -272,6 +274,7 @@ export class HardhatProvider {
         artifact: string
         source: IGeneratorSources
         ContractCtor: Constructor<T>
+        linkReferences?: Record<string /* path */, Record<string /* name */, any>>
     }> {
 
         solContractPath = $path.normalize(solContractPath);
@@ -353,7 +356,12 @@ export class HardhatProvider {
             });
         }
 
-        let { abi, bytecode, contractName } = await File.readAsync<{ abi, bytecode, contractName }> (output);
+        let { abi, bytecode, contractName, linkReferences } = await File.readAsync<{
+            abi,
+            bytecode,
+            contractName,
+            linkReferences: Record<string /* path */, Record<string /* name */, any>>
+        }> (output);
         let files = await Directory.readFilesAsync(dir, '*.sol');
         let { contract, ContractCtor } = ContractClassFactory.fromAbi<T>(null, abi, null, null, {
             $meta: {
@@ -379,6 +387,7 @@ export class HardhatProvider {
                 contractName: contractName ?? options?.contractName,
                 files: fileMap
             },
+            linkReferences,
             ContractCtor
         };
     }
@@ -399,6 +408,25 @@ export class HardhatProvider {
         }
     }
 
+    async linkReferences (
+        bytecode: TEth.Hex,
+        linkReferences: Record<string /* path */, Record<string /* name */, any>>,
+        addresses: Record<string /* name */, TAddress>
+    ): Promise<TEth.Hex> {
+        for (let path in linkReferences) {
+            for (let name in linkReferences[path]) {
+                let address = addresses[name];
+                $require.AddressNotEmpty(address, `Address for "${path}:${name}" not found`);
+
+                let str = `${path}:${name}`;
+                let hash = $contract.keccak256(str, 'hex').substring(2, 34 + 2);
+                let placeholder = `__$${hash}$__`;
+                bytecode = bytecode.replaceAll(placeholder, address.substring(2)) as TEth.Hex;
+            }
+        }
+        return bytecode;
+    }
+
     async compileCode (solidityCode: string, options: Parameters<HardhatProvider['deploySol']>[1] = {}) {
         let { tmpFile,  tmpDir, options: optionsNormalized } = await this.createTmpFile(solidityCode, options);
 

package/src/json/JsonObjectStore.ts

@@ -1,4 +1,4 @@
-import { Constructor } from 'atma-utils'
+import type { Constructor } from 'atma-utils'
 import { JsonConvert } from 'class-json'
 import { JsonStoreFs } from './JsonStoreFs';
 

package/src/safe/SafeTx.ts

@@ -48,7 +48,7 @@ export class SafeTx {
                 [`uint8`, tx.operation ],
                 [`address`, tx.to],
                 [`uint256`, tx.value],
-                [`uint256`, $hex.getBytesLength(tx.data)],
+                [`uint256`, $hex.getBytesLength(tx.data ?? '0x')],
                 [`bytes`, tx.data]
             );
         });

package/src/services/TimelockService/ITimelockService.ts

@@ -0,0 +1,123 @@
+import { ContractBase } from '@dequanto/contracts/ContractBase';
+import { IAccount } from '@dequanto/models/TAccount'
+import { TAddress } from '@dequanto/models/TAddress'
+import { TEth } from '@dequanto/models/TEth'
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { TTxWriteMethodKeys } from '@dequanto/utils/types';
+
+export interface ITimelockService {
+
+    getPendingByTitle (title: string): Promise<{
+        status: ETimelockTxStatus;
+        schedule: ITimelockTx;
+    }>
+
+    executePendingByTitle (sender: IAccount, title: string): Promise<{
+        tx: TxWriter;
+        schedule: ITimelockTx;
+    }>
+
+    executePending (sender: IAccount, txParams: ITimelockTx): Promise<{
+        tx: TxWriter;
+        schedule: ITimelockTx;
+    }>
+    /** Schedules-Wait-Execute a task distinguished by the unique task name
+     *
+     * 1. if schedule doesn't exist, create it
+     * 2. if schedule date NOT yet ready, exit
+     * 3. if schedule date IS ready, execute it
+     * 4. if executed, exit
+    */
+    process <
+        T extends ContractBase,
+        TMethodName extends TTxWriteMethodKeys<T>,
+    > (
+        uniqueTaskName: string,
+        sender: IAccount,
+        contract: T,
+        method: TMethodName,
+        ...params: T[TMethodName] extends (sender: IAccount, ...args: infer A) => any ? A : never
+    ): 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
+     * 2. if schedule date NOT yet ready, exit
+     * 3. if schedule date IS ready, execute it
+     * 4. if executed, exit
+    */
+    processBatch <
+        T extends ContractBase,
+        TMethodName extends TTxWriteMethodKeys<T>,
+    > (
+        uniqueTaskName: string,
+        sender: IAccount,
+        batch: Pick<TEth.TxLike, 'to' | 'data' | 'value'>[],
+    ): Promise<{
+        prevStatus: ETimelockTxStatus
+        status: ETimelockTxStatus
+        schedule: ITimelockTx
+        tx?: TEth.Hex
+    }>
+}
+
+export interface ITimelockTx {
+    // operation hash, unique as includes random salt
+    id: TEth.Hex
+    // operation key, should be unique only within pending operations
+    key: TEth.Hex
+
+    salt: TEth.Hex
+
+    title?: string
+    sender: string | TAddress
+
+    to: TAddress | TAddress[]
+    data: TEth.Hex | TEth.Hex[]
+    value?: TEth.Hex | TEth.Hex[]
+    predecessor?: TEth.Hex
+
+    createdAt: number
+    validAt: number
+
+    status: 'pending' | 'completed' | 'canceled'
+    txSchedule: TEth.Hex
+    txExecute?: TEth.Hex
+    txCancel?: TEth.Hex
+}
+
+export interface ITimelockTxParams {
+    title?: string
+
+    sender: IAccount
+    to: TAddress | TAddress[]
+    data: TEth.Hex | TEth.Hex[]
+
+    value?: bigint | bigint[]
+    predecessor?: TEth.Hex
+    delay?: bigint
+}
+
+export interface ITimelockTxParamsNormalized {
+    sender: IAccount
+    to: TAddress | TAddress[]
+    data: TEth.Hex | TEth.Hex[]
+
+    title: string
+    value: bigint | bigint[]
+    predecessor: TEth.Hex
+    delay: bigint
+}
+
+
+export enum ETimelockTxStatus {
+    None = 'none',
+    Pending = 'pending',
+    Ready = 'ready',
+    Executed = 'completed',
+}

package/src/services/{TimelockService.ts → TimelockService/TimelockService.ts}

@@ -1,5 +1,5 @@
+import memd from 'memd';
 import { TimelockController } from '@dequanto-contracts/openzeppelin/TimelockController';
-import { Web3Client } from '@dequanto/clients/Web3Client';
 import { ContractBase } from '@dequanto/contracts/ContractBase';
 import { JsonArrayStore } from '@dequanto/json/JsonArrayStore';
 import { IAccount } from '@dequanto/models/TAccount';
@@ -16,69 +16,16 @@ import { $number } from '@dequanto/utils/$number';
 import { $platform } from '@dequanto/utils/$platform';
 import { $require } from '@dequanto/utils/$require';
 import { File } from 'atma-io';
-import memd from 'memd';
-
-
-interface ITimelockTx {
-    // operation hash, unique as includes random salt
-    id: TEth.Hex
-    // operation key, should be unique only within pending operations
-    key: TEth.Hex
-
-    salt: TEth.Hex
-
-    title?: string
-    sender: string | TAddress
-
-    to: TAddress | TAddress[]
-    data: TEth.Hex | TEth.Hex[]
-    value?: TEth.Hex | TEth.Hex[]
-    predecessor?: TEth.Hex
-
-    createdAt: number
-    validAt: number
-
-    status: 'pending' | 'completed' | 'canceled'
-    txSchedule: TEth.Hex
-    txExecute?: TEth.Hex
-    txCancel?: TEth.Hex
-}
+import { ITimelockTx, ITimelockTxParamsNormalized, ITimelockTxParams, ITimelockService, ETimelockTxStatus } from './ITimelockService';
+import { TTxWriteMethodKeys } from '@dequanto/utils/types';
 
-interface ITimelockTxParams {
-    title?: string
 
-    sender: IAccount
-    to: TAddress | TAddress[]
-    data: TEth.Hex | TEth.Hex[]
-
-    value?: bigint | bigint[]
-    predecessor?: TEth.Hex
-    delay?: bigint
-}
-
-interface ITimelockTxParamsNormalized {
-    sender: IAccount
-    to: TAddress | TAddress[]
-    data: TEth.Hex | TEth.Hex[]
-
-    title: string
-    value: bigint | bigint[]
-    predecessor: TEth.Hex
-    delay: bigint
-}
-
-export enum ETimelockTxStatus {
-    None = 'none',
-    Pending = 'pending',
-    Ready = 'ready',
-    Executed = 'completed',
-}
 
 type TTimelockController = ContractBase & Pick<TimelockController,
     'schedule' | 'scheduleBatch' | 'execute' | 'executeBatch' | 'getMinDelay' | 'cancel'
 >;
 
-export class TimelockService {
+export class TimelockService implements ITimelockService {
 
 
     constructor(
@@ -90,7 +37,7 @@ export class TimelockService {
             // Only for hardhat client. Default: false
             execute?: boolean
 
-            // Directory to store the submitted schedules, default: `./data/0x/`
+            // Directory to store the submitted schedules, default: `./0x/data/`
             dir?: string
         }
     ) {
@@ -143,7 +90,7 @@ export class TimelockService {
     */
     async process <
         T extends ContractBase,
-        TMethodName extends WriteMethodKeys<T>,
+        TMethodName extends TTxWriteMethodKeys<T>,
     > (
         uniqueTaskName: string,
         sender: IAccount,
@@ -170,7 +117,7 @@ export class TimelockService {
     */
     async processBatch <
         T extends ContractBase,
-        TMethodName extends WriteMethodKeys<T>,
+        TMethodName extends TTxWriteMethodKeys<T>,
     > (
         uniqueTaskName: string,
         sender: IAccount,
@@ -225,7 +172,7 @@ export class TimelockService {
 
     async scheduleCall <
         T extends ContractBase,
-        TMethodName extends WriteMethodKeys<T>,
+        TMethodName extends TTxWriteMethodKeys<T>,
     > (
         sender: IAccount,
         contract: T,
@@ -253,7 +200,7 @@ export class TimelockService {
 
     async executeCall <
         T extends ContractBase,
-        TMethodName extends WriteMethodKeys<T>,
+        TMethodName extends TTxWriteMethodKeys<T>,
     > (
         sender: IAccount,
         contract: T,
@@ -587,7 +534,7 @@ export class TimelockService {
     }
     private async getTxParamsNormalizedFromContract <
         T extends ContractBase,
-        TMethodName extends WriteMethodKeys<T>,
+        TMethodName extends TTxWriteMethodKeys<T>,
     > (
         title: string | '' | null,
         sender: IAccount,
@@ -630,7 +577,7 @@ export class TimelockService {
     @memd.deco.memoize({ perInstance: true })
     private async getStore () {
         let { platform, network } = this.timelock.client;
-        let dir = this.options?.dir ?? `data/0x`;
+        let dir = this.options?.dir ?? `0x/data`;
 
         let path = getPath(platform, dir);
         if (platform === 'hardhat' && network !== platform) {
@@ -641,7 +588,7 @@ export class TimelockService {
             }
         }
         function getPath (p: TPlatform, directory: string) {
-            return `/${directory}/timelocks-${ $platform.toPath(p) }.json`
+            return `/${directory}/timelocks/${ $platform.toPath(p) }.json`
         }
         return new JsonArrayStore<ITimelockTx>({
             path,
@@ -650,12 +597,6 @@ export class TimelockService {
     }
 }
 
-type WriteMethodKeys<T> = {
-    [P in keyof T]: T[P] extends ((sender: IAccount, ...args) => (Promise<TxWriter>)) ? P : never;
-}[keyof T];
-
-
-
 namespace util {
     export function toBigInt (mix: string | string[]) {
         if (typeof mix === 'string') {

package/src/services/TimelockService/TimelockServiceFallbackSafe.ts

@@ -0,0 +1,310 @@
+import { TimelockController } from '@dequanto-contracts/openzeppelin/TimelockController';
+import { ContractBase } from '@dequanto/contracts/ContractBase';
+import { IAccount } from '@dequanto/models/TAccount';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TEth } from '@dequanto/models/TEth';
+import { SafeTx } from '@dequanto/safe/SafeTx';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { $contract } from '@dequanto/utils/$contract';
+import { $hex } from '@dequanto/utils/$hex';
+import memd from 'memd';
+import { ETimelockTxStatus, ITimelockTx, ITimelockTxParamsNormalized, ITimelockTxParams, ITimelockService } from './ITimelockService';
+
+
+export class TimelockServiceFallbackSafe implements ITimelockService {
+
+
+    constructor(
+        private safeTx: SafeTx,
+        private options?: {
+            // Only for hardhat client. Default: true
+            simulate?: boolean
+
+            // Only for hardhat client. Default: false
+            execute?: boolean
+
+            // Directory to store the submitted schedules, default: `./0x/data/`
+            dir?: string
+        }
+    ) {
+
+    }
+
+    async getPendingByTitle(title: string): Promise<{
+        status: ETimelockTxStatus;
+        schedule: ITimelockTx;
+    }> {
+        return { status: ETimelockTxStatus.None, schedule: null };
+    }
+
+    async executePendingByTitle(sender: IAccount, title: string): Promise<{
+        tx: TxWriter;
+        schedule: ITimelockTx;
+    }> {
+        throw new Error(`No pending tx found ${title}`);
+    }
+
+    async executePending(sender: IAccount, txParams: ITimelockTx): Promise<{
+        tx: TxWriter;
+        schedule: ITimelockTx;
+    }> {
+        let result = await this.execute({
+            ...txParams,
+            value: util.toBigInt(txParams.value),
+            sender: sender,
+        });
+        return result;
+    }
+
+    /** Schedules-Wait-Execute a task distinguished by the unique task name
+     *
+     * 1. if schedule doesn't exist, create it
+     * 2. if schedule date NOT yet ready, exit
+     * 3. if schedule date IS ready, execute it
+     * 4. if executed, exit
+    */
+    async process<
+        T extends ContractBase,
+        TMethodName extends WriteMethodKeys<T>,
+    >(
+        uniqueTaskName: string,
+        sender: IAccount,
+        contract: T,
+        method: TMethodName,
+        ...params: T[TMethodName] extends (sender: IAccount, ...args: infer A) => any ? A : never
+    ): Promise<{
+        prevStatus: ETimelockTxStatus
+        status: ETimelockTxStatus
+        schedule: ITimelockTx
+        tx?: TEth.Hex
+    }> {
+
+        let txParams = await this.getTxParamsNormalizedFromContract(uniqueTaskName, sender, contract, method, ...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
+     * 2. if schedule date NOT yet ready, exit
+     * 3. if schedule date IS ready, execute it
+     * 4. if executed, exit
+    */
+    async processBatch<
+        T extends ContractBase,
+        TMethodName extends WriteMethodKeys<T>,
+    >(
+        uniqueTaskName: string,
+        sender: IAccount,
+        batch: Pick<TEth.TxLike, 'to' | 'data' | 'value'>[],
+    ): Promise<{
+        prevStatus: ETimelockTxStatus
+        status: ETimelockTxStatus
+        schedule: ITimelockTx
+        tx?: TEth.Hex
+    }> {
+
+        let txParams = await this.getTxParamsNormalizedFromContractBatch(uniqueTaskName, sender, batch);
+        return await this.processTxParams(txParams);
+    }
+
+    private async processTxParams(txParams: ITimelockTxParamsNormalized): Promise<{
+        prevStatus: ETimelockTxStatus
+        status: ETimelockTxStatus
+        schedule: ITimelockTx
+        tx?: TEth.Hex
+    }> {
+
+        let result = await this.execute(txParams);
+        return {
+            prevStatus: ETimelockTxStatus.None,
+            status: ETimelockTxStatus.Executed,
+            schedule: result.schedule,
+            tx: result.tx.tx?.hash
+        };
+    }
+
+    async scheduleCall<
+        T extends ContractBase,
+        TMethodName extends WriteMethodKeys<T>,
+    >(
+        sender: IAccount,
+        contract: T,
+        method: TMethodName,
+        ...params: T[TMethodName] extends (sender: IAccount, ...args: infer A) => any ? A : never
+    ) {
+        let txParams = await this.getTxParamsNormalizedFromContract('', sender, contract, method, ...params);
+        let tx = await this.schedule(txParams);
+        return tx;
+    }
+
+    /**
+     *  E.g. `.scheduleCallBatch(title, sender, [ c1.$data().foo(sender), c2.$data().bar(sender, param1) ])`
+     */
+    async scheduleCallBatch(
+        title: string,
+        sender: IAccount,
+        batch: Pick<TEth.TxLike, 'to' | 'data' | 'value'>[],
+    ) {
+        let txParams = await this.getTxParamsNormalizedFromContractBatch(title, sender, batch);
+        let tx = await this.schedule(txParams);
+        return tx;
+    }
+
+
+    async executeCall<
+        T extends ContractBase,
+        TMethodName extends WriteMethodKeys<T>,
+    >(
+        sender: IAccount,
+        contract: T,
+        method: TMethodName,
+        ...params: T[TMethodName] extends (sender: IAccount, ...args: infer A) => any ? A : never
+    ) {
+        let txParams = await this.getTxParamsNormalizedFromContract('', sender, contract, method, ...params);
+        let tx = await this.execute(txParams);
+        return tx;
+    }
+
+    /**
+     *  E.g. `.scheduleCallBatch(title, sender, [ c1.$data().foo(sender), c2.$data().bar(sender, param1) ])`
+     */
+    async executeCallBatch(
+        title: string,
+        sender: IAccount,
+        batch: Pick<TEth.TxLike, 'to' | 'data' | 'value'>[],
+    ) {
+        let txParams = await this.getTxParamsNormalizedFromContractBatch(title, sender, batch);
+        let tx = await this.execute(txParams);
+        return tx;
+    }
+
+    @memd.deco.queued()
+    async schedule(params: ITimelockTxParams): Promise<ITimelockTx> {
+        let executed = await this.execute(params);
+        return executed.schedule;
+    }
+
+    async execute(params: ITimelockTxParams): Promise<{
+        tx: TxWriter
+        schedule: ITimelockTx
+    }> {
+        let txParams = await this.getTxParamsNormalized(params);
+        let isBatch = Array.isArray(txParams.to);
+        let tx = isBatch
+            ? await this.safeTx.executeBatch(
+                ...(txParams.to as TAddress[]).map((to, i) => {
+                    return {
+                        to,
+                        value: (txParams.value as bigint[])[i],
+                        data: (txParams.data as TEth.Hex[])[i]
+                    }
+                }),
+            )
+            : await this.safeTx.execute(
+                {
+                    to: txParams.to as TAddress,
+                    value: txParams.value as bigint,
+                    data: txParams.data as TEth.Hex
+                }
+            );
+
+        let receipt = await tx.wait();
+        return {
+            tx: tx,
+            schedule: {
+                txExecute: receipt.transactionHash,
+                status: ETimelockTxStatus.Executed,
+            } as ITimelockTx
+        };
+    }
+
+    async cancel(sender: IAccount, id: TEth.Hex, opts?: { storage?: boolean }) {
+        throw new Error(`Not implemented for Safe Fallback`);
+    }
+
+    public async clearSchedules() {
+        // SafeFallback has no schedules
+    }
+
+    public async updateSchedule(txInfo: Partial<ITimelockTx>) {
+        // SafeFallback has no schedules
+    }
+
+    public async debugMoveToSchedule(txInfo: ITimelockTx) {
+        // SafeFallback has no schedules
+    }
+
+    private async getTxParamsNormalized(params: ITimelockTxParams): Promise<ITimelockTxParamsNormalized> {
+        let value = params.value ?? 0n;
+        let data = params.data;
+        let predecessor = params.predecessor ?? $hex.ZERO;
+        let delay = 0n;
+        return {
+            title: params.title ?? '',
+            sender: params.sender,
+            to: params.to,
+
+            value,
+            data,
+            predecessor,
+            delay
+        };
+    }
+    private async getTxParamsNormalizedFromContract<
+        T extends ContractBase,
+        TMethodName extends WriteMethodKeys<T>,
+    >(
+        title: string | '' | null,
+        sender: IAccount,
+        contract: T,
+        method: TMethodName,
+        ...params: T[TMethodName] extends (sender: IAccount, ...args: infer A) => any ? A : never
+    ): Promise<ITimelockTxParamsNormalized> {
+
+        let txData = await contract.$data()[method](sender, ...params);
+        let abi = contract.abi?.find(x => x.name === method);
+        let methodCallStr = $contract.formatCallFromAbi(abi, params);
+
+        title ??= `${contract.constructor.name}.${methodCallStr}`;
+
+        let tx = await this.getTxParamsNormalized({
+            title,
+            sender,
+            to: txData.to,
+            data: txData.data,
+        })
+        return tx;
+    }
+    private async getTxParamsNormalizedFromContractBatch(
+        title: string | '' | null,
+        sender: IAccount,
+        batch: Pick<TEth.TxLike, 'to' | 'data' | 'value'>[],
+    ): Promise<ITimelockTxParamsNormalized> {
+
+
+        let tx = await this.getTxParamsNormalized({
+            title,
+            sender,
+            to: batch.map(x => x.to),
+            data: batch.map(x => x.data),
+            value: batch.map(x => BigInt(x.value)),
+        })
+        return tx;
+    }
+}
+
+type WriteMethodKeys<T> = {
+    [P in keyof T]: T[P] extends ((sender: IAccount, ...args) => (Promise<TxWriter>)) ? P : never;
+}[keyof T];
+
+
+
+namespace util {
+    export function toBigInt(mix: string | string[]) {
+        if (typeof mix === 'string') {
+            return BigInt(mix);
+        }
+        return mix.map(BigInt);
+    }
+}

package/src/tokens/TokenTransferService.ts

@@ -83,7 +83,7 @@ export class TokenTransferService {
         token = await this.getToken(token);
         amount = this.getAmount(amount, token);
 
-        let isNative = this.tokenService.isNative(token.address);
+        let isNative = this.tokenService.isNative(token);
         if (isNative) {
             return this.transferNative(from, to, amount);
         }
@@ -98,7 +98,7 @@ export class TokenTransferService {
         return token;
     }
     isNativeToken (token: string | IToken): boolean {
-        return this.tokenService.isNative(typeof token === 'string' ? token : token.address);
+        return this.tokenService.isNative(typeof token === 'string' ? token : (token.address ?? token.symbol));
     }
 
     private async transferNativeAll (from: EoAccount, to: TAddress, opts?: { remainder: number | bigint }): Promise<TxWriter> {

package/src/utils/types.ts

@@ -1,4 +1,6 @@
+import { IAccount } from '@dequanto/models/TAccount';
 import { TEth } from '@dequanto/models/TEth';
+import { TxWriter } from '@dequanto/txs/TxWriter';
 
 type NoneMethodKeys<T> = {
     [P in keyof T]: T[P] extends ((...args) => any) ? never : P;
@@ -31,11 +33,9 @@ export type ThenArg<T> = T extends PromiseLike<infer U> ? U : T
 
 export type ParametersFromSecond<T extends (x, ...args: any) => any> = T extends (x, ...args: infer P) => any ? P : never;
 
-
 export type TCallback<TResult = any> = (error: Error, result?: TResult) => void
 export type TFnWithCallback<TArgs extends any[], TResult> = (...args: [...TArgs, TCallback<TResult>]) => void
 
-
 export type DataLike<T> = T extends bigint
     ? bigint | number | TEth.Hex
     : (T extends number
@@ -49,10 +49,12 @@ export type DataLike<T> = T extends bigint
         )
     );
 
-
-
 export type TOverrideReturns<TObject extends { }, TReturn> = {
     [P in keyof TObject]: TObject[P] extends (...args: infer TParams) => any
         ? (...args: TParams) => TReturn
         : never;
 }
+
+export type TTxWriteMethodKeys<T> = {
+    [P in keyof T]: T[P] extends ((sender: IAccount, ...args) => (Promise<TxWriter>)) ? P : never;
+}[keyof T];

package/test/ns.spec.ts

@@ -26,7 +26,7 @@ UTest({
             eq_(urlRecord, 'https://vitalik.ca');
 
             let { value: contentHash } = await ns.getContent('vitalik.eth');
-            eq_(contentHash, `ipfs://QmckiKNiVmNyQWyxQVVouUjk2zAg8nVN8qrtvoUivJ2mt8`);
+            eq_(contentHash, `ipfs://QmdTpYZMWsNFh6ja6SYUrmDQ6YnBc2vpS1QkV9gfekociF`);
         },
         async 'reverse registrar' () {
             let ns = new NameService(Web3ClientFactory.get('eth'));

package/test/services/timelock.spec.ts

@@ -1,6 +1,6 @@
 import { TimelockController } from '@dequanto-contracts/openzeppelin/TimelockController';
 import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider'
-import { TimelockService } from '@dequanto/services/TimelockService';
+import { TimelockService } from '@dequanto/services/TimelockService/TimelockService';
 import { $address } from '@dequanto/utils/$address';
 import { $date } from '@dequanto/utils/$date';
 import { l } from '@dequanto/utils/$logger';

package/tools/copy-dts.ts

@@ -12,7 +12,7 @@ async function process () {
     await await alot(files).forEachAsync(async (file, i) => {
 
         let path = file.uri.toString();
-        let typesRoot = path.replace(/\/lib\/types\/.$/, '/lib/types/');
+        let typesRoot = path.replace(/\/lib\/types\/.+$/, '/lib/types/');
         let cjsFile = path.replace('/lib/types/', '/lib/cjs/').replace(/\.d\.ts$/, '.js');
         let mjsFile = path.replace('/lib/types/', '/lib/esm/').replace(/\.d\.ts$/, '.mjs');
 
@@ -28,8 +28,10 @@ async function process () {
 
         content = content.replace(/from (?<q>['"])(?<path>@dequanto\/[^'"]+)['"]/g, (match, q, importPath) => {
             let importPathFull = importPath.replace(/^@dequanto\//, typesRoot);
-            let importPathRelative = new class_Uri(importPathFull).toRelativeString(typesRoot);
-
+            let importPathRelative = new class_Uri(importPathFull).toRelativeString(path + '.js');
+            if (importPathRelative.startsWith('.') === false) {
+                importPathRelative = './' + importPathRelative;
+            }
             return `from ${q}${importPathRelative}${q}`;
         });