@mentaproject/client 0.0.3

package/dist/utils/IsContractCompliantWithAbi.js

@@ -0,0 +1,280 @@
+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

@@ -0,0 +1,168 @@
+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

@@ -0,0 +1,222 @@
+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

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

package/dist/utils/abis/index.js

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