dequanto 0.1.22 → 0.1.23

package/src/gen/GeneratorFromAbi.ts

@@ -59,27 +59,36 @@ export class GeneratorFromAbi {
                 return null;
             })
             .filter(Boolean)
-            .map(x => x[ opts?.target ?? 'ts' ])
-            .map(Str.formatMethod)
-            .toArray();
+            .mapFull(arr => {
+                return {
+                    ts: arr.map(x => Str.formatMethod(x.ts)),
+                    js: arr.map(x => Str.formatMethod(x.js)),
+                    types: arr.map(x => Str.formatMethod(x.types)),
+                }
+            });
 
 
-        let methodTypes = alot(abiJson)
+        let methodTypings = alot(abiJson)
             .filter(x => x.type === 'function')
             .groupBy(x => x.name)
             .map(group => {
                 let item = group.values[0];
-                return Gen.serializeMethodTypeTs(item.name, group.values);
+                return Gen.serializeMethodTypingsTs(item.name, group.values);
             })
             .filter(Boolean)
             .toArray();
 
-        let eventsArr = abiJson
+        let eventsArr = alot(abiJson)
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEvent(x))
             .filter(Boolean)
-            .map(x => x[ opts?.target ?? 'ts' ])
-            .map(Str.formatMethod);
+            .mapFull(arr => {
+                return {
+                    ts: arr.map(x => Str.formatMethod(x.ts)),
+                    js: arr.map(x => Str.formatMethod(x.js)),
+                    types: arr.map(x => Str.formatMethod(x.types)),
+                }
+            })
 
         let eventTypes = alot(abiJson)
             .filter(x => x.type === 'event')
@@ -94,19 +103,29 @@ export class GeneratorFromAbi {
 
         //let eventInterfacesAll = Gen.serializeEventsInterfacesAllTs(abiJson.filter(x => x.type === 'event'));
 
-        let eventsExtractorsArr = abiJson
+        let eventsExtractorsArr = alot(abiJson)
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEventExtractor(x))
             .filter(Boolean)
-            .map(x => x[ opts?.target ?? 'ts' ])
-            .map(Str.formatMethod);
+            .mapFull(arr => {
+                return {
+                    ts: arr.map(x => Str.formatMethod(x.ts)),
+                    js: arr.map(x => Str.formatMethod(x.js)),
+                    types: arr.map(x => Str.formatMethod(x.types)),
+                }
+            });
 
-        let eventsFetchersArr = abiJson
+        let eventsFetchersArr = alot(abiJson)
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEventFetcher(x))
             .filter(Boolean)
-            .map(x => x[ opts?.target ?? 'ts' ])
-            .map(Str.formatMethod);
+            .mapFull(arr => {
+                return {
+                    ts: arr.map(x => Str.formatMethod(x.ts)),
+                    js: arr.map(x => Str.formatMethod(x.js)),
+                    types: arr.map(x => Str.formatMethod(x.types)),
+                }
+            });
 
         // let eventInterfaces = abiJson
         //     .filter(x => x.type === 'event')
