@mentaproject/client 0.0.3 → 0.0.5

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>;
+    contractType(): Promise<any>;
     /**
      * Sends native cryptocurrency (ETH) to the account.
      * @param amount The amount of ETH to send (in wei).
@@ -23,12 +29,12 @@ export declare class Account {
      * Gets the native cryptocurrency (ETH) balance of the account.
      * @returns A Promise that resolves to the ETH balance (in wei).
      */
-    getETHBalance(): Promise<bigint>;
+    ETHBalance(): Promise<bigint>;
     /**
      * Gets the transaction count (nonce) for the account.
      * @returns A Promise that resolves to the transaction count.
      **/
-    getTransactionCount(): Promise<number>;
+    transactionCount(): Promise<number>;
     /**
      * Get all transactions involving this account in the given block range.
      * NOTE: This method relies on the non-standard 'trace_filter' method of the RPC. It may not be supported by all nodes.
@@ -37,5 +43,6 @@ export declare class Account {
      *
      * @returns A paginated result containing the transaction hashes.
      */
-    getTransactions(toRetreive: number): Promise<GetTransactionsReturnType>;
+    transactions(toRetreive?: number): Promise<GetTransactionsReturnType>;
+    toJSON(depth?: number): Promise<any>;
 }

package/dist/structures/Account.js

@@ -1,8 +1,10 @@
-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";
+import { toJSON } from "src/utils/toJSON";
 /**
- * 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 +16,24 @@ 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 contractType() {
+        const isContract = await this.isContract();
+        if (!isContract)
+            return undefined;
+        return await getContractType(this.rpcClient, this.address);
+    }
+    ;
     /**
      * Sends native cryptocurrency (ETH) to the account.
      * @param amount The amount of ETH to send (in wei).
@@ -34,7 +54,7 @@ export class Account {
      * Gets the native cryptocurrency (ETH) balance of the account.
      * @returns A Promise that resolves to the ETH balance (in wei).
      */
