@mentaproject/client 0.0.3

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './structures';
+export * from './managers';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './structures';
+export * from './managers';

package/dist/managers/AccountManager.d.ts

@@ -0,0 +1,8 @@
+import { Address } from "viem";
+import { Account } from "../structures/Account";
+import { CoreClient } from "@mentaproject/core/types";
+export declare class AccountManager {
+    rpcClient: CoreClient;
+    constructor(rpcClient: CoreClient);
+    get(address: Address): Account;
+}

package/dist/managers/AccountManager.js

@@ -0,0 +1,11 @@
+import { Account } from "../structures/Account";
+export class AccountManager {
+    constructor(rpcClient) {
+        this.rpcClient = rpcClient;
+    }
+    ;
+    get(address) {
+        return new Account(this.rpcClient, address);
+    }
+    ;
+}

package/dist/managers/BlockManager.d.ts

@@ -0,0 +1,8 @@
+import { BlockTag, GetBlockParameters } from "viem";
+import { Block } from "../structures/Block";
+import { CoreClient } from "@mentaproject/core/types";
+export declare class BlockManager {
+    client: CoreClient;
+    constructor(client: CoreClient);
+    get(params: GetBlockParameters<boolean, BlockTag>): Promise<Block>;
+}

package/dist/managers/BlockManager.js

@@ -0,0 +1,13 @@
+import { Block } from "../structures/Block";
+import { getBlock } from "@mentaproject/core/actions";
+export class BlockManager {
+    constructor(client) {
+        this.client = client;
+    }
+    ;
+    async get(params) {
+        const data = await getBlock(this.client, params);
+        return new Block(this.client, data);
+    }
+    ;
+}

package/dist/managers/ContractManager.d.ts

@@ -0,0 +1,7 @@
+import type { AbiItem, CoreClient } from "@mentaproject/core/types";
+import { GetContractParameters } from "@mentaproject/contracts";
+export declare class ContractManager {
+    protected rpcClient: CoreClient;
+    constructor(rpcClient: CoreClient);
+    get<P extends GetContractParameters<ReadonlyArray<AbiItem>>>(params: P): import("@mentaproject/contracts").GetContractReturnType<P>;
+}

package/dist/managers/ContractManager.js

@@ -0,0 +1,12 @@
+import { getContract } from "@mentaproject/contracts";
+export class ContractManager {
+    constructor(rpcClient) {
+        this.rpcClient = rpcClient;
+    }
+    ;
+    get(params) {
+        return getContract(this.rpcClient, params);
+    }
+    ;
+}
+;

package/dist/managers/TransactionManager.d.ts

@@ -0,0 +1,8 @@
+import { CoreClient, GetTransactionParameters, SendTransactionParameters } from "@mentaproject/core/types";
+import { Transaction } from "../structures/Transaction";
+export declare class TransactionManager {
+    rpcClient: CoreClient;
+    constructor(rpcClient: CoreClient);
+    get(params: GetTransactionParameters): Promise<Transaction>;
+    send(params: SendTransactionParameters): Promise<Transaction>;
+}

package/dist/managers/TransactionManager.js

@@ -0,0 +1,19 @@
+import { Transaction } from "../structures/Transaction";
+import { getTransaction, sendTransaction } from "@mentaproject/core/actions";
+export class TransactionManager {
+    constructor(rpcClient) {
+        this.rpcClient = rpcClient;
+    }
+    ;
+    async get(params) {
+        const data = await getTransaction(this.rpcClient, params);
+        return new Transaction(this.rpcClient, data);
+    }
+    ;
+    async send(params) {
+        const hash = await sendTransaction(this.rpcClient, params);
+        return await this.get({ hash });
+    }
+    ;
+}
+;

package/dist/managers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './AccountManager';
+export * from './BlockManager';
+export * from './ContractManager';
+export * from './TransactionManager';

package/dist/managers/index.js

@@ -0,0 +1,4 @@
+export * from './AccountManager';
+export * from './BlockManager';
+export * from './ContractManager';
+export * from './TransactionManager';

package/dist/structures/Account.d.ts

