dequanto 0.1.21 → 0.1.23

package/src/hardhat/HardhatProvider.ts

@@ -4,11 +4,11 @@ import { class_Uri } from 'atma-utils';
 import { File, env, Directory } from 'atma-io';
 
 import type { ContractBase } from '@dequanto/contracts/ContractBase';
-import type { Constructor } from 'atma-utils/mixin';
+
 import type { TAbiItem } from '@dequanto/types/TAbi';
 import type { TEth } from '@dequanto/models/TEth';
 
-import { EoAccount } from "@dequanto/models/TAccount";
+import { EoAccount } from '@dequanto/models/TAccount';
 import { HardhatWeb3Client } from '@dequanto/hardhat/HardhatWeb3Client';
 import { Web3Client } from '@dequanto/clients/Web3Client';
 
@@ -34,9 +34,12 @@ import { TAddress } from '@dequanto/models/TAddress';
 import { $contract } from '@dequanto/utils/$contract';
 import { $dependency } from '@dequanto/utils/$dependency';
 import { TTransport } from '@dequanto/rpc/transports/ITransport';
+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()
@@ -263,12 +266,14 @@ export class HardhatProvider {
         };
     }
 
-    async compileSol<T extends ContractBase = IContractWrapped> (solContractPath: string, options?: {
+    async compileSolDirectory (dir: string, options?: {
         paths?: {
             root?: string
             artifacts?: string
         },
         contractName?: string
+        tsgen?: boolean
+        install?: string
     }): Promise<{
         abi: TAbiItem[]
         bytecode: TEth.Hex
@@ -276,123 +281,81 @@ export class HardhatProvider {
         // renamed output
         artifact: string
         source: IGeneratorSources
-        ContractCtor: Constructor<T>
+        ContractCtor: Constructor<IContractWrapped>
         linkReferences?: Record<string /* path */, Record<string /* name */, any>>
-    }> {
+    }[]> {
 
-        solContractPath = $path.normalize(solContractPath);
-
-        const dir = solContractPath.replace(/[^\/]+$/, '');
-        const filename = /(?<filename>[^\/]+)\.\w+$/.exec(solContractPath)?.groups.filename;
-        // Filename could contain have random number, extract main-name
-        const filenameRndSuffix = filename.replace(/_\d+$/, '');
-
-        let root = options?.paths?.root;
-        let artifacts = options?.paths?.artifacts;
-
-        if (filename == null) {
-            throw new Error(`Filename not extracted from ${solContractPath}`);
+        dir = $path.normalize(dir);
+        if (await Directory.existsAsync(dir) === false) {
+            throw new Error(`Directory "${dir}" does not exist.`);
         }
-
-        let hhOptions = {
+        const paths = {
             sources: dir,
-            root,
-            artifacts,
-            tsgen: false,
+            root: options?.paths?.root,
+            artifacts: options?.paths?.artifacts,
+        };
+        const hhOptions = {
+            ...paths,
+            tsgen: options?.tsgen ?? false,
+            install: options?.install ?? null
         };
         const hh = await this.getHardhat();
         await hh.run('compile', hhOptions);
 
-        if (root == null) {
-            root = 'file://' + $path.normalize(process.cwd());
-        }
-        if (artifacts == null && root != null) {
-            artifacts = class_Uri.combine(root, 'artifacts/');
-        }
+        const files = await Directory.readFilesAsync(paths.sources, '*.sol');
 
-        if (solContractPath.toLowerCase().includes(root.toLowerCase())) {
-            let i = solContractPath.toLowerCase().indexOf(root.toLowerCase());
-            solContractPath = solContractPath.substring(i + root.length);
-        }
-
-        let outputDir = class_Uri.combine(artifacts, solContractPath);
-        let output = class_Uri.combine(outputDir, `${filename}.json`);
-        if (await File.existsAsync(output) === false) {
-            let path = `${outputDir}/`;
-            if (await Directory.existsAsync(path) === false) {
-                throw new Error(`No JSONs found in ${outputDir}, nor ${output}`);
-            }
-            let files = await Directory.readFilesAsync(path);
-            let jsons = files.filter(x => /(?<!dbg)\.json$/.test(x.uri.file));
-            if (jsons.length === 0) {
-                throw new Error(`No JSONs output found in "${outputDir}/"`);
-            }
-            if (jsons.length === 1) {
-                output = jsons[0].uri.toString();
-            } else {
-                let jsonFile = getJsonFile(jsons, filename);
-                if (jsonFile == null) {
-                    jsonFile = getJsonFile(jsons, filenameRndSuffix);
-                }
-                if (jsonFile == null) {
-                    let contractName = options?.contractName;
-                    if (contractName == null) {
-                        let source = await File.readAsync<string>(solContractPath);
-                        let rgx = /contract \s*(?<contractName>[\w_]+)/ig;
-                        let matches = Array.from(source.matchAll(rgx));
-                        contractName = matches[matches.length - 1]?.groups?.contractName;
-                        options.contractName = contractName;
-                    }
-                    jsonFile = getJsonFile(jsons, contractName);
-                }
-
-                if (jsonFile == null) {
-                    $logger.log(`Files: ${ files.map(file => file.uri.file ).join(', ')}`);
-                    throw new Error(`Compiled JSON data not found for "${filename}" in "${outputDir}/"`);
-                }
-                output = jsonFile.uri.toString();
-            }
-        }
-        function getJsonFile (files: InstanceType<typeof File>[], filename: string) {
-            return files.find(file => {
-                return file.uri.file === `${filename}.json`;
+        const results = await alot(files).mapAsync(async file => {
+            let solContractPath = file.uri.toLocalFile();
+            return await this.getContractFromSolPath(solContractPath, {
+                paths
             });
-        }
+        }).toArrayAsync();
 
-        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: {
-                artifact: output
-            }
-        })
+        return results.filter(x => x != null);
+    }
 
-        let fileMap = await alot(files)
-        .mapAsync(async file => {
-            return {
-                key: file.uri.toString(),
-                content: await file.readAsync<string>()
-            };
-        })
-        .toDictionaryAsync(x => x.key, x => ({ content: x.content }));
+    async compileSol<T extends ContractBase = IContractWrapped> (solContractPath: string, options?: {
+        paths?: {
+            root?: string
+            artifacts?: string
+        },
+        contractName?: string
+        tsgen?: boolean
+        install?: string
+    }): Promise<{
+        abi: TAbiItem[]
+        bytecode: TEth.Hex
+        output: string
+        // renamed output
+        artifact: string
+        source: IGeneratorSources
+        ContractCtor: Constructor<T>
+        linkReferences?: Record<string /* path */, Record<string /* name */, any>>
+    }> {
 
-        return {
-            abi,
-            bytecode,
-            output,
-            artifact: output,
-            source: {
-                contractName: contractName ?? options?.contractName,
-                files: fileMap
-            },
-            linkReferences,
-            ContractCtor
+        solContractPath = $path.normalize(solContractPath);
+
+        const dir = $path.getDirectory(solContractPath);
+        const paths = {
+            sources: dir,
+            root: options?.paths?.root,
+            artifacts: options?.paths?.artifacts,
         };
+
+        let hhOptions = {
+            ...paths,
+
+            tsgen: options?.tsgen ?? false,
+            install: options?.install ?? null
+        };
+        const hh = await this.getHardhat();
+        await hh.run('compile', hhOptions);
+
+
+        return await this.getContractFromSolPath<T> (solContractPath, {
+            contractName: options?.contractName,
+            paths
+        });
     }
 
     async deployCode <TReturn extends ContractBase = IContractWrapped> (
@@ -507,4 +470,174 @@ export class HardhatProvider {
         return hh.network.provider as any as TTransport.Transport;
     }
 
+
+    private async getArtifactJsonPath (solContractPath: string, options: {
+        contractName?: string
+        paths: {
+            root: string
+            artifacts: string
+        }
+    }) {
+        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}`);
+        }
+
+        if (options.contractName != null) {
+            let artifactJsonPath = class_Uri.combine(outputDir, `${options.contractName}.json`);
+            if (await File.existsAsync(artifactJsonPath)) {
+                return artifactJsonPath;
+            }
+        }
+        const { filename } = $path.getFilename(solContractPath);
+
+        if (filename != null) {
+            let artifactJsonPath = class_Uri.combine(outputDir, `${filename}.json`);
+            if (await File.existsAsync(artifactJsonPath)) {
+                return artifactJsonPath;
+            }
+        }
+        if (filename == null) {
+            throw new Error(`Filename not extracted from ${solContractPath}`);
+        }
+        let files = await Directory.readFilesAsync(outputDir);
+        let jsons = files.filter(x => /(?<!dbg)\.json$/.test(x.uri.file));
+        if (jsons.length === 0) {
+            throw new Error(`No JSONs output found in "${outputDir}/"`);
+        }
+        if (jsons.length === 1) {
+            // Only one JSON artifact found, assume it's the main contract
+            let artifactJsonPath = jsons[0].uri.toString();
+            return artifactJsonPath;
+        }
+
+
+        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 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);
+        }
+
+        if (jsonFile == null) {
+            $logger.log(`Files: ${ files.map(file => file.uri.file ).join(', ')}`);
+            throw new Error(`Compiled JSON data not found for "${filename}" in "${outputDir}/"`);
+        }
+        let artifactJsonPath = jsonFile.uri.toString();
+        return artifactJsonPath;
+
+
+        function getJsonFile (files: InstanceType<typeof File>[], filename: string) {
+            return files.find(file => {
+                return file.uri.file === `${filename}.json`;
+            });
+        }
+    }
+
+    private async getPaths (paths?: { root?: string, artifacts?: string }) {
+        let root = paths?.root;
+        let artifacts = paths?.artifacts;
+
+        if (root == null) {
+            root = 'file://' + $path.normalize(process.cwd());
+        }
+        if (artifacts == null) {
+            artifacts = class_Uri.combine(root, 'artifacts/');
+        }
+
+        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}`);
+        }
+
+        let source = await File.readAsync<string>(sourceFile);
+        return source;
+    }
+
+    public async getContractFromSolPath <T extends ContractBase = IContractWrapped>  (solContractPath: string, options?: {
+        contractName?: string
+        paths: {
+            sources?: string
+            root?: string;
+            artifacts?: string;
+        };
+    }) {
+
+        let { root, artifacts } = await this.getPaths (options?.paths);
+        let solContractPathRootRelative = $path.getRelativePath(solContractPath, root);
+
+        let artifactJsonPath = await this.getArtifactJsonPath(solContractPathRootRelative, {
+            contractName: options?.contractName,
+            paths: {
+                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, {
+            contractName,
+            $meta: {
+                name: contractName,
+                source: solContractPathRootRelative,
+                artifact: artifactJsonPath
+            }
+        })
+
+        let files = options?.paths?.sources
+            ? await Directory.readFilesAsync(options.paths.sources, '*.sol')
+            : [];
+        let fileMap = await alot(files)
+            .mapAsync(async file => {
+                return {
+                    key: file.uri.toString(),
+                    content: await file.readAsync<string>()
+                };
+            })
+            .toDictionaryAsync(x => x.key, x => ({ content: x.content }));
+
+        return {
+            abi,
+            bytecode,
+            output: artifactJsonPath,
+            artifact: artifactJsonPath,
+            source: {
+                contractName: contractName ?? options?.contractName,
+                files: fileMap
+            },
+            linkReferences,
+            ContractCtor
+        };
+    }
+}
+
+
+interface IJsonArtifact {
+    abi: TEth.Abi.Item[]
+    bytecode: TEth.Hex
+    contractName: string
+    linkReferences: Record<string /* path */, Record<string /* name */, any>>
 }

package/src/json/JsonArrayMultiStore.ts

@@ -89,14 +89,16 @@ export class JsonArrayMultiStore<T> {
     private async getGroupedFiles () {
         try {
             let files = await Directory.readFilesAsync(this.options.path, '*.json');
-            let rangeFiles = files
+            let rangeFiles = alot(files)
             .map(file => {
                 return {
                     file,
                     range: this.parseRangeFilename(file.uri.file)
                 };
             })
-            .filter(x => x.range != null);
+            .filter(x => x.range != null)
+            .sortBy(x => x.range.start, 'asc')
+            .toArray();
             return rangeFiles;
         } catch (e) {
             return [];

package/src/json/JsonArrayStore.ts

@@ -2,7 +2,7 @@ import alot from 'alot'
 import { JsonConvert } from 'class-json'
 import { Alot } from 'alot/alot'
 import { JsonStoreFs } from './JsonStoreFs'
-import type { Constructor } from 'atma-utils'
+import { Constructor } from '@dequanto/utils/types'
 
 export interface IStoreOptions<T, TStorage = T> {
     path: string

package/src/models/TEth.ts

@@ -201,7 +201,7 @@ export namespace TEth {
         }
 
         export interface Input {
-            name: string;
+            name?: string;
             type: string;
             indexed?: boolean;
             components?: Input[];
@@ -209,7 +209,7 @@ export namespace TEth {
         }
 
         export interface Output {
-            name: string;
+            name?: string;
             type: string;
             components?: Output[];
             internalType?: string;

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

package/src/solidity/SlotsStorage.ts

@@ -7,7 +7,8 @@ import { SlotDynamicArrayHandler } from './storage/handlers/SlotDynamicArrayHand
 import { SlotsStorageTransport, ISlotsStorageTransport, SlotsCursorTransport } from './storage/SlotsStorageTransport';
 import { TAddress } from '@dequanto/models/TAddress';
 import { ASlotsStorageHandler } from './storage/SlotsStorageHandler';
-import { Constructor, is_Object } from 'atma-utils';
+import { Constructor } from '@dequanto/utils/types';
+import { is_Object } from 'atma-utils';
 import { SlotMappingHandler } from './storage/handlers/SlotMappingHandler';
 import { SlotStringHandler } from './storage/handlers/SlotStringHandler';
 import { Accessor, IAccessorItem } from './storage/Accessor';

package/src/tokens/TokenExchanges/AmmV2ExchangeBase.ts

@@ -12,10 +12,10 @@ import { TokensServiceBsc } from '../TokensServiceBsc';
 import { $address } from '@dequanto/utils/$address';
 import { $require } from '@dequanto/utils/$require';
 import { $cache } from '@dequanto/utils/$cache';
-import { AmmFactoryV2Contract } from '@dequanto-contracts/amm/AmmFactoryV2Contract/AmmFactoryV2Contract';
-import { AmmMasterChefV2Contract } from '@dequanto-contracts/amm/AmmMasterChefV2Contract/AmmMasterChefV2Contract';
-import { AmmVaultV2Contract } from '@dequanto-contracts/amm/AmmVaultV2Contract/AmmVaultV2Contract';
-import { AmmPairV2Contract } from '@dequanto-contracts/amm/AmmPairV2Contract/AmmPairV2Contract';
+import { AmmFactoryV2Contract } from '@dequanto/prebuilt/amm/AmmFactoryV2Contract/AmmFactoryV2Contract';
+import { AmmMasterChefV2Contract } from '@dequanto/prebuilt/amm/AmmMasterChefV2Contract/AmmMasterChefV2Contract';
+import { AmmVaultV2Contract } from '@dequanto/prebuilt/amm/AmmVaultV2Contract/AmmVaultV2Contract';
+import { AmmPairV2Contract } from '@dequanto/prebuilt/amm/AmmPairV2Contract/AmmPairV2Contract';
 
 
 interface ILPPair extends IToken {

package/src/tokens/TokenExchanges/OneInchExchange.ts

@@ -11,7 +11,7 @@ import { TxWriter } from '@dequanto/txs/TxWriter';
 import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
 import { Web3Client } from '@dequanto/clients/Web3Client';
 import { IBlockChainExplorer } from '@dequanto/explorer/IBlockChainExplorer';
-import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
 import { $http } from '@dequanto/utils/$http';
 
 const PLATFORMS = {

package/src/tokens/TokenOracles/amm/AmmV1Oracle.ts

@@ -17,7 +17,7 @@ import { TAddress } from '@dequanto/models/TAddress';
 import { IBlockChainExplorer } from '@dequanto/explorer/IBlockChainExplorer';
 import { ContractReader } from '@dequanto/contracts/ContractReader';
 import { $config } from '@dequanto/utils/$config';
-import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
 import { TokensService } from '@dequanto/tokens/TokensService';
 import { $bigint } from '@dequanto/utils/$bigint';
 import { $block } from '@dequanto/utils/$block';

package/src/tokens/TokenService.ts

@@ -8,7 +8,7 @@ import { $bigint } from '@dequanto/utils/$bigint';
 import { TokensServiceFactory } from './TokensServiceFactory';
 import { $require } from '@dequanto/utils/$require';
 import { TokensService } from './TokensService';
-import { WETH } from '@dequanto-contracts/weth/WETH/WETH';
+import { WETH } from '@dequanto/prebuilt/weth/WETH/WETH';
 import { BlockDateResolver } from '@dequanto/blocks/BlockDateResolver';
 
 

package/src/tokens/TokensService.ts

@@ -8,7 +8,7 @@ import { ITokenProvider } from './TokenProviders/ITokenProvider';
 import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
 import { BlockChainExplorerProvider } from '@dequanto/explorer/BlockChainExplorerProvider';
 import { TokenDataProvider } from './TokenDataProvider';
-import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
 
 
 export class TokensService {

package/src/tokens/TokensServiceBsc.ts

@@ -2,7 +2,7 @@ import di from 'a-di';
 import { TokensService } from './TokensService';
 import { Bscscan } from '@dequanto/explorer/Bscscan';
 import { TAddress } from '@dequanto/models/TAddress';
-import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
 
 export class TokensServiceBsc extends TokensService {
     constructor () {

package/src/tokens/TokensServicePolygon.ts

@@ -2,7 +2,7 @@ import di from 'a-di';
 import { TokensService } from './TokensService';
 import { TAddress } from '@dequanto/models/TAddress';
 import { Polyscan } from '@dequanto/explorer/Polyscan';
-import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
 
 export class TokensServicePolygon extends TokensService {
     constructor () {

package/src/tokens/TokensServiceXDai.ts

@@ -4,7 +4,7 @@ import { TAddress } from '@dequanto/models/TAddress';
 import { XDaiscan } from '@dequanto/chains/xdai/XDaiscan';
 import { IToken } from '@dequanto/models/IToken';
 import { ITokenProvider } from './TokenProviders/ITokenProvider';
-import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
 
 export class TokensServiceXDai extends TokensService {
     constructor () {

package/src/types/TAbi.ts

@@ -20,13 +20,13 @@ export interface TAbiInput {
     name?: string;
     type: string;
     indexed?: boolean;
-	components?: TAbiInput[];
+    components?: TAbiInput[];
     internalType?: string;
 }
 
 export interface TAbiOutput {
     name?: string;
     type: string;
-	components?: TAbiOutput[];
+    components?: TAbiOutput[];
     internalType?: string;
 }