@@ -114,15 +133,22 @@ export class GeneratorFromAbi {
         //     .filter(Boolean)
         //     .map(Str.formatMethod);
 
-        let methods = methodsArr.join('\n\n');
-        let events = eventsArr.join('\n\n');
-        let eventsExtractors = eventsExtractorsArr.join('\n\n');
-        let eventsFetchers = eventsFetchersArr.join('\n\n');
+        let methods = methodsArr[targetType].join('\n\n');
+        let methodsTypings = methodsArr.types.join('\n\n');
+        let events = eventsArr[targetType].join('\n\n');
+        let eventsTypings = eventsArr.types.join('\n\n');
+
+        let eventsExtractors = eventsExtractorsArr[targetType].join('\n\n');
+        let eventsExtractorsTypings = eventsExtractorsArr.types.join('\n\n');
+
+        let eventsFetchers = eventsFetchersArr[targetType].join('\n\n');
+        let eventsFetchersTypings = eventsFetchersArr.types.join('\n\n');
 
         let name = opts.name;
-        let templatePath = $path.resolve(`/src/gen/ContractTemplate.${ targetType }`);
+        let templatePath = $path.resolve(`/src/gen/templates/ContractTemplate.${ targetType }.tmpl`);
         let template = await File.readAsync<string>(templatePath, { skipHooks: true });
-
+        let templateDtsPath = $path.resolve(`/src/gen/templates/ContractTemplate.d.ts.tmpl`);
+        let templateDts = await File.readAsync<string>(templateDtsPath, { skipHooks: true });
 
         let EtherscanStr;
         let EthWeb3ClientStr;
@@ -130,44 +156,8 @@ export class GeneratorFromAbi {
         let sourceUri: string;
         let Web3ClientOptions = '';
         let EvmScanOptions = '';
-        let importPfx = targetType === 'js' ? 'dequanto' : '@dequanto';
+        let importPfx = true /* always */ ? 'dequanto' : '@dequanto';
         switch (opts.network) {
-            case 'bsc':
-                EtherscanStr = 'Bscscan';
-                EthWeb3ClientStr = 'BscWeb3Client';
-                imports = [
-                    `import { Bscscan } from '${importPfx}/explorer/Bscscan'`,
-                    `import { BscWeb3Client } from '${importPfx}/clients/BscWeb3Client'`,
-                ];
-                sourceUri = `https://bscscan.com/address/${opts.address}#code`;
-                break;
-            case 'polygon':
-                EtherscanStr = 'Polyscan';
-                EthWeb3ClientStr = 'PolyWeb3Client';
-                imports = [
-                    `import { Polyscan } from '${importPfx}/explorer/Polyscan'`,
-                    `import { PolyWeb3Client } from '${importPfx}/clients/PolyWeb3Client'`,
-                ];
-                sourceUri = `https://polygonscan.com/address/${opts.address}#code`;
-                break;
-            case 'xdai':
-                EtherscanStr = 'XDaiscan';
-                EthWeb3ClientStr = 'XDaiWeb3Client';
-                imports = [
-                    `import { XDaiscan } from '${importPfx}/chains/xdai/XDaiscan'`,
-                    `import { XDaiWeb3Client } from '${importPfx}/chains/xdai/XDaiWeb3Client'`,
-                ];
-                sourceUri = `https://blockscout.com/xdai/mainnet/address/${opts.address}/contracts`;
-                break;
-            case 'eth':
-                EtherscanStr = 'Etherscan';
-                EthWeb3ClientStr = 'EthWeb3Client';
-                imports = [
-                    `import { Etherscan } from '${importPfx}/explorer/Etherscan'`,
-                    `import { EthWeb3Client } from '${importPfx}/clients/EthWeb3Client'`,
-                ];
-                sourceUri = `https://etherscan.io/address/${opts.address}#code`;
-                break;
             case 'hardhat':
                 EtherscanStr = 'Etherscan';
                 EthWeb3ClientStr = 'HardhatWeb3Client';
@@ -222,6 +212,7 @@ export class GeneratorFromAbi {
         let storageReaderInitializer = '';
         let storageReaderProperty = '';
         let storageReaderClass = '';
+        let storageReaderClassTypings = '';
         try {
             let storageReaderGenerator = new GeneratorStorageReader();
             let reader = await storageReaderGenerator.generate({ ...opts, target: targetType });
@@ -231,6 +222,7 @@ export class GeneratorFromAbi {
             }
             if (reader.className) {
                 storageReaderClass = reader.code;
+                storageReaderClassTypings = reader.types;
                 storageReaderProperty = targetType === 'ts' ? `declare storage: ${reader.className}` : '';
                 storageReaderInitializer = `this.storage = new ${reader.className}(this.address, this.client, this.explorer);`;
                 $logger.log(`green<StorageReader> was generated`);
@@ -270,13 +262,43 @@ export class GeneratorFromAbi {
 
 
             .replace(`/* $EVENT_TYPES$ */`, () => Str.indent(eventTypes.map(x => x.code).join('\n'), '        '))
-            .replace(`/* $METHOD_TYPES$ */`, () => Str.indent(methodTypes.map(x => x.code).join('\n'), '        '))
+            .replace(`/* $METHOD_TYPES$ */`, () => Str.indent(methodTypings.map(x => x.code).join('\n'), '        '))
             //.replace(`/* $METHOD_INTERFACES$ */`, () => methodInterfacesArr.map(x => x.code).join('\n\n') + '\n\n' + methodInterfacesAll.code + '\n\n')
             ;
 
+        let codeDts = templateDts
+
+            .replace(`/* IMPORTS */`, () => imports.join('\n'))
+            .replace(`/* ERRORS */`, () => Gen.serializeErrors(className, abiJson))
+            .replace(/\$NAME\$/g, className)
+            .replace(`$ADDRESS$`, opts.address ? `'${opts.address}'` : 'null')
+            .replace(`/* METHODS */`, methodsTypings)
+            .replace(`/* EVENTS */`, eventsTypings)
+            .replace(`/* EVENTS_EXTRACTORS */`, eventsExtractorsTypings)
+            .replace(`/* EVENTS_FETCHERS */`, eventsFetchersTypings)
+            .replace(`$ABI$`, () => JSON.stringify(abiJson))
+            .replace(`$DATE$`, $date.format(new Date(), 'yyyy-MM-dd HH:mm'))
+            .replace(`$EXPLORER_URL$`, sourceUri)
+            //.replace(`/* $EVENT_INTERFACES$ */`, () => eventInterfaces.join('\n') + '\n\n' + eventInterfacesAll.code + '\n\n')
+
+            .replace(`/* STORAGE_READER_INITIALIZER */`, storageReaderInitializer)
+            .replace(`/* STORAGE_READER_PROPERTY */`, storageReaderProperty)
+            .replace(`/* STORAGE_READER_CLASS */`, () => storageReaderClassTypings)
+            .replace(`/* TX_CALLER_METHODS */`, () => Gen.serializeTxCallerMethods(className, abiJson)[targetType])
+            .replace(`/* TX_DATA_METHODS */`, () => Gen.serializeTxDataMethods(className, abiJson)[targetType])
+
+
+            .replace(`/* $EVENT_TYPES$ */`, () => Str.indent(eventTypes.map(x => x.code).join('\n'), '        '))
+            .replace(`/* $METHOD_TYPES$ */`, () => Str.indent(methodTypings.map(x => x.code).join('\n'), '        '))
+            ;
 
 
         await File.writeAsync(outputPath, code, { skipHooks: true });
+        if (targetType === 'js') {
+            let outputPathDts = outputPath.replace(/\.\w+$/, '.d.ts');
+            await File.writeAsync(outputPathDts, codeDts, { skipHooks: true });
+        }
+
 
         if (opts.saveAbi) {
             let path = class_Uri.combine(opts.output, outputDirectory, `${outputFilename}Abi.json`);
@@ -372,7 +394,7 @@ namespace Gen {
         };
     }
 
-    export function serializeMethodTypeTs(name: string, abis: TAbiItem[]) {
+    export function serializeMethodTypingsTs(name: string, abis: TAbiItem[]) {
         let args = abis.map(abi => {
             let { fnInputArgumentsTargets } = serializeArgumentsTs(abi);
             return `[ ${fnInputArgumentsTargets.ts} ]`;
@@ -443,6 +465,9 @@ namespace Gen {
                     return this.$onLog('${abi.name}', fn);
                 }
             `,
+            types: `
+                on${abi.name} (fn?: (event: TClientEventsStreamData<TEventArguments<'${abi.name}'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'${abi.name}'>>>
+            `,
             js: `
                 on${abi.name} (fn) {
                     return this.$onLog('${abi.name}', fn);
@@ -458,6 +483,9 @@ namespace Gen {
                     return this.$extractLogs(tx, abi) as any as ITxLogItem<TEventParams<'${abi.name}'>>[];
                 }
             `,
+            types: `
+                extractLogs${abi.name} (tx: TEth.TxReceipt): ITxLogItem<TEventParams<'${abi.name}'>>[]
+            `,
             js: `
                 extractLogs${abi.name} (tx) {
                     let abi = this.$getAbiItem('event', '${abi.name}');
@@ -481,13 +509,11 @@ namespace Gen {
                 }
             `,
             types: `
-                async getPastLogs${abi.name} (options?: {
+                getPastLogs${abi.name} (options?: {
                     fromBlock?: number | Date
                     toBlock?: number | Date
                     params?: { ${indexedParams} }
-                }): Promise<ITxLogItem<TEventParams<'${abi.name}'>>[]> {
-                    return await this.$getPastLogsParsed('${abi.name}', options) as any;
-                }
+                }): Promise<ITxLogItem<TEventParams<'${abi.name}'>>[]>
             `,
             js: `
                 async getPastLogs${abi.name} (options) {
@@ -536,7 +562,7 @@ namespace Gen {
             `,
             types: `
                 // ${$abiUtils.getMethodSignature(abi)}
-                async ${abi.name} (${fnInputArgumentsTargets.ts}): ${fnResult}
+                ${abi.name} (${fnInputArgumentsTargets.ts}): ${fnResult}
             `,
             js: `
                 // ${$abiUtils.getMethodSignature(abi)}
@@ -568,7 +594,7 @@ namespace Gen {
             `,
             types: `
                 ${overrides}
-                async ${abi.name} (...args): ${fnResult}
+                ${abi.name} (...args): ${fnResult}
             `,
             js: `
                 async ${abi.name} (...args) {
@@ -594,7 +620,7 @@ namespace Gen {
             `,
             types: `
                 // ${$abiUtils.getMethodSignature(abi)}
-                async ${abi.name} (sender: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter>
+                ${abi.name} (sender: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter>
             `,
             js: `
                 // ${$abiUtils.getMethodSignature(abi)}
@@ -616,7 +642,7 @@ namespace Gen {
                 }
             `,
             types: `
-                async $constructor (deployer: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter>
+                $constructor (deployer: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter>
             `,
             js: `
                 async $constructor (deployer, ${fnInputArgumentsTargets.js}) {
@@ -646,7 +672,7 @@ namespace Gen {
             `,
             types: `
                 ${overrides}
-                async ${abi.name} (sender: TSender, ...args): Promise<TxWriter>
+                ${abi.name} (sender: TSender, ...args): Promise<TxWriter>
             `,
             js: `
                 async ${abi.name} (sender, ...args) {

package/src/gen/GeneratorStorageReader.ts

@@ -24,7 +24,7 @@ export class GeneratorStorageReader {
             [file: string]: { content: string }
         },
         client?: Web3Client
-    }): Promise<{ code?: string, className?: string, sourcePath?: string, error?: Error }> {
+    }): Promise<{ code?: string, types?: string, className?: string, sourcePath?: string, error?: Error }> {
 
         let targetType = opts.target ?? 'ts';
         let { client, sources, contractName, address } = opts;
@@ -60,19 +60,29 @@ export class GeneratorStorageReader {
 
         let methods = this.serializeSlots(slots);
         let codeMethods = methods.map(x => x[targetType]).join('\n\n');
+        let codeMethodsTypings = methods.map(x => x.types).join('\n\n');
 
-        let templatePath = $path.resolve(`/src/gen/ContractStorageReaderTemplate.${targetType}`);
+        let templatePath = $path.resolve(`/src/gen/templates/ContractStorageReaderTemplate.${targetType}.tmpl`);
         let template = await File.readAsync<string>(templatePath, { skipHooks: true });
+
+        let templateTypingsPath = $path.resolve(`/src/gen/templates/ContractStorageReaderTemplate.d.ts.tmpl`);
+        let templateTypings = await File.readAsync<string>(templateTypingsPath, { skipHooks: true });
+
         let className = $gen.toClassName(opts.name + 'StorageReader');
         let code = template
             .replace(`$NAME$`, className)
             .replace(`/* METHODS */`, () => codeMethods)
             .replace(`$SLOTS$`, () => JSON.stringify(slots, null, '    '))
 
+        let codeTypings = templateTypings
+            .replace(`$NAME$`, className)
+            .replace(`/* METHODS */`, () => codeMethodsTypings)
+            .replace(`$SLOTS$`, () => JSON.stringify(slots, null, '    '))
 
         return {
             className: className,
             code: code,
+            types: codeTypings,
             sourcePath: file.path
         };
     }
@@ -84,6 +94,7 @@ export class GeneratorStorageReader {
                 return {
                     ts: Str.formatMethod(entry.ts),
                     js: Str.formatMethod(entry.js),
+                    types: Str.formatMethod(entry.types),
                 }
             });
     }
@@ -98,6 +109,9 @@ export class GeneratorStorageReader {
                     return this.$storage.get(['${name}', ${ parametersCall ?? '' }]);
                 }
             `,
+            types: `
+                ${name}(${parametersTypes?.ts ?? ''}): Promise<${returnType}>
+            `,
             js: `
                 async ${name}(${parametersTypes?.js ?? ''}) {
                     return this.$storage.get(['${name}', ${ parametersCall ?? '' }]);

package/src/gen/templates/ContractStorageReaderTemplate.d.ts.tmpl

@@ -0,0 +1,7 @@
+declare class $NAME$ extends ContractStorageReaderBase {
+
+/* METHODS */
+
+    $slots: $SLOTS$
+
+}

package/src/gen/{ContractTemplate.d.ts.template → templates/ContractTemplate.d.ts.tmpl}

@@ -3,24 +3,24 @@
  *  Implementation: $EXPLORER_URL$
  */
 import di from 'a-di';
-import { TAddress } from '@dequanto/models/TAddress';
-import { TAccount } from '@dequanto/models/TAccount';
-import { TBufferLike } from '@dequanto/models/TBufferLike';
-import { ClientEventsStream, TClientEventsStreamData } from '@dequanto/clients/ClientEventsStream';
-import { ContractBase } from '@dequanto/contracts/ContractBase';
-import { ContractBaseUtils } from '@dequanto/contracts/utils/ContractBaseUtils';
-import { ContractStorageReaderBase } from '@dequanto/contracts/ContractStorageReaderBase';
-import { TxWriter } from '@dequanto/txs/TxWriter';
-import { ITxLogItem } from '@dequanto/txs/receipt/ITxLogItem';
-import { Web3Client } from '@dequanto/clients/Web3Client';
-import { IBlockChainExplorer } from '@dequanto/explorer/IBlockChainExplorer';
-import { SubjectStream } from '@dequanto/class/SubjectStream';
-
-
-import type { ContractWriter } from '@dequanto/contracts/ContractWriter';
-import type { TAbiItem } from '@dequanto/types/TAbi';
-import type { TEth } from '@dequanto/models/TEth';
-import type { TOverrideReturns } from '@dequanto/utils/types';
+import { TAddress } from 'dequanto/models/TAddress';
+import { TAccount } from 'dequanto/models/TAccount';
+import { TBufferLike } from 'dequanto/models/TBufferLike';
+import { ClientEventsStream, TClientEventsStreamData } from 'dequanto/clients/ClientEventsStream';
+import { ContractBase } from 'dequanto/contracts/ContractBase';
+import { ContractBaseUtils } from 'dequanto/contracts/utils/ContractBaseUtils';
+import { ContractStorageReaderBase } from 'dequanto/contracts/ContractStorageReaderBase';
+import { TxWriter } from 'dequanto/txs/TxWriter';
+import { ITxLogItem } from 'dequanto/txs/receipt/ITxLogItem';
+import { Web3Client } from 'dequanto/clients/Web3Client';
+import { IBlockChainExplorer } from 'dequanto/explorer/IBlockChainExplorer';
+import { SubjectStream } from 'dequanto/class/SubjectStream';
+
+
+import type { ContractWriter } from 'dequanto/contracts/ContractWriter';
+import type { TAbiItem } from 'dequanto/types/TAbi';
+import type { TEth } from 'dequanto/models/TEth';
+import type { TOverrideReturns } from 'dequanto/utils/types';
 
 
 /* IMPORTS */
@@ -28,16 +28,15 @@ import type { TOverrideReturns } from '@dequanto/utils/types';
 /* ERRORS */
 
 export declare class $NAME$ extends ContractBase {
-    constructor(public address: TEth.Address,
-        public client: Web3Client,
-        public explorer: IBlockChainExplorer,
-    )
+
 
     Types: T$NAME$Types;
 
+
+
 /* METHODS */
 
-    $call (): TxCaller
+    $call (): I$NAME$TxCaller
     $signed (): TOverrideReturns<I$NAME$TxCaller, Promise<{ signed: TEth.Hex, error?: Error & { data?: { type: string, params } } }>>
     $data (): I$NAME$TxData
     $gas (): TOverrideReturns<I$NAME$TxCaller, Promise<{ gas?: bigint, price?: bigint, error?: Error & { data?: { type: string, params } } }>>
@@ -54,15 +53,15 @@ export declare class $NAME$ extends ContractBase {
     onLog (event: keyof TEvents, cb?: (event: TClientEventsStreamData) => void): ClientEventsStream<TClientEventsStreamData>
 
 
-    async getPastLogs <TEventName extends keyof TEvents> (
-        events: TEventName[]
-        , options?: TEventLogOptions<TEventParams<TEventName>>
+    getPastLogs <TEventName extends keyof TEvents> (
+        events: TEventName[], options?: TEventLogOptions<TEventParams<TEventName>>
     ): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>
-    async getPastLogs <TEventName extends keyof TEvents> (
-        event: TEventName
-        , options?: TEventLogOptions<TEventParams<TEventName>>
+
+    getPastLogs <TEventName extends keyof TEvents> (
+        event: TEventName, options?: TEventLogOptions<TEventParams<TEventName>>
     ): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>
-    async getPastLogs (mix: any, options?): Promise<any>
+
+    getPastLogs (mix: any, options?): Promise<any>
 
 /* EVENTS */
 

package/src/hardhat/HardhatProvider.ts

@@ -38,6 +38,8 @@ import { Constructor } from '@dequanto/utils/types';
 
 type THardhatLib = typeof import('hardhat');
 
+const rgx_CONTRACT_NAME = /contract\s+(?<contractName>[\w_]+)/ig;
+
 export class HardhatProvider {
 
     @memd.deco.memoize()
@@ -302,12 +304,14 @@ export class HardhatProvider {
 
         const files = await Directory.readFilesAsync(paths.sources, '*.sol');
 
-        return await alot(files).mapAsync(async file => {
+        const results = await alot(files).mapAsync(async file => {
             let solContractPath = file.uri.toLocalFile();
             return await this.getContractFromSolPath(solContractPath, {
                 paths
             });
         }).toArrayAsync();
+
+        return results.filter(x => x != null);
     }
 
     async compileSol<T extends ContractBase = IContractWrapped> (solContractPath: string, options?: {
@@ -476,6 +480,10 @@ export class HardhatProvider {
     }) {
         let outputDir = class_Uri.combine(options.paths.artifacts, solContractPath, '/');
         if (await Directory.existsAsync(outputDir) === false) {
+            let content = await this.getSolFileContent(solContractPath, options);
+            if (rgx_CONTRACT_NAME.test(content) === false) {
+                return null;
+            }
             throw new Error(`No JSONs found in ${outputDir} for ${solContractPath}`);
         }
 
@@ -496,11 +504,6 @@ export class HardhatProvider {
         if (filename == null) {
             throw new Error(`Filename not extracted from ${solContractPath}`);
         }
-
-
-        // Filename could contain random number, extract main-name
-
-
         let files = await Directory.readFilesAsync(outputDir);
         let jsons = files.filter(x => /(?<!dbg)\.json$/.test(x.uri.file));
         if (jsons.length === 0) {
@@ -515,24 +518,15 @@ export class HardhatProvider {
 
         let jsonFile = getJsonFile(jsons, filename);
         if (jsonFile == null) {
+            // Filename could contain random number, extract main-name
             const filenameRndSuffix = filename.replace(/_\d+$/, '');
             if (filenameRndSuffix != null) {
                 jsonFile = getJsonFile(jsons, filenameRndSuffix);
             }
         }
         if (jsonFile == null) {
-            let sourceFile = solContractPath;
-            if (await File.existsAsync(sourceFile) === false) {
-                sourceFile = class_Uri.combine(options.paths.root, sourceFile);
-            }
-            if (await File.existsAsync(sourceFile) === false) {
-                throw new Error(`Source file "${solContractPath}" not found in ${options.paths.root}`);
-            }
-
-
-            let source = await File.readAsync<string>(sourceFile);
-            let rgx = /contract \s*(?<contractName>[\w_]+)/ig;
-            let matches = Array.from(source.matchAll(rgx));
+            let source = await this.getSolFileContent(solContractPath, options);
+            let matches = Array.from(source.matchAll(rgx_CONTRACT_NAME));
             let contractName = matches[matches.length - 1]?.groups?.contractName;
             options.contractName = contractName;
             jsonFile = getJsonFile(jsons, contractName);
@@ -567,11 +561,23 @@ export class HardhatProvider {
         return { root, artifacts };
     }
 
+    private async getSolFileContent (solContractPath, options: { paths: { root }}) {
+        let sourceFile = solContractPath;
+        if (await File.existsAsync(sourceFile) === false) {
+            sourceFile = class_Uri.combine(options.paths.root, sourceFile);
+        }
+        if (await File.existsAsync(sourceFile) === false) {
+            throw new Error(`Source file "${solContractPath}" not found in ${options.paths.root}`);
+        }
 
-    private async getContractFromSolPath <T extends ContractBase = IContractWrapped>  (solContractPath, options: {
+        let source = await File.readAsync<string>(sourceFile);
+        return source;
+    }
+
+    public async getContractFromSolPath <T extends ContractBase = IContractWrapped>  (solContractPath: string, options?: {
         contractName?: string
         paths: {
-            sources: string
+            sources?: string
             root?: string;
             artifacts?: string;
         };
@@ -586,7 +592,10 @@ export class HardhatProvider {
                 root,
                 artifacts,
             },
-        })
+        });
+        if (artifactJsonPath == null) {
+            return null;
+        }
 
         let { abi, bytecode, contractName, linkReferences } = await File.readAsync<IJsonArtifact> (artifactJsonPath);
         let { contract, ContractCtor } = ContractClassFactory.fromAbi<T>(null, abi, null, null, {
@@ -598,7 +607,9 @@ export class HardhatProvider {
             }
         })
 
-        let files = await Directory.readFilesAsync(options.paths.sources, '*.sol');
+        let files = options?.paths?.sources
+            ? await Directory.readFilesAsync(options.paths.sources, '*.sol')
+            : [];
         let fileMap = await alot(files)
             .mapAsync(async file => {
                 return {

package/src/ns/providers/EnsProvider.ts

@@ -4,8 +4,8 @@ import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
 import { TAddress } from '@dequanto/models/TAddress';
 import { $require } from '@dequanto/utils/$require';
 import { $ns } from '../utils/$ns';
-import type { EnsPublicResolver } from '@dequanto-contracts/ens/EnsPublicResolver/EnsPublicResolver';
-import type { EnsRegistry } from '@dequanto-contracts/ens/EnsRegistry/EnsRegistry';
+import type { EnsPublicResolver } from '@dequanto/prebuilt/ens/EnsPublicResolver/EnsPublicResolver';
+import type { EnsRegistry } from '@dequanto/prebuilt/ens/EnsRegistry/EnsRegistry';
 import { $is } from '@dequanto/utils/$is';
 import { TEth } from '@dequanto/models/TEth';
 import { ContractClassFactory } from '@dequanto/contracts/ContractClassFactory';

package/src/safe/GnosisSafeFactory.ts

@@ -2,10 +2,10 @@ import { EoAccount } from "@dequanto/models/TAccount";
 import { Web3Client } from '@dequanto/clients/Web3Client';
 import { TAddress } from '@dequanto/models/TAddress';
 import { GnosisSafeHandler } from './GnosisSafeHandler';
-import { Safe } from '@dequanto-contracts/safe/Safe';
+import { Safe } from '@dequanto/prebuilt/safe/Safe';
 import { config } from '@dequanto/config/Config';
 import { $require } from '@dequanto/utils/$require';
-import { SafeProxyFactory } from '@dequanto-contracts/safe/SafeProxyFactory';
+import { SafeProxyFactory } from '@dequanto/prebuilt/safe/SafeProxyFactory';
 import { TEth } from '@dequanto/models/TEth';
 import { TAbiItem } from '@dequanto/types/TAbi';
 

package/src/safe/GnosisSafeService.ts

@@ -1,4 +1,4 @@
-import { GnosisSafe } from '@dequanto-contracts/safe/GnosisSafe';
+import { GnosisSafe } from '@dequanto/prebuilt/safe/GnosisSafe';
 import { IBlockChainExplorer } from '@dequanto/explorer/IBlockChainExplorer';
 import { Web3Client } from '@dequanto/clients/Web3Client';
 import { ContractAbiProvider } from '@dequanto/contracts/ContractAbiProvider';

package/src/safe/SafeTx.ts

@@ -7,7 +7,7 @@ import { TxWriter } from '@dequanto/txs/TxWriter';
 import { $abiUtils } from '@dequanto/utils/$abiUtils';
 import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
 import { config } from '@dequanto/config/Config';
-import { MultiSend } from '@dequanto-contracts/safe/MultiSend';
+import { MultiSend } from '@dequanto/prebuilt/safe/MultiSend';
 import { ISafeServiceTransport } from './transport/ISafeServiceTransport';
 import { $hex } from '@dequanto/utils/$hex';
 

package/src/safe/transport/FileServiceTransport.ts

@@ -1,4 +1,4 @@
-import { GnosisSafe } from '@dequanto-contracts/safe/GnosisSafe';
+import { GnosisSafe } from '@dequanto/prebuilt/safe/GnosisSafe';
 import { Web3Client } from '@dequanto/clients/Web3Client';
 import { EoAccount } from '@dequanto/models/TAccount';
 import { TAddress } from '@dequanto/models/TAddress';

package/src/safe/transport/InMemoryServiceTransport.ts

@@ -1,5 +1,5 @@
 import alot from 'alot';
-import { GnosisSafe } from '@dequanto-contracts/safe/GnosisSafe';
+import { GnosisSafe } from '@dequanto/prebuilt/safe/GnosisSafe';
 import { Web3Client } from '@dequanto/clients/Web3Client';
 import type { EoAccount } from '@dequanto/models/TAccount';
 import type { TAddress } from '@dequanto/models/TAddress';

package/src/services/TimelockService/TimelockService.ts

@@ -1,5 +1,5 @@
 import memd from 'memd';
-import { TimelockController } from '@dequanto-contracts/openzeppelin/TimelockController';
+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';

package/src/services/TimelockService/TimelockServiceFallbackSafe.ts

@@ -1,4 +1,4 @@
-import { TimelockController } from '@dequanto-contracts/openzeppelin/TimelockController';
+import { TimelockController } from '@dequanto/prebuilt/openzeppelin/TimelockController';
 import { ContractBase } from '@dequanto/contracts/ContractBase';
 import { IAccount } from '@dequanto/models/TAccount';
 import { TAddress } from '@dequanto/models/TAddress';