@@ -0,0 +1,41 @@
+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.
+ */
+export declare class Account {
+    protected rpcClient: CoreClient;
+    address: Address;
+    /**
+     * Creates an instance of Account.
+     * @param client The CoreClient instance used for blockchain interactions.
+     * @param address The blockchain address of the account.
+     */
+    constructor(rpcClient: CoreClient, address: Address);
+    /**
+     * Sends native cryptocurrency (ETH) to the account.
+     * @param amount The amount of ETH to send (in wei).
+     * @returns A Promise that resolves to a Transaction object representing the sent transaction.
+     */
+    sendETH(amount: bigint): Promise<Transaction>;
+    /**
+     * Gets the native cryptocurrency (ETH) balance of the account.
+     * @returns A Promise that resolves to the ETH balance (in wei).
+     */
+    getETHBalance(): Promise<bigint>;
+    /**
+     * Gets the transaction count (nonce) for the account.
+     * @returns A Promise that resolves to the transaction count.
+     **/
+    getTransactionCount(): 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.
+     *
+     * @param toRetreive The number of transactions to retrieve.
+     *
+     * @returns A paginated result containing the transaction hashes.
+     */
+    getTransactions(toRetreive: number): Promise<GetTransactionsReturnType>;
+}

package/dist/structures/Account.js

@@ -0,0 +1,86 @@
+import { createBlockRangePager, getBalance, getBlockNumber, getTransaction, getTransactionCount, sendTransaction, traceFilter } from "@mentaproject/core/actions";
+import { Transaction } from "./Transaction";
+import { toHex } from "@mentaproject/core/utils";
+/**
+ * Represents a user account with methods for interacting with the blockchain.
+ */
+export class Account {
+    /**
+     * Creates an instance of Account.
+     * @param client The CoreClient instance used for blockchain interactions.
+     * @param address The blockchain address of the account.
+     */
+    constructor(rpcClient, address) {
+        this.rpcClient = rpcClient;
+        this.address = address;
+    }
+    /**
+     * Sends native cryptocurrency (ETH) to the account.
+     * @param amount The amount of ETH to send (in wei).
+     * @returns A Promise that resolves to a Transaction object representing the sent transaction.
+     */
+    async sendETH(amount) {
+        const hash = await sendTransaction(this.rpcClient, {
+            calls: [{
+                    to: this.address,
+                    value: amount,
+                }]
+        });
+        const data = await getTransaction(this.rpcClient, { hash });
+        return new Transaction(this.rpcClient, data);
+    }
+    ;
+    /**
+     * Gets the native cryptocurrency (ETH) balance of the account.
+     * @returns A Promise that resolves to the ETH balance (in wei).
+     */
+    async getETHBalance() {
+        // Assurez-vous que rpcClient est bien un PublicClient ou WalletClient
+        return await getBalance(this.rpcClient, {
+            address: this.address,
+        });
+    }
+    ;
+    /**
+     * Gets the transaction count (nonce) for the account.
+     * @returns A Promise that resolves to the transaction count.
+     **/
+    async getTransactionCount() {
+        return await getTransactionCount(this.rpcClient, { address: this.address });
+    }
+    /**
+     * 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.
+     *
+     * @param toRetreive The number of transactions to retrieve.
+     *
+     * @returns A paginated result containing the transaction hashes.
+     */
+    async getTransactions(toRetreive) {
+        const currentBlock = await getBlockNumber(this.rpcClient);
+        const onBlockRange = async ({ fromBlock, toBlock }) => {
+            const outgoing = await traceFilter(this.rpcClient, {
+                fromBlock: toHex(fromBlock),
+                toBlock: toHex(toBlock),
+                fromAddress: this.address
+            });
+            const incoming = await traceFilter(this.rpcClient, {
+                fromBlock: toHex(fromBlock),
+                toBlock: toHex(toBlock),
+                toAddress: this.address
+            });
+            const traces = outgoing.concat(incoming);
+            return traces.map(t => ({
+                blockNumber: BigInt(t.blockNumber),
+                index: t.transactionPosition,
+                hash: t.transactionHash
+            }));
+        };
+        return await createBlockRangePager({
+            blockLimit: 0n,
+            startBlock: currentBlock,
+            direction: "backward",
+            itemsPerPage: toRetreive
+        }, onBlockRange);
+    }
+}

package/dist/structures/Block.d.ts