-    async getETHBalance() {
+    async ETHBalance() {
         // Assurez-vous que rpcClient est bien un PublicClient ou WalletClient
         return await getBalance(this.rpcClient, {
             address: this.address,
@@ -45,7 +65,7 @@ export class Account {
      * Gets the transaction count (nonce) for the account.
      * @returns A Promise that resolves to the transaction count.
      **/
-    async getTransactionCount() {
+    async transactionCount() {
         return await getTransactionCount(this.rpcClient, { address: this.address });
     }
     /**
@@ -56,7 +76,7 @@ export class Account {
      *
      * @returns A paginated result containing the transaction hashes.
      */
-    async getTransactions(toRetreive) {
+    async transactions(toRetreive = 10) {
         const currentBlock = await getBlockNumber(this.rpcClient);
         const onBlockRange = async ({ fromBlock, toBlock }) => {
             const outgoing = await traceFilter(this.rpcClient, {
@@ -83,4 +103,18 @@ export class Account {
             itemsPerPage: toRetreive
         }, onBlockRange);
     }
+    ;
+    async toJSON(depth = 1) {
+        return await toJSON({
+            obj: {
+                ...this,
+                isContract: this.isContract,
+                contractType: this.contractType,
+                ETHBalance: this.ETHBalance,
+                transactionCount: this.transactionCount,
+            },
+            depth
+        });
+    }
 }
+;

package/dist/structures/Block.d.ts

@@ -33,4 +33,5 @@ export declare class Block implements Omit<IBlockData, "miner" | "transactions">
     miner: Account;
     transactions?: Transaction[];
     constructor(rpcClient: CoreClient, data: IBlockData, includeTransactions?: boolean);
+    toJSON(depth?: number): Promise<any>;
 }

package/dist/structures/Block.js

@@ -1,5 +1,6 @@
 import { Account } from "./Account";
 import { Transaction } from "./Transaction";
+import { toJSON } from "src/utils/toJSON";
 export class Block {
     constructor(rpcClient, data, includeTransactions = false) {
         this.rpcClient = rpcClient;
@@ -33,5 +34,11 @@ export class Block {
             this.transactions = data.transactions.map((txData) => new Transaction(this.rpcClient, txData));
     }
     ;
+    async toJSON(depth = 1) {
+        return await toJSON({
+            obj: this,
+            depth
+        });
+    }
 }
 ;

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,7 +24,16 @@ export declare class Transaction implements Omit<ITransactionData, "from" | "to"
     from?: Account;
     to?: Account;
     constructor(rpcClient: CoreClient, data: ITransactionData);
+    calls(): 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>;
+    toJSON(depth?: number): Promise<any>;
 }

package/dist/structures/Transaction.js

@@ -1,6 +1,8 @@
 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';
+import { toJSON } from 'src/utils/toJSON';
 export class Transaction {
     constructor(rpcClient, data) {
         this.rpcClient = rpcClient;
@@ -25,6 +27,18 @@ export class Transaction {
         this.to = data.to ? new Account(this.rpcClient, data.to) : undefined;
     }
     ;
+    async calls() {
+        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,
@@ -41,5 +55,19 @@ export class Transaction {
         return new Block(this.rpcClient, data);
     }
     ;
+    async toJSON(depth = 1) {
+        return await toJSON({
+            obj: {
+                ...this,
+                block: this.block,
+                receipt: this.receipt,
+                calls: async () => {
+                    const calls = await this.calls();
+                    return Promise.all(calls.map(async (c) => await toJSON({ obj: c, depth: depth })));
+                }
+            },
+            depth
+        });
+    }
 }
 ;

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/dist/utils/toJSON.d.ts

@@ -0,0 +1,9 @@
+export interface IToJSONParams<T extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> {
+    obj: T;
+    depth?: number;
+}
+export declare function toJSON({ obj, depth }: IToJSONParams): Promise<any>;

package/dist/utils/toJSON.js

@@ -0,0 +1,71 @@
+function isClassInstance(obj) {
+    if (obj === null || typeof obj !== 'object' || !obj.constructor) {
+        return false;
+    }
+    // Les constructeurs de classes ES6 commencent par "class " quand on les convertit en string.
+    // Attention: cela peut être sensible à la minification ou à des transpilers très spécifiques,
+    // mais c'est généralement fiable pour les classes définies avec le mot-clé `class`.
+    return obj.constructor.toString().startsWith('class ');
+}
+;
+function convertBigintsToStrings(obj) {
+    if (typeof obj === 'bigint') {
+        return obj.toString();
+    }
+    if (typeof obj === 'object') {
+        for (const key in obj) {
+            obj[key] = convertBigintsToStrings(obj[key]);
+        }
+    }
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            obj[i] = convertBigintsToStrings(obj[i]);
+        }
+    }
+    return obj;
+}
+export async function toJSON({ obj, depth = 0 }) {
+    // copy the properties of the object
+    const data = Object.assign({}, obj);
+    for (const key in obj) {
+        // skip class related properties
+        if (key === "toJSON" || key === "constructor" || key === "rpcClient") {
+            delete data[key];
+            continue;
+        }
+        ;
+        const prop = obj[key];
+        if (typeof prop === "function") {
+            // do not fetch getters if depth is 0
+            if (depth === 0) {
+                delete data[key];
+                continue;
+            }
+            // fetch getters
+            const value = await obj[key]();
+            // if the value is a class instance, convert it to JSON recursively
+            if (typeof value === "object" && isClassInstance(value)) {
+                data[key] = await toJSON({ obj: value, depth: depth - 1 });
+                continue;
+            }
+            data[key] = value;
+            continue;
+        }
+        if (typeof prop === "object" && isClassInstance(prop)) {
+            // If depth is 0, just flatten the object using recursion
+            if (depth === 0) {
+                data[key] = await toJSON({
+                    obj: prop,
+                    depth: depth - 1
+                });
+                continue;
+            }
+            ;
+            // If depth is not 0, fetch the object
+            data[key] = await prop.toJSON({ depth: depth - 1 });
+        }
+    }
+    ;
+    return convertBigintsToStrings(data);
+}
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "High level EVM library used into the Menta App to facilitate Blockchain interactions. ",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -29,14 +29,15 @@
   "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",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-typescript": "^12.1.2",
+    "@types/node": "^22.15.29",
     "rollup": "^4.40.1",
     "tslib": "^2.8.1",
     "tsx": "^4.19.4",

package/test.ts

@@ -1,11 +1,9 @@
-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";
+
+import { writeFileSync } from "fs";
 
 const viemAccount = privateKeyToAccount(generatePrivateKey());
 
@@ -16,45 +14,8 @@ 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
-    };
+    const firstTx = await client.transactions.get({ hash: "0xeae261aeada2db19fee5cc4dfd47d575ff2380a5fb6a4039685d5044fdc8e2bb" });
+    const json = await firstTx.toJSON(2);
 
-    getImplementationAddress("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48").then(console.log);
+    writeFileSync("./test.json", JSON.stringify(json, null, 2));
 })()