@mentaproject/client 0.1.11 → 0.1.13

package/dist/managers/PersistenceManager.d.ts

@@ -1,6 +1,8 @@
-import { IPersistenceAdapter, TransactionWithAccount, GetPersistentTransactionsParams } from '../types/PersistenceAdapter';
+import { Address } from '@mentaproject/core/types';
+import { IPersistenceAdapter } from '../types/PersistenceAdapter';
 import { Account } from '../structures/Account';
-import { MentaClient } from '../structures';
+import { MentaClient, Transaction } from '../structures';
+import { GetTransactionsParams } from 'src/types';
 /**
  * Manages the persistence of data, including transactions, using a specified persistence adapter.
  * It handles fetching data from both local storage and remote sources, and synchronizing them.
@@ -19,7 +21,7 @@ export declare class PersistenceManager {
      * @param params - Parameters for retrieving transactions.
      * @returns A promise that resolves to an array of transactions with associated account information.
      */
-    getTransactions(params: GetPersistentTransactionsParams): Promise<TransactionWithAccount[]>;
+    getTransactions(address: Address, params: GetTransactionsParams): Promise<Transaction[]>;
     /**
      * Synchronizes an account's transactions from the remote source to the local persistence.
      * It fetches new transactions starting from the last synced block and updates the local storage.

package/dist/managers/PersistenceManager.js

@@ -19,8 +19,8 @@ export class PersistenceManager {
      * @param params - Parameters for retrieving transactions.
      * @returns A promise that resolves to an array of transactions with associated account information.
      */