@@ -0,0 +1,36 @@
+import { Hash, Hex, Withdrawal } from "viem";
+import { Account } from "./Account";
+import { Transaction } from "./Transaction";
+import { IBlockData } from "../types/Block";
+import type { CoreClient } from "@mentaproject/core/types";
+export declare class Block implements Omit<IBlockData, "miner" | "transactions"> {
+    rpcClient: CoreClient;
+    baseFeePerGas: bigint | null;
+    blobGasUsed: bigint;
+    difficulty: bigint;
+    excessBlobGas: bigint;
+    extraData: Hex;
+    gasLimit: bigint;
+    gasUsed?: bigint;
+    hash?: Hash | null;
+    logsBloom?: Hex | null;
+    mixHash: Hash;
+    nonce?: Hex | null;
+    number?: bigint | null;
+    parentBeaconBlockRoot?: Hex | undefined;
+    parentHash: Hash;
+    receiptsRoot: Hex;
+    sealFields: Hex[];
+    sha3Uncles: Hash;
+    size: bigint;
+    stateRoot: Hash;
+    timestamp: bigint;
+    totalDifficulty?: bigint | null;
+    transactionsRoot: Hash;
+    uncles: Hash[];
+    withdrawals?: Withdrawal[];
+    withdrawalsRoot?: Hex | null;
+    miner: Account;
+    transactions?: Transaction[];
+    constructor(rpcClient: CoreClient, data: IBlockData, includeTransactions?: boolean);
+}

package/dist/structures/Block.js

@@ -0,0 +1,37 @@
+import { Account } from "./Account";
+import { Transaction } from "./Transaction";
+export class Block {
+    constructor(rpcClient, data, includeTransactions = false) {
+        this.rpcClient = rpcClient;
+        this.baseFeePerGas = data.baseFeePerGas;
+        this.blobGasUsed = data.blobGasUsed;
+        this.difficulty = data.difficulty;
+        this.excessBlobGas = data.excessBlobGas;
+        this.extraData = data.extraData;
+        this.gasLimit = data.gasLimit;
+        this.gasUsed = data.gasUsed;
+        this.hash = data.hash;
+        this.logsBloom = data.logsBloom;
+        this.mixHash = data.mixHash;
+        this.nonce = data.nonce;
+        this.number = data.number;
+        this.parentBeaconBlockRoot = data.parentBeaconBlockRoot;
+        this.parentHash = data.parentHash;
+        this.receiptsRoot = data.receiptsRoot;
+        this.sealFields = data.sealFields;
+        this.sha3Uncles = data.sha3Uncles;
+        this.size = data.size;
+        this.stateRoot = data.stateRoot;
+        this.timestamp = data.timestamp;
+        this.totalDifficulty = data.totalDifficulty;
+        this.transactionsRoot = data.transactionsRoot;
+        this.uncles = data.uncles;
+        this.withdrawals = data.withdrawals;
+        this.withdrawalsRoot = data.withdrawalsRoot;
+        this.miner = new Account(this.rpcClient, data.miner);
+        if (includeTransactions)
+            this.transactions = data.transactions.map((txData) => new Transaction(this.rpcClient, txData));
+    }
+    ;
+}
+;

package/dist/structures/MentaClient.d.ts

@@ -0,0 +1,13 @@
+import type { CoreClient, CoreClientConfig } from "@mentaproject/core/types";
+import { BlockManager } from "../managers/BlockManager";
+import { TransactionManager } from "../managers/TransactionManager";
+import { ContractManager } from "../managers/ContractManager";
+import { AccountManager } from "../managers/AccountManager";
+export declare class MentaClient {
+    rpcClient: CoreClient;
+    blocks: BlockManager;
+    transactions: TransactionManager;
+    contracts: ContractManager;
+    accounts: AccountManager;
+    constructor(params: CoreClientConfig);
+}

package/dist/structures/MentaClient.js

@@ -0,0 +1,16 @@
+import { createClient } from "@mentaproject/core";
+import { BlockManager } from "../managers/BlockManager";
+import { TransactionManager } from "../managers/TransactionManager";
+import { ContractManager } from "../managers/ContractManager";
+import { AccountManager } from "../managers/AccountManager";
+export class MentaClient {
+    constructor(params) {
+        this.rpcClient = createClient(params);
+        this.blocks = new BlockManager(this.rpcClient);
+        this.transactions = new TransactionManager(this.rpcClient);
+        this.contracts = new ContractManager(this.rpcClient);
+        this.accounts = new AccountManager(this.rpcClient);
+    }
+    ;
+}
+;

