@mentaproject/client 0.1.12 → 0.1.14

package/dist/index.d.ts

@@ -4,10 +4,6 @@
  * It includes managers for accounts, blocks, contracts, persistence, and transactions,
  * as well as core data structures and utility types.
  */
-/**
- * Re-exports all types defined within the library.
- */
-export * from './types';
 /**
  * Re-exports all core data structures like MentaClient, Account, Block, and Transaction.
  */

package/dist/index.js

@@ -4,10 +4,6 @@
  * It includes managers for accounts, blocks, contracts, persistence, and transactions,
  * as well as core data structures and utility types.
  */
-/**
- * Re-exports all types defined within the library.
- */
-export * from './types';
 /**
  * Re-exports all core data structures like MentaClient, Account, Block, and Transaction.
  */

package/dist/managers/TransactionManager.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module TransactionManager
  */
-import { GetTransactionParameters, RawTransaction, SendTransactionParameters } from "@mentaproject/core/types";
+import { GetTransactionParameters, Transaction as RawTransaction, SendTransactionParameters } from "@mentaproject/core/types";
 import { Transaction } from "../structures/Transaction";
 import { MentaClient } from "../structures";
 /**

package/dist/structures/Account.d.ts

@@ -1,13 +1,13 @@
 import type { Address, Hash } from "@mentaproject/core/types";
 import { Transaction } from "./Transaction";
-import { FetchTransactionParams, GetTransactionsParams } from "../types/Account";
+import { AccountData, FetchTransactionParams, GetTransactionsParams, JSONAccount } from "../types/Account";
 import { PersistenceManager } from "../managers/PersistenceManager";
 import { MentaClient } from "./MentaClient";
 /**
  * Represents a blockchain account with functionalities to interact with the Menta blockchain.
  * This class provides methods to query account information, send transactions, and manage account-related data.
  */
