@mentaproject/client 0.1.37 → 0.1.38

package/dist/index.cjs

@@ -141,6 +141,7 @@ var src_exports = {};
 __export(src_exports, {
   Account: () => Account,
   AccountManager: () => AccountManager,
+  Action: () => Action,
   Block: () => Block,
   BlockManager: () => BlockManager,
   ContractManager: () => ContractManager,
@@ -159,12 +160,38 @@ module.exports = __toCommonJS(src_exports);
 // src/structures/Account.ts
 var import_actions2 = require("@mentaproject/core/actions");
 
-// src/structures/Transaction.ts
+// src/structures/Action.ts
 var import_actions = require("@mentaproject/core/actions");
-var import_utils = require("@mentaproject/core/utils");
+var Action = class {
+  constructor(client, _call) {
+    this.client = client;
+    this._call = _call;
+  }
+  /**
+   * Returns the Call object for use with TransactionBuilder.
+   */
+  call() {
+    return this._call;
+  }
+  /**
+   * Simulates the action without executing.
+   */
+  async simulate() {
+    return (0, import_actions.simulateCalls)(this.client, { calls: [this._call] });
+  }
+  /**
+   * Executes the action directly.
+   *
+   * @returns Transaction hash
+   */
+  async execute() {
+    return this.client.sendTransaction(this._call);
+  }
+};
 
-// node_modules/viem/_esm/index.js
-init_transaction();
+// src/structures/Account.ts
+var import_utils = require("@mentaproject/core/utils");
+var import_contracts = require("@mentaproject/contracts");
 
 // src/utils/toJSON.ts
 function isClassInstance(obj) {
@@ -234,68 +261,123 @@ async function toJSON({ obj, depth = 0 }) {
   return convertBigintsToStrings(data);
 }
 
-// src/structures/Block.ts
-var Block = class {
-  /**
-   * @description Creates an instance of Block.
-   * @param client - The instance of MentaClient used to interact with the blockchain.
-   * @param data The raw block data conforming to IBlockData.
-   * @param includeTransactions Whether to include full transaction objects. Defaults to false.
-   */
-  constructor(client, data) {
+// src/structures/Account.ts
+var Account = class {
+  constructor(client, data, persistenceManager) {
     this.client = client;
-    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.client, { address: data.miner });
-    if (!data.transactions || data.transactions.length === 0) {
-      const parsed = data.transactions.map((data2) => typeof data2 === "string" ? data2 : new Transaction(this.client, data2));
-      this.transactions = parsed;
-    }
+    this.address = data.address;
+    this.persistenceManager = persistenceManager;
   }
-  includeTransactions() {
-    if (!this.transactions || this.transactions.length === 0) return false;
+  async isContract() {
+    const code = await (0, import_actions2.getCode)(this.client.rpc, { address: this.address });
+    if (!code || code === "0x") return false;
     return true;
   }
+  async contractType() {
+    const isContract = await this.isContract();
+    if (!isContract) return void 0;
+    return await (0, import_contracts.getContractType)(this.client.rpc, this.address);
+  }
   /**
-   * @description Converts the Block instance to a JSON representation.
-   * This method serializes the block's properties into a plain JavaScript object,
-   * suitable for JSON serialization.
-   * @param depth The depth of the conversion. Defaults to 1.
-   * @returns A promise that resolves to the JSON representation of the block.
+   * Creates an Action to send ETH to this account.
+   *
+   * @param amount The amount of ETH to send, in wei.
+   * @returns An Action with .call(), .simulate(), and .execute() methods.
+   *
+   * @example
+   * ```ts
+   * // Direct execution
+   * await account.sendEth(parseEther("1")).execute();
+   *
+   * // Batch with TransactionBuilder
+   * builder.addCall(account.sendEth(parseEther("1")));
+   * ```
    */
+  sendEth(amount) {
+    return new Action(this.client.rpc, {
+      to: this.address,
+      value: amount
+    });
+  }
+  async ETHBalance() {
+    return await (0, import_actions2.getBalance)(this.client.rpc, { address: this.address });
+  }
+  async transactionCount() {
+    return await (0, import_actions2.getTransactionCount)(this.client.rpc, { address: this.address });
+  }
+  async transactions(params, forceFetch = false) {
+    if (!this.persistenceManager || forceFetch) {
+      const hashes = await this._fetchTransactions(params);
+      const transactions = await Promise.all(
+        hashes.map((hash) => this.client.transactions.get({ hash }))
+      );
+      return transactions;
+    }
+    const jsons = await this.persistenceManager.getTransactions(
+      this.address,
+      params
+    );
+    return jsons.map((j) => this.client.transactions.parse(j));
+  }
+  async syncTransactions(limit = 1e3) {
+    if (!this.persistenceManager)
+      throw new Error("The persistence module is not configured.");
+    await this.persistenceManager.syncTransactions(this, limit);
+  }
+  async tokenTransactions(tokenAddress) {
+    if (!this.persistenceManager)
+      throw new Error("The persistence module is not configured.");
+    return {};
+  }
   async toJSON(depth) {
     return await toJSON({
       obj: {
-        ...this
+        address: this.address,
+        isContract: this.isContract.bind(this),
+        contractType: this.contractType.bind(this),
+        ETHBalance: this.ETHBalance.bind(this),
+        transactionCount: this.transactionCount.bind(this)
       },
       depth
     });
   }
+  async _fetchTransactions({
+    fromBlock,
+    toBlock,
+    limit = 50
+  }) {
+    const lastBlock = await (0, import_actions2.getBlockNumber)(this.client.rpc);
+    const onBlockRange = async ({ fromBlock: fromBlock2, toBlock: toBlock2 }, stop) => {
+      const outgoing = await (0, import_actions2.traceFilter)(this.client.rpc, {
+        fromBlock: (0, import_utils.toHex)(fromBlock2),
+        toBlock: (0, import_utils.toHex)(toBlock2),
+        fromAddress: this.address
+      });
+      const incoming = await (0, import_actions2.traceFilter)(this.client.rpc, {
+        fromBlock: (0, import_utils.toHex)(fromBlock2),
+        toBlock: (0, import_utils.toHex)(toBlock2),
+        toAddress: this.address
+      });
+      const traces = outgoing.concat(incoming).sort((a, b) => a.blockNumber - b.blockNumber);
+      return traces.map((t) => t.transactionHash);
+    };
+    return await (0, import_actions2.fetchByBlockRange)({
+      toBlock: BigInt(toBlock !== void 0 ? toBlock : 0),
+      fromBlock: BigInt(fromBlock !== void 0 ? fromBlock : lastBlock),
+      direction: "backward",
+      itemLimit: limit,
+      onBlockRange
+    });
+  }
 };
 
+// src/structures/Transaction.ts
+var import_actions3 = require("@mentaproject/core/actions");
+var import_utils2 = require("@mentaproject/core/utils");
+
+// node_modules/viem/_esm/index.js
+init_transaction();
+
 // src/structures/Transaction.ts
 var Transaction = class {
   /**
@@ -334,15 +416,15 @@ var Transaction = class {
    * @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 (0, import_actions.traceTransaction)(this.client.rpc, this.hash);
+    const traces = await (0, import_actions3.traceTransaction)(this.client.rpc, this.hash);
     if (!traces) return void 0;
     const calls = traces.filter((t) => t.type === "call" && t.action !== void 0);
     return calls.map((c) => ({
       from: new Account(this.client, { address: c.action.from }),
       to: new Account(this.client, { address: c.action.to }),
-      value: (0, import_utils.hexToBigInt)(c.action.value),
+      value: (0, import_utils2.hexToBigInt)(c.action.value),
       input: c.action.input,
-      gas: (0, import_utils.hexToBigInt)(c.action.gas),
+      gas: (0, import_utils2.hexToBigInt)(c.action.gas),
       callType: c.action.callType
     }));
   }
@@ -353,7 +435,7 @@ var Transaction = class {
    * @returns {Promise<WaitForTransactionReceiptReturnType>} A promise that resolves to the transaction receipt once the specified number of confirmations are met.
    */
   async waitForReceipt(confirmations) {
-    return await (0, import_actions.waitForTransactionReceipt)(this.client.rpc, {
+    return await (0, import_actions3.waitForTransactionReceipt)(this.client.rpc, {
       hash: this.hash,
       confirmations: confirmations || 1
     });
@@ -365,7 +447,7 @@ var Transaction = class {
    */
   async receipt() {
     try {
-      return await (0, import_actions.getTransactionReceipt)(this.client.rpc, { hash: this.hash });
+      return await (0, import_actions3.getTransactionReceipt)(this.client.rpc, { hash: this.hash });
     } catch (error) {
       if (error instanceof TransactionReceiptNotFoundError) {
         return void 0;
@@ -378,7 +460,7 @@ var Transaction = class {
    * @returns {Promise<Block>} A promise that resolves to a Block instance representing the block that includes this transaction.
    */
   async block() {
-    const data = await (0, import_actions.getBlock)(this.client.rpc, { blockHash: this.blockHash });
+    const data = await (0, import_actions3.getBlock)(this.client.rpc, { blockHash: this.blockHash });
     return new Block(this.client, data);
   }
   /**
@@ -404,187 +486,66 @@ var Transaction = class {
   }
 };
 
-// src/structures/Account.ts
-var import_utils2 = require("@mentaproject/core/utils");
-var import_contracts = require("@mentaproject/contracts");
-var Account = class {
+// src/structures/Block.ts
+var Block = class {
   /**
-   * Creates an instance of the Account class.
-   * @param client.rpc The CoreClient instance used for blockchain interactions.
-   * @param address The blockchain address of the account.
-   * @param persistenceManager An optional PersistenceManager instance for caching and data synchronization.
+   * @description Creates an instance of Block.
+   * @param client - The instance of MentaClient used to interact with the blockchain.
+   * @param data The raw block data conforming to IBlockData.
+   * @param includeTransactions Whether to include full transaction objects. Defaults to false.
    */
-  constructor(client, data, persistenceManager) {
+  constructor(client, data) {
     this.client = client;
-    this.address = data.address;
-    this.persistenceManager = persistenceManager;
-  }
-  /**
-   * Checks if the account's address belongs to a smart contract.
-   * @description This method queries the blockchain for the code associated with the account's address.
-   * If code is found, it indicates that the account is a contract.
-   * @returns {Promise<boolean>} A promise that resolves to `true` if the account is a contract, `false` otherwise.
-   */
-  async isContract() {
-    const code = await (0, import_actions2.getCode)(this.client.rpc, { address: this.address });
-    if (!code || code === "0x") return false;
-    return true;
-  }
-  /**
-   * Retrieves the type of the contract if the account is a smart contract.
-   * @description This method first checks if the account is a contract using `isContract()`.
-   * If it is a contract, it then attempts to determine and return its type.
-   * @returns {Promise<any>} A promise that resolves to the contract type (e.g., 'ERC20', 'ERC721') or `undefined` if the account is not a contract or its type cannot be determined.
-   */
-  async contractType() {
-    const isContract = await this.isContract();
-    if (!isContract) return void 0;
-    return await (0, import_contracts.getContractType)(this.client.rpc, this.address);
-  }
-  /**
-   * Sends a specified amount of native cryptocurrency (ETH) to this account.
-   * @description This method constructs and sends a transaction to transfer ETH to the account's address.
-   * @param {bigint} amount The amount of ETH to send, specified in wei (the smallest denomination of Ether).
-   * @returns {Promise<Transaction>} A promise that resolves to a `Transaction` object representing the sent transaction.
-   */
-  async sendETH(amount) {
-    const hash = await (0, import_actions2.sendTransaction)(this.client.rpc, {
-      calls: [
-        {
-          to: this.address,
-          value: amount
-        }
-      ]
-    });
-    const data = await (0, import_actions2.getTransaction)(this.client.rpc, { hash });
-    return new Transaction(this.client, data);
-  }
-  /**
-   * Retrieves the current native cryptocurrency (ETH) balance of the account.
-   * @description This method queries the blockchain to get the balance associated with the account's address.
-   * @returns {Promise<bigint>} A promise that resolves to the ETH balance of the account, in wei.
-   */
-  async ETHBalance() {
-    return await (0, import_actions2.getBalance)(this.client.rpc, {
-      address: this.address
-    });
-  }
-  /**
-   * Retrieves the transaction count (nonce) for the account.
-   * @description The transaction count represents the number of transactions sent from this account,
-   * which is also used as the nonce for new transactions to prevent replay attacks.
-   * @returns {Promise<number>} A promise that resolves to the transaction count of the account.
-   */
-  async transactionCount() {
-    return await (0, import_actions2.getTransactionCount)(this.client.rpc, {
-      address: this.address
-    });
-  }
-  /**
-   * Retrieves all transactions involving this account.
-   * @description If a `PersistenceManager` is configured, this method will first attempt to retrieve transactions from the local cache.
-   * If not found in cache or if no `PersistenceManager` is configured, it will fetch transactions directly from the remote RPC.
-   * @param {GetTransactionsOptions} [options] - Optional parameters for filtering, pagination, and sorting the transactions.
-   * @param {number} [options.startBlock] - The starting block number (inclusive) from which to retrieve transactions.
-   * @param {number} [options.endBlock] - The ending block number (inclusive) up to which to retrieve transactions.
-   * @param {number} [options.page] - The page number for paginated results.
-   * @param {number} [options.offset] - The number of items to skip from the beginning of the result set.
-   * @param {'asc' | 'desc'} [options.sort] - The sorting order for transactions based on block number ('asc' for ascending, 'desc' for descending).
-   * @param {boolean} [forceFetch=false] - Forces the method to fetch transactions from the remote source even if they are already cached. (mostly used internally)
-   * @returns {Promise<Transaction[]>} A promise that resolves to an array of transactions.
-   */
-  async transactions(params, forceFetch = false) {
-    if (!this.persistenceManager || forceFetch) {
-      const hashes = await this._fetchTransactions(params);
-      const transactions = await Promise.all(
-        hashes.map((hash) => this.client.transactions.get({ hash }))
-      );
-      return transactions;
+    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.client, { address: data.miner });
+    if (!data.transactions || data.transactions.length === 0) {
+      const parsed = data.transactions.map((data2) => typeof data2 === "string" ? data2 : new Transaction(this.client, data2));
+      this.transactions = parsed;
     }
-    const jsons = await this.persistenceManager.getTransactions(
-      this.address,
-      params
-    );
-    return jsons.map((j) => this.client.transactions.parse(j));
-  }
-  /**
-   * Synchronizes the account's transactions with the remote data source using the configured `PersistenceManager`.
-   * @description This method initiates a synchronization process to ensure that the local cache of transactions
-   * for this account is up-to-date with the blockchain.
-   * @param {number} [limit] The maximum number of transactions to synchronize.
-   * @returns {Promise<void>} A promise that resolves when the synchronization process is complete.
-   * @throws {Error} If the persistence module is not configured.
-   */
-  async syncTransactions(limit = 1e3) {
-    if (!this.persistenceManager)
-      throw new Error("The persistence module is not configured.");
-    await this.persistenceManager.syncTransactions(this, limit);
   }
-  /**
-   * Retrieves transactions involving a specific token. (not implemented yet)
-   * @description This method queries the persistence adapter to retrieve transactions involving a specific token.
-   * @param {Address} tokenAddress The address of the token.
-   * @returns {Promise<any>} A promise that resolves to an array of transactions involving the token.
-   * @throws {Error} If the persistence module is not configured.
-   */
-  async tokenTransactions(tokenAddress) {
-    if (!this.persistenceManager)
-      throw new Error("The persistence module is not configured.");
-    return {};
+  includeTransactions() {
+    if (!this.transactions || this.transactions.length === 0) return false;
+    return true;
   }
   /**
-   * Converts the Account instance into a JSON-serializable representation.
-   * @description This method leverages a utility function to convert the `Account` object,
-   * including its asynchronous properties (like `isContract`, `ETHBalance`), into a plain JSON object.
-   * @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.
+   * @description Converts the Block instance to a JSON representation.
+   * This method serializes the block's properties into a plain JavaScript object,
+   * suitable for JSON serialization.
+   * @param depth The depth of the conversion. Defaults to 1.
+   * @returns A promise that resolves to the JSON representation of the block.
    */
   async toJSON(depth) {
     return await toJSON({
       obj: {
-        address: this.address,
-        isContract: this.isContract.bind(this),
-        contractType: this.contractType.bind(this),
-        ETHBalance: this.ETHBalance.bind(this),
-        transactionCount: this.transactionCount.bind(this)
+        ...this
       },
       depth
     });
   }
-  /**
-   * Fetches transactions from the account using a block range exploration with trace_filter calls.
-   *
-   *  @param params - The parameters for the block range exploration.
-   *  @returns A Promise that resolves to an array of transaction hashes.
-   */
-  async _fetchTransactions({
-    fromBlock,
-    toBlock,
-    limit = 50
-  }) {
-    const lastBlock = await (0, import_actions2.getBlockNumber)(this.client.rpc);
-    const onBlockRange = async ({ fromBlock: fromBlock2, toBlock: toBlock2 }, stop) => {
-      const outgoing = await (0, import_actions2.traceFilter)(this.client.rpc, {
-        fromBlock: (0, import_utils2.toHex)(fromBlock2),
-        toBlock: (0, import_utils2.toHex)(toBlock2),
-        fromAddress: this.address
-      });
-      const incoming = await (0, import_actions2.traceFilter)(this.client.rpc, {
-        fromBlock: (0, import_utils2.toHex)(fromBlock2),
-        toBlock: (0, import_utils2.toHex)(toBlock2),
-        toAddress: this.address
-      });
-      const traces = outgoing.concat(incoming).sort((a, b) => a.blockNumber - b.blockNumber);
-      return traces.map((t) => t.transactionHash);
-    };
-    return await (0, import_actions2.fetchByBlockRange)({
-      toBlock: BigInt(toBlock !== void 0 ? toBlock : 0),
-      fromBlock: BigInt(fromBlock !== void 0 ? fromBlock : lastBlock),
-      direction: "backward",
-      itemLimit: limit,
-      onBlockRange
-    });
-  }
 };
 
 // src/structures/MentaClient.ts
@@ -592,7 +553,7 @@ var import_clients = require("@mentaproject/core/clients");
 var import_core = require("@mentaproject/core");
 
 // src/managers/BlockManager.ts
-var import_actions3 = require("@mentaproject/core/actions");
+var import_actions4 = require("@mentaproject/core/actions");
 var BlockManager = class {
   /**
    * Creates an instance of BlockManager.
@@ -630,13 +591,13 @@ var BlockManager = class {
    * fetchBlock();
    */
   async get(params) {
-    const data = await (0, import_actions3.getBlock)(this.client.rpc, params);
+    const data = await (0, import_actions4.getBlock)(this.client.rpc, params);
     return new Block(this.client, data);
   }
 };
 
 // src/managers/TransactionManager.ts
-var import_actions4 = require("@mentaproject/core/actions");
+var import_actions5 = require("@mentaproject/core/actions");
 
 // src/utils/bigint.ts
 var bigIntMax = (...args) => args.reduce((m, e) => e > m ? e : m);
@@ -714,7 +675,7 @@ var TransactionManager = class {
    * console.log(transaction);
    */
   async get(params) {
-    const data = await (0, import_actions4.getTransaction)(this.client.rpc, params);
+    const data = await (0, import_actions5.getTransaction)(this.client.rpc, params);
     return new Transaction(this.client, data);
   }
   /**
@@ -758,7 +719,7 @@ var TransactionManager = class {
    * console.log('Transaction sent with hash:', transactionResult.hash);
    */
   async send(params) {
-    const hash = await (0, import_actions4.sendTransaction)(this.client.rpc, params);
+    const hash = await (0, import_actions5.sendTransaction)(this.client.rpc, params);
     return await this.get({ hash });
   }
 };
@@ -856,7 +817,7 @@ var AccountManager = class {
 };
 
 // src/managers/PersistenceManager.ts
-var import_actions5 = require("@mentaproject/core/actions");
+var import_actions6 = require("@mentaproject/core/actions");
 var PersistenceManager = class {
   /**
    * Creates an instance of PersistenceManager.
@@ -885,7 +846,7 @@ var PersistenceManager = class {
   async syncTransactions(account, limit = 1e5) {
     const lastSyncedBlock = await this.persistenceAdapter.getLastSyncedBlock(account.address);
     const lastBlock = lastSyncedBlock ?? 0n;
-    const fromBlock = lastSyncedBlock ? lastSyncedBlock + 1n : await (0, import_actions5.getBlockNumber)(this.client.rpc);
+    const fromBlock = lastSyncedBlock ? lastSyncedBlock + 1n : await (0, import_actions6.getBlockNumber)(this.client.rpc);
     const newTransactions = await account.transactions({
       fromBlock,
       toBlock: lastBlock,
@@ -900,22 +861,22 @@ var PersistenceManager = class {
 };
 
 // src/types/MentaClient.ts
-var import_actions6 = require("@mentaproject/core/actions");
+var import_actions7 = require("@mentaproject/core/actions");
 var ClientEvents = {
   /**
    * Event for new blocks.
    * Uses the {@link watchBlocks} function from `@mentaproject/core`.
    */
-  block: import_actions6.watchBlocks,
+  block: import_actions7.watchBlocks,
   /**
    * Event for new block numbers.
    * Uses the {@link watchBlockNumber} function from `@mentaproject/core`.
    */
-  blockNumber: import_actions6.watchBlockNumber
+  blockNumber: import_actions7.watchBlockNumber
 };
 
 // src/utils/withCache.ts
-var import_actions7 = require("@mentaproject/core/actions");
+var import_actions8 = require("@mentaproject/core/actions");
 var GET_NONCE_SELECTOR = "0x35567e1a";
 function isNonceCall(method, params) {
   if (method !== "eth_call") return false;
@@ -923,7 +884,7 @@ function isNonceCall(method, params) {
   return typeof callData === "string" && callData.startsWith(GET_NONCE_SELECTOR);
 }
 function withCache(client, cache) {
-  (0, import_actions7.watchBlockNumber)(client, {
+  (0, import_actions8.watchBlockNumber)(client, {
     onBlockNumber: (blockNumber) => {
       cache.setBlockNumber(blockNumber);
     },
@@ -1151,6 +1112,7 @@ var MemoryCache = class {
 0 && (module.exports = {
   Account,
   AccountManager,
+  Action,
   Block,
   BlockManager,
   ContractManager,