package/dist/structures/Transaction.d.ts

@@ -0,0 +1,30 @@
+import { Account } from './Account';
+import { Block } from './Block';
+import { ITransactionData } from '../types/Transaction';
+import { AccessList, CoreClient, Hash, Hex, TransactionType, WaitForTransactionReceiptReturnType } from '@mentaproject/core/types';
+export declare class Transaction implements Omit<ITransactionData, "from" | "to"> {
+    protected rpcClient: CoreClient;
+    accessList?: AccessList;
+    blobVersionedHashes?: readonly Hex[];
+    gas: bigint;
+    gasPrice?: bigint;
+    hash: Hash;
+    input?: Hex;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce: number;
+    r: Hex;
+    s: Hex;
+    transactionIndex?: number | null;
+    type: TransactionType;
+    v: bigint;
+    value: bigint;
+    yParity?: number;
+    blockHash?: Hash;
+    from?: Account;
+    to?: Account;
+    constructor(rpcClient: CoreClient, data: ITransactionData);
+    waitForReceipt(confirmations?: number): Promise<WaitForTransactionReceiptReturnType>;
+    receipt(): Promise<WaitForTransactionReceiptReturnType>;
+    block(): Promise<Block>;
+}

package/dist/structures/Transaction.js

@@ -0,0 +1,45 @@
+import { Account } from './Account';
+import { Block } from './Block';
+import { getBlock, getTransactionReceipt, waitForTransactionReceipt } from '@mentaproject/core/actions';
+export class Transaction {
+    constructor(rpcClient, data) {
+        this.rpcClient = rpcClient;
+        this.accessList = data.accessList;
+        this.blobVersionedHashes = data.blobVersionedHashes;
+        this.gas = data.gas;
+        this.gasPrice = data.gasPrice;
+        this.hash = data.hash;
+        this.input = data.input;
+        this.maxFeePerGas = data.maxFeePerGas;
+        this.maxPriorityFeePerGas = data.maxPriorityFeePerGas;
+        this.nonce = data.nonce;
+        this.r = data.r;
+        this.s = data.s;
+        this.transactionIndex = data.transactionIndex;
+        this.type = data.type;
+        this.v = data.v;
+        this.value = data.value;
+        this.yParity = data.yParity;
+        this.blockHash = data.blockHash;
+        this.from = new Account(this.rpcClient, data.from);
+        this.to = data.to ? new Account(this.rpcClient, data.to) : undefined;
+    }
+    ;
+    async waitForReceipt(confirmations) {
+        return await waitForTransactionReceipt(this.rpcClient, {
+            hash: this.hash,
+            confirmations: confirmations || 1,
+        });
+    }
+    ;
+    async receipt() {
+        return await getTransactionReceipt(this.rpcClient, { hash: this.hash });
+    }
+    ;
+    async block() {
+        const data = await getBlock(this.rpcClient, { blockHash: this.blockHash });
+        return new Block(this.rpcClient, data);
+    }
+    ;
+}
+;

package/dist/structures/TransactionReceipt.js

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

package/dist/structures/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Account';
+export * from './Block';
+export * from './MentaClient';
+export * from './Transaction';
+export * from "@mentaproject/core/types";

package/dist/structures/index.js

@@ -0,0 +1,5 @@
+export * from './Account';
+export * from './Block';
+export * from './MentaClient';
+export * from './Transaction';
+export * from "@mentaproject/core/types";

package/dist/types/Account.d.ts

@@ -0,0 +1,5 @@
+import { Hash, PaginatableItem } from "@mentaproject/core/types";
+import { PaginatedResult } from "@mentaproject/core/structures";
+export type GetTransactionsReturnType = PaginatedResult<PaginatableItem<{
+    hash: Hash;
+}>>;

package/dist/types/Account.js

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

package/dist/types/Block.d.ts

