@mentaproject/client 0.0.3 → 0.0.4

package/dist/structures/Account.d.ts

@@ -2,10 +2,10 @@ import type { Address, CoreClient } from "@mentaproject/core/types";
 import { Transaction } from "./Transaction";
 import { GetTransactionsReturnType } from "../types/Account";
 /**
- * Represents a user account with methods for interacting with the blockchain.
+ * Represents an account with methods for interacting with it.
  */
 export declare class Account {
-    protected rpcClient: CoreClient;
+    rpcClient: CoreClient;
     address: Address;
     /**
      * Creates an instance of Account.
@@ -13,6 +13,12 @@ export declare class Account {
      * @param address The blockchain address of the account.
      */
     constructor(rpcClient: CoreClient, address: Address);
+    /**
+         * If the account is a contract, returns a ContractAccount instance. Otherwise, returns undefined.
+         * @returns
+         */
+    isContract(): Promise<boolean>;
+    getContractType(): Promise<any>;
     /**
      * Sends native cryptocurrency (ETH) to the account.
      * @param amount The amount of ETH to send (in wei).

package/dist/structures/Account.js

@@ -1,8 +1,9 @@
-import { createBlockRangePager, getBalance, getBlockNumber, getTransaction, getTransactionCount, sendTransaction, traceFilter } from "@mentaproject/core/actions";
+import { createBlockRangePager, getBalance, getBlockNumber, getCode, getTransaction, getTransactionCount, sendTransaction, traceFilter } from "@mentaproject/core/actions";
 import { Transaction } from "./Transaction";
 import { toHex } from "@mentaproject/core/utils";
+import { getContractType } from "@mentaproject/contracts";
 /**
- * Represents a user account with methods for interacting with the blockchain.
+ * Represents an account with methods for interacting with it.
  */
 export class Account {
     /**
@@ -14,6 +15,21 @@ export class Account {
         this.rpcClient = rpcClient;
         this.address = address;
     }
+    /**
+         * If the account is a contract, returns a ContractAccount instance. Otherwise, returns undefined.
+         * @returns
+         */
+    async isContract() {
+        const code = await getCode(this.rpcClient, { address: this.address });
+        if (!code || code === "0x")
+            return false;
+        return true;
+    }
+    ;
+    async getContractType() {
+        return await getContractType(this.rpcClient, this.address);
+    }
+    ;
     /**
      * Sends native cryptocurrency (ETH) to the account.
      * @param amount The amount of ETH to send (in wei).
@@ -84,3 +100,4 @@ export class Account {
         }, onBlockRange);
     }
 }
+;

package/dist/structures/ContractAccount.d.ts

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

@@ -0,0 +1,12 @@
+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/Transaction.d.ts

@@ -24,6 +24,14 @@ export declare class Transaction implements Omit<ITransactionData, "from" | "to"
     from?: Account;
     to?: Account;
     constructor(rpcClient: CoreClient, data: ITransactionData);
+    getCalls(): Promise<{
+        from: Account;
+        to: Account;
+        value: bigint;
+        input: Hex;
+        gas: bigint;
+        callType: string | undefined;
+    }[]>;
     waitForReceipt(confirmations?: number): Promise<WaitForTransactionReceiptReturnType>;
     receipt(): Promise<WaitForTransactionReceiptReturnType>;
     block(): Promise<Block>;

package/dist/structures/Transaction.js

@@ -1,6 +1,7 @@
 import { Account } from './Account';
 import { Block } from './Block';
-import { getBlock, getTransactionReceipt, waitForTransactionReceipt } from '@mentaproject/core/actions';
+import { getBlock, getTransactionReceipt, traceTransaction, waitForTransactionReceipt } from '@mentaproject/core/actions';
+import { hexToBigInt } from '@mentaproject/core/utils';
 export class Transaction {
     constructor(rpcClient, data) {
         this.rpcClient = rpcClient;
@@ -25,6 +26,18 @@ export class Transaction {
         this.to = data.to ? new Account(this.rpcClient, data.to) : undefined;
     }
     ;
+    async getCalls() {
+        const traces = await traceTransaction(this.rpcClient, this.hash);
+        const calls = traces.filter(t => t.type === "call" && t.action !== undefined);
+        return calls.map(c => ({
+            from: new Account(this.rpcClient, c.action.from),
+            to: new Account(this.rpcClient, c.action.to),
+            value: hexToBigInt(c.action.value),
+            input: c.action.input,
+            gas: hexToBigInt(c.action.gas),
+            callType: c.action.callType,
+        }));
+    }
     async waitForReceipt(confirmations) {
         return await waitForTransactionReceipt(this.rpcClient, {
             hash: this.hash,

package/dist/structures/minimal.d.ts

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

@@ -0,0 +1,62 @@
+"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "High level EVM library used into the Menta App to facilitate Blockchain interactions. ",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -29,9 +29,9 @@
   "author": "@mentaproject",
   "license": "ISC",
   "dependencies": {
-    "@shazow/whatsabi": "^0.21.1",
-    "@mentaproject/contracts": "0.0.2",
-    "@mentaproject/core": "0.0.3"
+    "@mentaproject/contracts": "^0.0.8",
+    "@mentaproject/core": "^0.0.4",
+    "@shazow/whatsabi": "^0.21.1"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^28.0.3",

package/test.ts

@@ -1,11 +1,7 @@
-import { Address, erc20Abi, getAddress, http, toFunctionSelector, zeroAddress } from "viem";
+import { http } from "viem";
 import { MentaClient } from "./src";
 import { privateKeyToAccount, generatePrivateKey } from "viem/accounts"
 import { mainnet } from "@mentaproject/core/chains";
-import { getCode, getStorageAt } from "@mentaproject/core/actions";
-import { selectorsFromBytecode } from "@shazow/whatsabi";
-import { toFunctionSignature } from "viem"
-import { bytes32ToAddress } from "@mentaproject/core/utils";
 
 const viemAccount = privateKeyToAccount(generatePrivateKey());
 
@@ -16,45 +12,17 @@ const client = new MentaClient({
 });
 
 (async () => {
-    // const firstTx = await client.transactions.get({ hash: "0x1ac2418d94a069d3460b7dd52cfc251879da4948bb0df8362598b5595d28cbf1" });
-    // const receipt = await firstTx.receipt();
-
-    // const log = receipt.logs[0];
-
-    // if (!log) return;
-
-    // const decoded = decodeEventLog({
-    //     abi: erc20Abi,
-    //     data: receipt.logs[0].data,
-    //     topics: receipt.logs[0].topics,
-    // });
-
-    // console.log(decoded.args)
-
-    const erc20Signatures = erc20Abi.filter(item => item.type === "function").map(item => ({ signature:toFunctionSignature(item), selector: toFunctionSelector(item)}));
-
-    const code = await getCode(client.rpcClient, { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" });
-    const infos = selectorsFromBytecode(code as string);
-
-    console.log(infos);
-
-    async function getImplementationAddress(proxyAddr: Address) {
-        const storageValue = await getStorageAt(client.rpcClient, {
-            address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
-            slot: "0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3"
-        });
-    
-        if (storageValue) {
-
-            console.log(storageValue);
-            // La valeur retournée est un hex de 32 octets. L'adresse est dans les 20 derniers octets.
-            const address = getAddress(bytes32ToAddress(storageValue))
-            if (address !== zeroAddress) {
-                return address;
-            }
-        }
-        return null; // Pas d'adresse trouvée ou contrat non EIP-1967
-    };
-
-    getImplementationAddress("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").then(console.log);
+    const firstTx = await client.transactions.get({ hash: "0xeae261aeada2db19fee5cc4dfd47d575ff2380a5fb6a4039685d5044fdc8e2bb" });
+    const calls = await firstTx.getCalls();
+
+    for (const call of calls) {
+        const contract = call.to;
+        console.log(`Calling ${contract.address}`);
+        const isContract = await contract.isContract();
+        console.log(isContract);
+        if (!isContract) continue;
+        const contractType = await contract.getContractType();
+        console.log(contractType);
+        console.log(`Contract ${contract.address} detected as ${Object.keys(contractType).join(", ")}`);
+    }
 })()