-    async getTransactions(params) {
-        const localTransactions = await this.persistenceAdapter.getTransactions(params);
+    async getTransactions(address, params) {
+        const localTransactions = await this.persistenceAdapter.getTransactions(address, params);
         return localTransactions;
     }
     /**

package/dist/structures/Account.d.ts

@@ -67,7 +67,7 @@ export declare class Account {
      * @param {'asc' | 'desc'} [options.sort] - The sorting order for transactions based on block number ('asc' for ascending, 'desc' for descending).
      * @returns {Promise<Transaction[]>} A promise that resolves to an array of transactions.
      */
-    transactions(options: GetTransactionsParams): Promise<Transaction[]>;
+    transactions(params: GetTransactionsParams): Promise<Transaction[]>;
     /**
      * Synchronizes the account's transactions with the remote data source using the configured `PersistenceManager`.
      * @description This method initiates a synchronization process to ensure that the local cache of transactions

package/dist/structures/Account.js

@@ -93,19 +93,14 @@ export class Account {
      * @param {'asc' | 'desc'} [options.sort] - The sorting order for transactions based on block number ('asc' for ascending, 'desc' for descending).
      * @returns {Promise<Transaction[]>} A promise that resolves to an array of transactions.
      */
-    async transactions(options) {
+    async transactions(params) {
         if (!this.persistenceManager) {
             // If persistence is not configured, fetch directly from remote
-            const hashes = await this._fetchTransactions(options);
+            const hashes = await this._fetchTransactions(params);
             const transactions = await Promise.all(hashes.map(hash => this.client.transactions.get({ hash })));
             return transactions;
         }
-        // If persistence is configured, try to get from cache first
-        const filters = {
-            accountAddress: this.address,
-            ...options
-        };
-        const cachedTransactions = await this.persistenceManager.getTransactions(filters);
+        const cachedTransactions = await this.persistenceManager.getTransactions(this.address, params);
         return cachedTransactions;
     }
     /**

package/dist/types/PersistenceAdapter.d.ts

@@ -1,12 +1,6 @@
-import { Transaction } from '../structures';
+import { Address } from '@mentaproject/core/types';
+import { Transaction } from '../structures/Transaction';
 import { GetTransactionsParams } from './Account';
-export interface TransactionWithAccount extends Transaction {
-    accountAddress: string;
-    timestamp: number;
-}
-export interface GetPersistentTransactionsParams extends GetTransactionsParams {
-    accountAddress: string;
-}
 /**
  * @interface IPersistenceAdapter
  * @description Defines the contract for persistence layers, ensuring consistent data storage and retrieval operations.
@@ -23,9 +17,9 @@ export interface IPersistenceAdapter {
      * @method getTransactions
      * @description Retrieves a paginated list of transactions for a specific account based on provided filters.
      * @param {GetTransactionsFilters} filters - An object containing filters for retrieving transactions, such as account address, block range, pagination, and sort order.
-     * @returns {Promise<TransactionWithAccount[]>} A Promise that resolves with an array of transactions matching the filters.
+     * @returns {Promise<Transaction[]>} A Promise that resolves with an array of transactions matching the filters.
      */
-    getTransactions(filters: GetPersistentTransactionsParams): Promise<TransactionWithAccount[]>;
+    getTransactions(address: Address, params: GetTransactionsParams): Promise<Transaction[]>;
     /**
      * @method getLastSyncedBlock
      * @description Retrieves the last synced block number for a given account. This is used to track the synchronization progress of an account's transactions.

package/dist/types/PersistenceAdapter.js

@@ -1,2 +1 @@
-;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "High level EVM library used into the Menta App to facilitate Blockchain interactions. ",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/tests/structures/Account.test.ts

@@ -124,7 +124,7 @@ describe('Account', () => {
       (mockPersistenceManager.getTransactions as jest.Mock).mockResolvedValue(mockTransactions);
 
       const result = await account.transactions({});
-      expect(mockPersistenceManager.getTransactions).toHaveBeenCalledWith({ accountAddress: mockAddress });
+      expect(mockPersistenceManager.getTransactions).toHaveBeenCalledWith(mockAddress, {});
       expect(result).toEqual(mockTransactions);
     });
 
@@ -150,8 +150,8 @@ describe('Account', () => {
 
   describe('syncTransactions', () => {
     it('should call syncTransactions on the persistence manager', async () => {
-      await account.syncTransactions();
-      expect(mockPersistenceManager.syncTransactions).toHaveBeenCalledWith(account);
+      await account.syncTransactions(1n);
+      expect(mockPersistenceManager.syncTransactions).toHaveBeenCalledWith(account, 1n);
     });
 
     it('should throw an error if persistence manager is not configured', async () => {

package/dist/structures/ContractAccount.d.ts

@@ -1,6 +0,0 @@
-import { Address, CoreClient } from "src/types";
-import { Account } from "./Account";
-export declare class ContractAccount extends Account {
-    constructor(rpcClient: CoreClient, address: Address);
-    getType(): Promise<any>;
-}

package/dist/structures/ContractAccount.js

@@ -1,12 +0,0 @@
-import { Account } from "./Account";
-import { getContractType } from "@mentaproject/contracts";
-export class ContractAccount extends Account {
-    constructor(rpcClient, address) {
-        super(rpcClient, address);
-    }
-    ;
-    async getType() {
-        return await getContractType(this.rpcClient, this.address);
-    }
-}
-;

package/dist/structures/TransactionReceipt.js

@@ -1 +0,0 @@
-"use strict";

package/dist/structures/minimal.d.ts

@@ -1,20 +0,0 @@
-declare class BaseService {
-    id: string;
-    rpcClient: any;
-    address: string;
-    constructor(id: string, rpcClient: any, address: string);
-    protected fetchCode(): Promise<string | null>;
-}
-type ContractService = BaseService & {
-    isContractMarker: true;
-    getContractDetails: () => string;
-};
-declare class AccountVerifier extends BaseService {
-    isContractMarker?: true;
-    getContractDetails?: () => string;
-    /**
-     * Vérifie si le compte est un contrat.
-     */
-    isContractAccount(): Promise<this is ContractService>;
-    processAccount(): Promise<void>;
-}

package/dist/structures/minimal.js

@@ -1,62 +0,0 @@
-"use strict";
-// test-guard.ts
-// Simulez vos dépendances externes si nécessaire pour ce test
-// Par exemple :
-// declare function getCode(rpcClient: any, params: { address: string }): Promise<string | null | undefined>;
-// interface RpcClientType {}
-// Définition de la classe de base
-class BaseService {
-    constructor(id, rpcClient, address) {
-        this.id = id;
-        this.rpcClient = rpcClient;
-        this.address = address;
-    }
-    // Méthode pour simuler l'appel externe
-    async fetchCode() {
-        // Remplacez par votre vrai appel à getCode si possible pour le test,
-        // ou utilisez ce mock :
-        console.log(`Workspaceing code for ${this.address} using client ${this.rpcClient}`);
-        if (this.address === "contract_address") {
-            return "0x12345"; // code de contrat valide
-        }
-        return "0x"; // pas de code ou compte externe
-    }
-}
-// Classe contenant le type guard asynchrone
-class AccountVerifier extends BaseService {
-    /**
-     * Vérifie si le compte est un contrat.
-     */
-    async isContractAccount() {
-        const code = await this.fetchCode(); // Utilise la méthode de la classe (ou de la base)
-        if (code && typeof code === 'string' && code !== '0x' && code.length > 2) {
-            // Logique pour rendre 'this' conforme à ContractService
-            this.isContractMarker = true;
-            this.getContractDetails = () => `Details for contract ${this.address}`;
-            return true;
-        }
-        else {
-            delete this.isContractMarker;
-            delete this.getContractDetails;
-            return false;
-        }
-    }
-    async processAccount() {
-        if (await this.isContractAccount()) {
-            // Ici, 'this' est affiné en ContractService
-            console.log(`Account ${this.id} (${this.address}) is a contract.`);
-            console.log(this.getContractDetails());
-            console.log(`Marker: ${this.isContractMarker}`);
-        }
-        else {
-            // Ici, 'this' est AccountVerifier (ou BaseService)
-            console.log(`Account ${this.id} (${this.address}) is not a contract.`);
-        }
-    }
-}
-// Test
-// const mockRpcClient: RpcClientType = {}; // Votre client RPC
-// const verifier1 = new AccountVerifier("service1", mockRpcClient, "contract_address");
-// const verifier2 = new AccountVerifier("service2", mockRpcClient, "eoa_address");
-// verifier1.processAccount();
-// verifier2.processAccount();

package/dist/types/IPersistenceAdapter.d.ts

@@ -1,44 +0,0 @@
-import { Transaction } from 'src/structures';
-import { GetTransactionsOptions } from './Account';
-export interface TransactionWithAccount extends Transaction {
-    accountAddress: string;
-    timestamp: number;
-}
-export interface GetTransactionsFilters extends GetTransactionsOptions {
-    accountAddress: string;
-}
-/**
- * @interface IPersistenceAdapter
- * @description Defines the contract for persistence layers, ensuring consistent data storage and retrieval operations.
- */
-export interface IPersistenceAdapter {
-    /**
-     * @method upsertTransactions
-     * @description Inserts or updates a list of transactions. The operation must be atomic.
-     * @param {TransactionWithAccount[]} transactions - An array of transaction data, including associated account addresses and timestamps.
-     * @returns {Promise<void>} A Promise that resolves when the transactions have been successfully inserted or updated.
-     */
-    upsertTransactions(transactions: TransactionWithAccount[]): Promise<void>;
-    /**
-     * @method getTransactions
-     * @description Retrieves a paginated list of transactions for a specific account based on provided filters.
-     * @param {GetTransactionsFilters} filters - An object containing filters for retrieving transactions, such as account address, block range, pagination, and sort order.
-     * @returns {Promise<TransactionWithAccount[]>} A Promise that resolves with an array of transactions matching the filters.
-     */
-    getTransactions(filters: GetTransactionsFilters): Promise<TransactionWithAccount[]>;
-    /**
-     * @method getLastSyncedBlock
-     * @description Retrieves the last synced block number for a given account. This is used to track the synchronization progress of an account's transactions.
-     * @param {string} accountAddress - The address of the account for which to retrieve the last synced block number.
-     * @returns {Promise<number | null>} A Promise that resolves with the last synced block number, or `null` if no block has been synced for the account.
-     */
-    getLastSyncedBlock(accountAddress: string): Promise<bigint | null>;
-    /**
-     * @method setLastSyncedBlock
-     * @description Saves the last synced block number for a given account. This updates the synchronization progress for an account.
-     * @param {string} accountAddress - The address of the account for which to save the last synced block number.
-     * @param {number} blockNumber - The block number to save as the last synced block for the account.
-     * @returns {Promise<void>} A Promise that resolves when the last synced block number has been successfully saved.
-     */
-    setLastSyncedBlock(accountAddress: string, blockNumber: number): Promise<void>;
-}

package/dist/types/IPersistenceAdapter.js

@@ -1,2 +0,0 @@
-;
-export {};

package/dist/types/TransactionReceipt.d.ts

@@ -1,9 +0,0 @@
-import { GetTransactionReceiptReturnType } from "@mentaproject/core/types";
-export interface IDecodedLog<T extends {
-    [key: string]: any;
-} = {}> {
-    eventName: string;
-    args: T;
-}
-export interface ITransactionReceiptData extends GetTransactionReceiptReturnType {
-}

package/dist/types/TransactionReceipt.js

@@ -1,3 +0,0 @@
-;
-;
-export {};

package/dist/utils/Cache.d.ts

@@ -1,13 +0,0 @@
-import { ICache, ICacheConfig } from '../types/Cache';
-export declare class Cache implements ICache {
-    private cache;
-    config: ICacheConfig;
-    private blockNumber;
-    constructor(blockNumber: bigint, options?: Partial<ICacheConfig>);
-    protected isExpired(expiry: bigint): boolean;
-    setBlockNumber(blockNumber: bigint): void;
-    set<T>(key: string, value: T, ttl?: number): Promise<void>;
-    get<T>(key: string): Promise<T | undefined>;
-    has(key: string): Promise<boolean>;
-    private evict;
-}

package/dist/utils/Cache.js

@@ -1,57 +0,0 @@
-export class Cache {
-    constructor(blockNumber, options) {
-        this.cache = new Map();
-        this.blockNumber = blockNumber;
-        this.config = {
-            maxSize: 500,
-            defaultTtl: 1,
-            ttlPolicies: options?.ttlPolicies || {},
-            ...options,
-        };
-    }
-    ;
-    isExpired(expiry) {
-        return this.blockNumber > expiry;
-    }
-    ;
-    setBlockNumber(blockNumber) {
-        this.blockNumber = blockNumber;
-    }
-    async set(key, value, ttl = this.config.defaultTtl) {
-        if (this.cache.has(key)) {
-            this.cache.delete(key);
-        }
-        if (this.cache.size >= this.config.maxSize)
-            this.evict();
-        const expiry = this.blockNumber + BigInt(ttl);
-        this.cache.set(key, { value, expiry });
-    }
-    async get(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return undefined;
-        if (this.isExpired(entry.expiry)) {
-            this.cache.delete(key);
-            return undefined;
-        }
-        this.cache.delete(key);
-        this.cache.set(key, entry);
-        return entry.value;
-    }
-    async has(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return false;
-        if (this.isExpired(entry.expiry)) {
-            this.cache.delete(key);
-            return false;
-        }
-        return true;
-    }
-    evict() {
-        const oldestKey = this.cache.keys().next().value;
-        if (!oldestKey)
-            return;
-        this.cache.delete(oldestKey);
-    }
-}

package/dist/utils/IsContractCompliantWithAbi.d.ts

@@ -1,15 +0,0 @@
-import { Abi, Address } from 'viem';
-import { CoreClient } from '@mentaproject/core/types';
-/**
- * Vérifie de manière plus "absolue" si un contrat est conforme à une ABI
- * en utilisant ERC-165 (if applicable) et en simulant les appels de fonctions.
- *
- * @param client - Le client viem connecté au réseau.
- * @param contractAddress - L'adresse du contrat à vérifier.
- * @param contractAbi - L'ABI complète du contrat.
- * @param options - Options pour la vérification : { erc165InterfaceId?: any } // Utilisation de 'any' pour contourner l'erreur de type bytes4
- * @returns True si le contrat semble implémenter toutes les fonctions de l'ABI (Selon les checks), False sinon.
- */
-export declare function isContractCompliantWithAbi(client: CoreClient, contractAddress: Address, contractAbi: Abi, options?: {
-    erc165InterfaceId?: any;
-}): Promise<boolean>;

package/dist/utils/IsContractCompliantWithAbi.js

@@ -1,280 +0,0 @@
-import { parseAbi, } from 'viem';
-import { getCode, readContract, simulateContract } from '@mentaproject/core/actions'; // Importer les actions depuis viem/actions
-// import type { bytes4, AbiParameter, AbiParameterWithComponents } from 'viem'; // Impossible d'importer ces types directement dans cette version de viem
-const zeroAddress = '0xB21fD8AF36937Cf0ac1B84368E756C580BFdA342';
-// --- Configuration du client viem (remplacez par votre configuration) ---
-// const client = createPublicClient({
-//   chain: mainnet, // ou une autre chaîne
-//   transport: http() // ou autre transport
-// });
-// ---------------------------------------------------------------------
-// Helper pour générer des paramètres factices basés sur le type ABI
-function generateDummyArgs(inputs) {
-    return inputs.map(input => {
-        // Gérer les types simples
-        switch (input.type) {
-            case 'address':
-                return zeroAddress; // Adresse nulle
-            case 'uint8':
-            case 'uint16':
-            case 'uint24':
-            case 'uint32':
-            case 'uint40':
-            case 'uint48':
-            case 'uint56':
-            case 'uint64':
-            case 'uint72':
-            case 'uint80':
-            case 'uint88':
-            case 'uint96':
-            case 'uint104':
-            case 'uint112':
-            case 'uint120':
-            case 'uint128':
-            case 'uint136':
-            case 'uint144':
-            case 'uint152':
-            case 'uint160':
-            case 'uint168':
-            case 'uint176':
-            case 'uint184':
-            case 'uint192':
-            case 'uint200':
-            case 'uint208':
-            case 'uint216':
-            case 'uint224':
-            case 'uint232':
-            case 'uint240':
-            case 'uint248':
-            case 'uint256':
-            case 'int8':
-            case 'int16':
-            case 'int24':
-            case 'int32':
-            case 'int40':
-            case 'int48':
-            case 'int56':
-            case 'int64':
-            case 'int72':
-            case 'int80':
-            case 'int88':
-            case 'int96':
-            case 'int104':
-            case 'int112':
-            case 'int120':
-            case 'int128':
-            case 'int136':
-            case 'int144':
-            case 'int152':
-            case 'int160':
-            case 'int168':
-            case 'int176':
-            case 'int184':
-            case 'int192':
-            case 'int200':
-            case 'int208':
-            case 'int216':
-            case 'int224':
-            case 'int232':
-            case 'int240':
-            case 'int248':
-            case 'int256':
-                return 1n;
-            case 'bool':
-                return false; // Faux pour les booléens
-            case 'bytes':
-            case 'string':
-                return ''; // Chaîne vide pour les chaînes/bytes dynamiques
-            default:
-                // Gérer les bytes fixes (bytes1 à bytes32)
-                if (input.type.startsWith('bytes') && input.type !== 'bytes') {
-                    const size = parseInt(input.type.substring(5), 10);
-                    if (!isNaN(size) && size >= 1 && size <= 32) {
-                        return '0x' + '00'.repeat(size); // Zero-filled hex string
-                    }
-                }
-                // Gérer les tableaux et les tuples (récursion)
-                if (input.type.endsWith('[]')) { // Tableau dynamique
-                    // Retourne un tableau vide pour la simulation simple
-                    return [];
-                }
-                else if (input.type.endsWith(']')) { // Tableau fixe (ex: address[5])
-                    const baseType = input.type.substring(0, input.type.indexOf('['));
-                    const length = parseInt(input.type.substring(input.type.indexOf('[') + 1, input.type.indexOf(']')), 10);
-                    if (!isNaN(length)) {
-                        // On pourrait créer un tableau de dummyArgs du baseType de taille 'length'
-                        // Pour une simplicité minimale ici, on pourrait aussi retourner un tableau vide,
-                        // mais c'est moins précis. Faisons un tableau de dummy du bon type.
-                        // Correction: Pass only the base type, not components/indexed from the array type
-                        const dummyValue = generateDummyArgs([{ name: '', type: baseType }])[0];
-                        // Check if dummyValue generation failed for the base type
-                        if (dummyValue === undefined) {
-                            return undefined; // Propagate undefined if base type failed
-                        }
-                        return Array(length).fill(dummyValue);
-                    }
-                }
-                else if (input.type === 'tuple' && input.components) { // Tuple (struct) - Utilisation de 'any' pour contourner l'erreur de type AbiParameterWithComponents
-                    // Générer des dummy args pour chaque composant du tuple
-                    const componentArgs = generateDummyArgs(input.components); // Utilisation de 'any'
-                    // Check if any component arg generation failed
-                    if (componentArgs.some(arg => arg === undefined)) {
-                        return undefined; // Propagate undefined if any component failed
-                    }
-                    // Les tuples sont souvent attendus comme des objets ou des tableaux selon l'impl
-                    // Retournons un objet avec les noms des composants si possible
-                    return componentArgs.reduce((obj, arg, index) => {
-                        // Correction: Access components from the casted input
-                        obj[input.components[index].name || index] = arg; // Utilise le nom du composant ou l'index - Utilisation de 'any'
-                        return obj;
-                    }, {});
-                }
-                // On retourne undefined, cela pourrait causer l'échec de la simulation
-                return undefined; // Indique qu'on n'a pas pu générer le paramètre
-        }
-    });
-}
-/**
- * Vérifie de manière plus "absolue" si un contrat est conforme à une ABI
- * en utilisant ERC-165 (if applicable) et en simulant les appels de fonctions.
- *
- * @param client - Le client viem connecté au réseau.
- * @param contractAddress - L'adresse du contrat à vérifier.
- * @param contractAbi - L'ABI complète du contrat.
- * @param options - Options pour la vérification : { erc165InterfaceId?: any } // Utilisation de 'any' pour contourner l'erreur de type bytes4
- * @returns True si le contrat semble implémenter toutes les fonctions de l'ABI (Selon les checks), False sinon.
- */
-export async function isContractCompliantWithAbi(client, contractAddress, contractAbi, options // Utilisation de 'any'
-) {
-    // Check 1: Bytecode Existence
-    try {
-        const bytecode = await getCode(client, { address: contractAddress });
-        if (!bytecode || bytecode === '0x') {
-            return false; // No code at address
-        }
-    }
-    catch (e) {
-        // Handle potential errors during RPC call (e.g., network)
-        return false;
-    }
-    // Check 2: ERC-165 Support (if interfaceId and supportsInterface are in ABI)
-    const erc165InterfaceId = options?.erc165InterfaceId;
-    const supportsInterfaceAbiItem = contractAbi.find((item) => item.type === 'function' &&
-        item.name === 'supportsInterface' &&
-        item.inputs.length === 1 &&
-        item.inputs[0].type === 'bytes4' &&
-        (item.stateMutability === 'view' || item.stateMutability === 'pure'));
-    if (erc165InterfaceId && supportsInterfaceAbiItem) {
-        try {
-            const erc165AbiMinimal = parseAbi(['function supportsInterface(bytes4 interfaceId) view returns (bool)']);
-            // Check if it supports ERC-165 itself first
-            const supports165Self = await readContract(client, {
-                address: contractAddress,
-                abi: erc165AbiMinimal, // Use minimal ABI for supportsInterface itself
-                functionName: 'supportsInterface',
-                args: ['0x01ffc9a7'] // ERC-165 interface ID
-            });
-            if (!supports165Self) {
-                // Contract has supportsInterface but doesn't claim ERC-165 support
-                return false;
-            }
-            // Now check if it supports the target interfaceId
-            const supportsTargetInterface = await readContract(client, {
-                address: contractAddress,
-                abi: erc165AbiMinimal, // Use minimal ABI for supportsInterface
-                functionName: 'supportsInterface',
-                args: [erc165InterfaceId] // The target interface ID
-            });
-            if (!supportsTargetInterface) {
-                // It supports ERC-165 but not the specific target interface
-                return false;
-            }
-            // ERC-165 check passed for the target interface.
-        }
-        catch (e) {
-            // If calling supportsInterface failed (function not found, revert, etc.)
-            // Treat as not compliant with the ERC-165 check.
-            return false;
-        }
-    }
-    // Check 3: Simulate or Read all functions, distinguishing errors
-    const functions = contractAbi.filter((item) => item.type === 'function');
-    if (functions.length === 0) {
-        // If no functions in ABI, and bytecode exists + ERC165 passed (if applicable), consider compliant
-        // with an ABI that defines no functions to check.
-        return true;
-    }
-    // Track if any function was *not found* or had a non-revert error
-    let hasFunctionNotFoundError = false;
-    let hasOtherUnexpectedError = false;
-    for (const func of functions) {
-        // Skip supportsInterface if we already checked it via ERC-165 logic
-        if (func.name === 'supportsInterface' && func.inputs.length === 1 && func.inputs[0].type === 'bytes4') {
-            if (erc165InterfaceId && supportsInterfaceAbiItem)
-                continue; // Already checked as part of ERC-165 flow
-            // If not part of ERC-165 flow, treat as a regular function to check below
-        }
-        try {
-            const dummyArgs = generateDummyArgs(func.inputs);
-            // If generateDummyArgs returned undefined for any arg, we cannot simulate this function reliably
-            if (dummyArgs.some(arg => arg === undefined)) {
-                // Cannot generate valid inputs -> Cannot test this function -> Not compliant with ABI requiring complex inputs
-                hasOtherUnexpectedError = true;
-                // We could break here, but checking other functions might still be useful.
-                continue; // Move to the next function
-            }
-            const commonCallArgs = {
-                address: contractAddress,
-                abi: contractAbi,
-                functionName: func.name,
-                args: dummyArgs,
-            };
-            if (func.stateMutability === 'view' || func.stateMutability === 'pure') {
-                // Simulate view/pure functions
-                await readContract(client, commonCallArgs); // Use any for args typing simplification
-            }
-            else if (func.stateMutability === 'nonpayable' || func.stateMutability === 'payable') {
-                // Simulate write functions
-                await simulateContract(client, {
-                    ...commonCallArgs, // Use any for args typing simplification
-                    account: zeroAddress, // Use a dummy account for simulation
-                    // Add value for payable functions if needed for simulation logic, e.g.:
-                    // value: func.stateMutability === 'payable' ? 1n : 0n
-                });
-            }
-            else {
-                // Unknown state mutability - cannot verify this function type
-                hasOtherUnexpectedError = true;
-                continue; // Move to the next function
-            }
-        }
-        catch (e) {
-            const error = e;
-            if (error.name === "AbiFunctionNotFoundError") {
-                // Function not found in ABI
-                hasFunctionNotFoundError = true;
-                console.warn(`Warning: Function ${func.name} not found in ABI`);
-                continue; // Move to the next function
-            }
-            if (error.name === "ContractFunctionExecutionError") {
-                // Function reverted, but not a failure of the function itself
-                // This is a valid state/logic check, but not a failure of the function
-                console.warn(`Warning: Function ${func.name} reverted: ${error.name}`);
-                continue; // Move to the next function
-            }
-        }
-    }
-    // Final Decision:
-    // Compliant only if:
-    // 1. Bytecode exists
-    // 2. ERC-165 check passed (if requested)
-    // 3. NO ContractFunctionNotFoundError occurred for ANY function.
-    // 4. NO other unexpected errors occurred (like generation of dummy args failing, or network issues during checks).
-    // Revert errors (ContractFunctionRevertedError) are ACCEPTED, implying the function exists but failed state/logic checks with dummy args.
-    if (hasFunctionNotFoundError || hasOtherUnexpectedError) {
-        return false; // Found a missing function or hit an unexpected issue
-    }
-    // If we went through all functions without hitting ContractFunctionNotFoundError or other unexpected errors,
-    // and Bytecode & ERC165 (if applicable) checks passed.
-    return true;
-}

package/dist/utils/abis/ERC20.d.ts

@@ -1,168 +0,0 @@
-export declare const ERC20: readonly [{
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "name";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: false;
-    readonly inputs: readonly [{
-        readonly name: "_spender";
-        readonly type: "address";
-    }, {
-        readonly name: "_value";
-        readonly type: "uint256";
-    }];
-    readonly name: "approve";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "totalSupply";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: false;
-    readonly inputs: readonly [{
-        readonly name: "_from";
-        readonly type: "address";
-    }, {
-        readonly name: "_to";
-        readonly type: "address";
-    }, {
-        readonly name: "_value";
-        readonly type: "uint256";
-    }];
-    readonly name: "transferFrom";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "decimals";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint8";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [{
-        readonly name: "_owner";
-        readonly type: "address";
-    }];
-    readonly name: "balanceOf";
-    readonly outputs: readonly [{
-        readonly name: "balance";
-        readonly type: "uint256";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [];
-    readonly name: "symbol";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly constant: false;
-    readonly inputs: readonly [{
-        readonly name: "_to";
-        readonly type: "address";
-    }, {
-        readonly name: "_value";
-        readonly type: "uint256";
-    }];
-    readonly name: "transfer";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly constant: true;
-    readonly inputs: readonly [{
-        readonly name: "_owner";
-        readonly type: "address";
-    }, {
-        readonly name: "_spender";
-        readonly type: "address";
-    }];
-    readonly name: "allowance";
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly payable: false;
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly payable: true;
-    readonly stateMutability: "payable";
-    readonly type: "fallback";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly name: "owner";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly name: "spender";
-        readonly type: "address";
-    }, {
-        readonly indexed: false;
-        readonly name: "value";
-        readonly type: "uint256";
-    }];
-    readonly name: "Approval";
-    readonly type: "event";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly indexed: false;
-        readonly name: "value";
-        readonly type: "uint256";
-    }];
-    readonly name: "Transfer";
-    readonly type: "event";
-}];