@@ -0,0 +1,56 @@
+import { Address, Hash, Hex, Transaction, Withdrawal } from "viem";
+export interface IBlockData {
+    /** Base fee per gas */
+    baseFeePerGas: bigint | null;
+    /** Total used blob gas by all transactions in this block */
+    blobGasUsed: bigint;
+    /** Difficulty for this block */
+    difficulty: bigint;
+    /** Excess blob gas */
+    excessBlobGas: bigint;
+    /** "Extra data" field of this block */
+    extraData: Hex;
+    /** Maximum gas allowed in this block */
+    gasLimit: bigint;
+    /** Total used gas by all transactions in this block */
+    gasUsed?: bigint;
+    /** Block hash or `null` if pending */
+    hash?: Hash | null;
+    /** Logs bloom filter or `null` if pending */
+    logsBloom?: Hex | null;
+    /** Address that received this block’s mining rewards, COINBASE address */
+    miner: Address;
+    /** Unique identifier for the block. */
+    mixHash: Hash;
+    /** Proof-of-work hash or `null` if pending */
+    nonce?: Hex | null;
+    /** Block number or `null` if pending */
+    number?: bigint | null;
+    /** Root of the parent beacon chain block */
+    parentBeaconBlockRoot?: Hex;
+    /** Parent block hash */
+    parentHash: Hash;
+    /** Root of the this block’s receipts trie */
+    receiptsRoot: Hex;
+    sealFields: Hex[];
+    /** SHA3 of the uncles data in this block */
+    sha3Uncles: Hash;
+    /** Size of this block in bytes */
+    size: bigint;
+    /** Root of this block’s final state trie */
+    stateRoot: Hash;
+    /** Unix timestamp of when this block was collated */
+    timestamp: bigint;
+    /** Total difficulty of the chain until this block */
+    totalDifficulty?: bigint | null;
+    /** List of transaction object or hashes */
+    transactions: Transaction[] | Hash[];
+    /** Root of this block’s transaction trie */
+    transactionsRoot: Hash;
+    /** List of uncle hashes */
+    uncles: Hash[];
+    /** List of withdrawal objects */
+    withdrawals?: Withdrawal[];
+    /** Root of the this block’s withdrawals trie */
+    withdrawalsRoot?: Hex | null;
+}

package/dist/types/Block.js

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

package/dist/types/Transaction.d.ts

@@ -0,0 +1,45 @@
+import { AccessList, Address, Hash, Hex, TransactionType } from "@mentaproject/core/types";
+export type TransactionDirection = "in" | "out";
+export interface ITransactionData {
+    /** EIP-2930 Access List. */
+    accessList?: AccessList;
+    /** List of versioned blob hashes associated with the transaction's blobs. */
+    blobVersionedHashes?: readonly Hex[];
+    /** Gas provided for transaction execution */
+    gas: bigint;
+    /** Base fee per gas. */
+    gasPrice?: bigint;
+    /** Hash of the transaction. */
+    hash: Hash;
+    /** Contract code or a hashed method call */
+    input?: Hex;
+    /** Total fee per gas in wei (gasPrice/baseFeePerGas + maxPriorityFeePerGas) */
+    maxFeePerGas?: bigint;
+    /** Max priority fee per gas (in wei). */
+    maxPriorityFeePerGas?: bigint;
+    /** Unique number identifying this transaction */
+    nonce: number;
+    /** ECDSA signature r */
+    r: Hex;
+    /** ECDSA signature s */
+    s: Hex;
+    /** Index of this transaction in the block or null if pending */
+    transactionIndex?: number | null;
+    /** The type of transaction */
+    type: TransactionType;
+    /** ECDSA recovery ID */
+    v: bigint;
+    /** Value in wei sent with this transaction */
+    value: bigint;
+    /** The parity of the y-value of the secp256k1 signature. */
+    yParity?: number;
+    /** Block from which the transaction was included */
+    blockHash?: Hash;
+    /** Transaction sender */
+    from: Address;
+    /** Transaction recipient or `null` if deploying a contract */
+    to?: Address | null;
+}
+export interface IGetTransactionBlockParams {
+    includeTransactions?: boolean;
+}

package/dist/types/Transaction.js

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

package/dist/types/TransactionReceipt.d.ts

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

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

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Account';
+export * from './Block';
+export * from './Transaction';
+export * from "@mentaproject/core/types";

package/dist/types/index.js

@@ -0,0 +1,4 @@
+export * from './Account';
+export * from './Block';
+export * from './Transaction';
+export * from "@mentaproject/core/types";

package/dist/utils/IsContractCompliantWithAbi.d.ts

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