-export declare class Account {
+export declare class Account implements AccountData {
     client: MentaClient;
     /**
      * The blockchain address of the account.
@@ -92,7 +92,7 @@ export declare class Account {
      * @param {number} [depth=1] The depth to which nested objects should be converted. A depth of 1 means only direct properties are included.
      * @returns {Promise<object>} A promise that resolves to the JSON representation of the account.
      */
-    toJSON(depth?: number): Promise<any>;
+    toJSON(depth?: number): Promise<JSONAccount>;
     /**
      * Fetches transactions from the account using a block range exploration with trace_filter calls.
      *

package/dist/structures/Block.d.ts

@@ -1,13 +1,13 @@
 import { Hash, Hex, Withdrawal } from "@mentaproject/core/types";
 import { Account } from "./Account";
 import { Transaction } from "./Transaction";
-import { IBlockData } from "../types/Block";
+import { BlockData, JSONBlock } from "../types/Block";
 import { MentaClient } from "./MentaClient";
 /**
  * @description Represents a blockchain block with its properties and methods.
  * This class provides a structured way to access block-related data and interact with the blockchain client.
  */
-export declare class Block implements Omit<IBlockData, "miner" | "transactions"> {
+export declare class Block implements Omit<BlockData, "miner" | "transactions"> {
     client: MentaClient;
     /**
      * @description The base fee per gas for the block.
@@ -123,7 +123,7 @@ export declare class Block implements Omit<IBlockData, "miner" | "transactions">
      * @param data The raw block data conforming to IBlockData.
      * @param includeTransactions Whether to include full transaction objects. Defaults to false.
      */
-    constructor(client: MentaClient, data: IBlockData);
+    constructor(client: MentaClient, data: BlockData);
     protected includeTransactions(): this is this & {
         transactions: Transaction[];
     };
@@ -134,5 +134,5 @@ export declare class Block implements Omit<IBlockData, "miner" | "transactions">
      * @param depth The depth of the conversion. Defaults to 1.
      * @returns A promise that resolves to the JSON representation of the block.
      */
-    toJSON(depth?: number): Promise<any>;
+    toJSON(depth?: number): Promise<JSONBlock>;
 }

package/dist/structures/Transaction.d.ts

@@ -1,7 +1,8 @@
-import { AccessList, Hash, Hex, RawTransaction, WaitForTransactionReceiptReturnType } from '@mentaproject/core/types';
+import { AccessList, Hash, Hex, Transaction as RawTransaction, WaitForTransactionReceiptReturnType } from '@mentaproject/core/types';
 import { Account } from './Account';
 import { Block } from './Block';
 import { MentaClient } from './MentaClient';
+import { JSONTransaction, TransactionCall } from '../types';
 /**
  * Represents a blockchain transaction with its properties and methods.
  *
@@ -105,16 +106,9 @@ export declare class Transaction implements Omit<RawTransaction, "from" | "to">
     /**
      * Retrieves the internal calls made by this transaction.
      * @description Fetches and processes the transaction traces to extract internal call details.
-     * @returns {Promise<Array<{ from: Account; to: Account; value: bigint; input: Hex; gas: bigint; callType: string; }>>} A promise that resolves to an array of call objects, each representing an internal call with sender, recipient, value, input data, gas used, and call type.
+     * @returns {Promise<TransactionCall[] | undefined>} A promise that resolves to an array of call objects, each representing an internal call with sender, recipient, value, input data, gas used, and call type.
      */
-    calls(): Promise<{
-        from: Account;
-        to: Account;
-        value: bigint;
-        input: Hex;
-        gas: bigint;
-        callType: string | undefined;
-    }[]>;
+    calls(): Promise<TransactionCall[] | undefined>;
     /**
      * Waits for the transaction receipt to be available.
      * @description Asynchronously waits for the transaction to be confirmed on the blockchain and its receipt to be available.
@@ -127,7 +121,7 @@ export declare class Transaction implements Omit<RawTransaction, "from" | "to">
      * @description Fetches the transaction receipt for the current transaction hash.
      * @returns {Promise<WaitForTransactionReceiptReturnType>} A promise that resolves to the transaction receipt.
      */
-    receipt(): Promise<WaitForTransactionReceiptReturnType>;
+    receipt(): Promise<WaitForTransactionReceiptReturnType | undefined>;
     /**
      * Retrieves the block containing this transaction.
      * @description Fetches the block data using the transaction's block hash and returns a Block instance.
@@ -140,5 +134,5 @@ export declare class Transaction implements Omit<RawTransaction, "from" | "to">
      * @param {number} [depth=1] The depth of the conversion. Controls how deeply nested objects are serialized.
      * @returns {Promise<object>} A promise that resolves to the JSON representation of the transaction.
      */
-    toJSON(depth?: number): Promise<any>;
+    toJSON(depth?: number): Promise<JSONTransaction>;
 }

package/dist/structures/Transaction.js

@@ -1,5 +1,6 @@
 import { getBlock, getTransactionReceipt, traceTransaction, waitForTransactionReceipt } from '@mentaproject/core/actions';
 import { hexToBigInt } from '@mentaproject/core/utils';
+import { TransactionReceiptNotFoundError } from 'viem';
 import { Account } from './Account';
 import { Block } from './Block';
 import { toJSON } from '../utils/toJSON';
@@ -45,10 +46,12 @@ export class Transaction {
     /**
      * Retrieves the internal calls made by this transaction.
      * @description Fetches and processes the transaction traces to extract internal call details.
-     * @returns {Promise<Array<{ from: Account; to: Account; value: bigint; input: Hex; gas: bigint; callType: string; }>>} A promise that resolves to an array of call objects, each representing an internal call with sender, recipient, value, input data, gas used, and call type.
+     * @returns {Promise<TransactionCall[] | undefined>} A promise that resolves to an array of call objects, each representing an internal call with sender, recipient, value, input data, gas used, and call type.
      */
     async calls() {
         const traces = await traceTransaction(this.client.rpc, this.hash);
+        if (!traces)
+            return undefined;
         const calls = traces.filter(t => t.type === "call" && t.action !== undefined);
         return calls.map(c => ({
             from: new Account(this.client, c.action.from),
@@ -78,7 +81,14 @@ export class Transaction {
      * @returns {Promise<WaitForTransactionReceiptReturnType>} A promise that resolves to the transaction receipt.
      */
     async receipt() {
-        return await getTransactionReceipt(this.client.rpc, { hash: this.hash });
+        try {
+            return await getTransactionReceipt(this.client.rpc, { hash: this.hash });
+        }
+        catch (error) {
+            if (error instanceof TransactionReceiptNotFoundError) {
+                return undefined;
+            }
+        }
     }
     ;
     /**
@@ -105,6 +115,8 @@ export class Transaction {
                 receipt: this.receipt,
                 calls: async () => {
                     const calls = await this.calls();
+                    if (!calls)
+                        return undefined;
                     return Promise.all(calls.map(async (c) => await toJSON({ obj: c, depth: depth })));
                 }
             },

package/dist/structures/index.d.ts

@@ -3,4 +3,3 @@ export * from './Block';
 export * from './MentaClient';
 export * from './Transaction';
 export * from './Cache';
-export * from "@mentaproject/core/types";

package/dist/structures/index.js

@@ -3,4 +3,3 @@ export * from './Block';
 export * from './MentaClient';
 export * from './Transaction';
 export * from './Cache';
-export * from "@mentaproject/core/types";

package/dist/types/Account.d.ts

@@ -1,6 +1,7 @@
 /**
  * @module AccountTypes
  */
+import { Address } from "@mentaproject/core";
 /**
  * Defines the options for retrieving transactions associated with an account.
  */
@@ -26,3 +27,11 @@ export type FetchTransactionParams = {
      */
     limit?: number;
 };
+export type AccountData = {
+    address: Address;
+};
+export type JSONAccount = AccountData & {
+    isContract: boolean;
+    ETHBalance: string;
+    transactionCount: number;
+};

package/dist/types/Block.d.ts

@@ -1,9 +1,11 @@
-import { Address, Hash, Hex, RawTransaction, Withdrawal } from "@mentaproject/core/types";
+import { Address, Hash, Hex, Transaction as RawTransaction, Withdrawal } from "@mentaproject/core/types";
+import { JSONAccount } from "./Account";
+import { Transaction } from "../structures";
 /**
- * @interface IBlockData
+ * @interface BlockData
  * Represents the raw data structure of a blockchain block.
  */
-export interface IBlockData {
+export type BlockData = {
     /** Base fee per gas */
     baseFeePerGas: bigint | null;
     /** Total used blob gas by all transactions in this block */
@@ -58,4 +60,8 @@ export interface IBlockData {
     withdrawals?: Withdrawal[];
     /** Root of the withdrawals trie for this block. */
     withdrawalsRoot?: Hex | null;
-}
+};
+export type JSONBlock = BlockData & {
+    miner: JSONAccount;
+    transactions?: Transaction[] | Hash[];
+};

package/dist/types/Block.js

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

package/dist/types/MentaClient.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module MentaClientTypes
  */
-import { CoreClientConfig } from "../structures";
+import { CoreClientConfig } from "@mentaproject/core/types";
 import { ICache } from "./Cache";
 import { watchBlockNumber, watchBlocks } from "@mentaproject/core/actions";
 import { IPersistenceAdapter } from "./PersistenceAdapter";

package/dist/types/Transaction.d.ts

@@ -1,6 +1,9 @@
 /**
  * @module TransactionTypes
  */
+import { Hex, TransactionReceipt, Transaction as RawTransaction } from "@mentaproject/core";
+import { Account } from "../structures";
+import { BlockData } from "./Block";
 /**
  * Defines the direction of a transaction relative to an account.
  * "in" for incoming transactions, "out" for outgoing transactions.
@@ -20,3 +23,16 @@ export interface IGetTransactionBlockParams {
      */
     includeTransactions?: boolean;
 }
+export type TransactionCall = {
+    from: Account;
+    to: Account;
+    value: bigint;
+    input: Hex;
+    gas: bigint;
+    callType: string;
+};
+export type JSONTransaction = RawTransaction & {
+    block: BlockData;
+    receipt: TransactionReceipt;
+    calls?: TransactionCall[];
+};

package/dist/utils/toJSON.js

@@ -52,7 +52,7 @@ export async function toJSON({ obj, depth = 0 }) {
     const promises = [];
     for (const key in obj) {
         // skip class related properties
-        if (key === "toJSON" || key === "constructor" || key === "rpcClient")
+        if (key === "toJSON" || key === "constructor" || key === "client")
             continue;
         const prop = obj[key];
         if (typeof prop === "function") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "High level EVM library used into the Menta App to facilitate Blockchain interactions. ",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -21,6 +21,7 @@
     "./package.json": "./package.json"
   },
   "scripts": {
+    "test:file": "tsx test.ts",
     "test": "jest",
     "build": "tsc --project tsconfig.json",
     "patch": "npm version patch && npm run build && npm publish --access public",
@@ -31,7 +32,7 @@
   "license": "ISC",
   "dependencies": {
     "@mentaproject/contracts": "^0.0.9",
-    "@mentaproject/core": "^0.4.1",
+    "@mentaproject/core": "^0.5.2",
     "@modelcontextprotocol/sdk": "^1.13.0",
     "@shazow/whatsabi": "^0.21.1"
   },

package/test.ts

@@ -4,6 +4,7 @@ import { privateKeyToAccount, generatePrivateKey } from "viem/accounts"
 import { mainnet } from "@mentaproject/core/chains";
 import { MemoryCache } from "./src/structures/Cache";
 import { watchBlockNumber, watchBlocks } from "@mentaproject/core/actions";
+import { writeFileSync } from "fs";
 
 const viemAccount = privateKeyToAccount(generatePrivateKey());
 
@@ -31,10 +32,8 @@ const client = new MentaClient({
 (async () => {
     console.log("Watching for new blocks and block numbers...");
 
-    watchBlockNumber(client.rpcClient, {
-        onBlockNumber: async (blockNumber) => {
-            console.log('New block number:', blockNumber);
-        },
-        pollingInterval: 1000,
-    });
+    const item = await client.transactions.get({ hash: "0x2ac872604f7ce5e132417b881bfa80a66836ca669c0720e8ce2cc40c9c92a696" });
+    const json = await item.toJSON(1);
+
+    writeFileSync("./test.json", JSON.stringify(json, null, 2));
 })();

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