package/dist/utils/abis/ERC20.js

@@ -1,222 +0,0 @@
-export const ERC20 = [
-    {
-        "constant": true,
-        "inputs": [],
-        "name": "name",
-        "outputs": [
-            {
-                "name": "",
-                "type": "string"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "constant": false,
-        "inputs": [
-            {
-                "name": "_spender",
-                "type": "address"
-            },
-            {
-                "name": "_value",
-                "type": "uint256"
-            }
-        ],
-        "name": "approve",
-        "outputs": [
-            {
-                "name": "",
-                "type": "bool"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "constant": true,
-        "inputs": [],
-        "name": "totalSupply",
-        "outputs": [
-            {
-                "name": "",
-                "type": "uint256"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "constant": false,
-        "inputs": [
-            {
-                "name": "_from",
-                "type": "address"
-            },
-            {
-                "name": "_to",
-                "type": "address"
-            },
-            {
-                "name": "_value",
-                "type": "uint256"
-            }
-        ],
-        "name": "transferFrom",
-        "outputs": [
-            {
-                "name": "",
-                "type": "bool"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "constant": true,
-        "inputs": [],
-        "name": "decimals",
-        "outputs": [
-            {
-                "name": "",
-                "type": "uint8"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "constant": true,
-        "inputs": [
-            {
-                "name": "_owner",
-                "type": "address"
-            }
-        ],
-        "name": "balanceOf",
-        "outputs": [
-            {
-                "name": "balance",
-                "type": "uint256"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "constant": true,
-        "inputs": [],
-        "name": "symbol",
-        "outputs": [
-            {
-                "name": "",
-                "type": "string"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "constant": false,
-        "inputs": [
-            {
-                "name": "_to",
-                "type": "address"
-            },
-            {
-                "name": "_value",
-                "type": "uint256"
-            }
-        ],
-        "name": "transfer",
-        "outputs": [
-            {
-                "name": "",
-                "type": "bool"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "nonpayable",
-        "type": "function"
-    },
-    {
-        "constant": true,
-        "inputs": [
-            {
-                "name": "_owner",
-                "type": "address"
-            },
-            {
-                "name": "_spender",
-                "type": "address"
-            }
-        ],
-        "name": "allowance",
-        "outputs": [
-            {
-                "name": "",
-                "type": "uint256"
-            }
-        ],
-        "payable": false,
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "payable": true,
-        "stateMutability": "payable",
-        "type": "fallback"
-    },
-    {
-        "anonymous": false,
-        "inputs": [
-            {
-                "indexed": true,
-                "name": "owner",
-                "type": "address"
-            },
-            {
-                "indexed": true,
-                "name": "spender",
-                "type": "address"
-            },
-            {
-                "indexed": false,
-                "name": "value",
-                "type": "uint256"
-            }
-        ],
-        "name": "Approval",
-        "type": "event"
-    },
-    {
-        "anonymous": false,
-        "inputs": [
-            {
-                "indexed": true,
-                "name": "from",
-                "type": "address"
-            },
-            {
-                "indexed": true,
-                "name": "to",
-                "type": "address"
-            },
-            {
-                "indexed": false,
-                "name": "value",
-                "type": "uint256"
-            }
-        ],
-        "name": "Transfer",
-        "type": "event"
-    }
-];

package/dist/utils/abis/index.d.ts

@@ -1 +0,0 @@
-export * from './ERC20';

package/dist/utils/abis/index.js

@@ -1 +0,0 @@
-export * from './ERC20';