@toruslabs/ethereum-controllers 8.17.0 → 9.0.0

package/dist/lib.cjs/types/utils/interfaces.d.ts

@@ -2,15 +2,25 @@ import { Implementation, toMetaMaskSmartAccount } from "@metamask/smart-accounts
 import { BASE_TX_EVENT_TYPE, BaseBlockTrackerState, BaseControllerEvents, BaseFormattedTransactionActivity, BaseTokenInfo, BaseTransactionEvents, MESSAGE_EVENTS, MessageStatus, NetworkConfig, NetworkState, PaymentTransaction, PollingBlockTrackerConfig, PopupWhitelabelData, ProviderConfig, TRANSACTION_TYPE, TransactionMeta, TransactionState, TransactionStatus, TX_CONFIRMED_EVENT_TYPE, TX_DROPPED_EVENT_TYPE, TX_EVENTS, TX_FAILED_EVENT_TYPE, TX_WARNING_EVENT_TYPE, User } from "@toruslabs/base-controllers";
 import { JRPCRequest, Json } from "@web3auth/auth";
 import { MutexInterface } from "async-mutex";
-import { AccessList, TypedDataDomain, TypedDataField } from "ethers";
 import { ToBiconomySmartAccountParameters, toEcdsaKernelSmartAccount, ToLightSmartAccountParameters, ToNexusSmartAccountParameters, toSafeSmartAccount, toSimpleSmartAccount, toTrustSmartAccount } from "permissionless/accounts";
-import { Client, Hex, WalletClient } from "viem";
+import { Client, Hex, Signature, WalletClient } from "viem";
 import { createBundlerClient, createPaymasterClient, SmartAccount, UserOperationReceipt, WebAuthnAccount } from "viem/account-abstraction";
 import { METHOD_TYPES, SMART_ACCOUNT, TRANSACTION_ENVELOPE_TYPES } from "./constants";
 import { NestedTransactionMetadata } from "./eip5792Types";
 import { Authorization } from "./eip7702Types";
 export type { BatchTransactionParams, NestedTransactionMetadata, TransactionBatchRequest, TransactionBatchSingleRequest } from "./eip5792Types";
 export type { Authorization, Eip7702Params, Eip7702WalletGetUpgradeStatusResponse, SignedAuthorization } from "./eip7702Types";
+export type TypedDataField = {
+    name: string;
+    type: string;
+};
+export type TypedDataDomain = {
+    name?: string;
+    version?: string;
+    chainId?: number | string;
+    verifyingContract?: string;
+    salt?: string;
+};
 export type CustomTokenInfo = BaseTokenInfo & {
     erc20: boolean;
     customTokenId?: string;
@@ -61,6 +71,7 @@ export interface Message extends AbstractMessage {
     messageParams: MessageParams;
 }
 export type SignTypedDataMessageV4 = {
+    primaryType: string;
     types: Record<string, TypedDataField[]>;
     domain: TypedDataDomain;
     message: Record<string, unknown>;
@@ -504,3 +515,195 @@ export interface UserOperationGas {
  * Type Def for function to query the deployment bytecode of an address. (eth_getCode)
  */
 export type GetEthCodeFn = (address: `0x${string}`, chainId: `0x${string}`) => Promise<`0x${string}`>;
+/**
+ *  A [[HexString]] whose length is even, which ensures it is a valid
+ *  representation of binary data.
+ */
+export type DataHexString = Hex;
+/**
+ *  An object that can be used to represent binary data.
+ */
+export type BytesLike = DataHexString | Uint8Array;
+/**
+ *  A BLOb object that can be passed for [[link-eip-4844]]
+ *  transactions.
+ *
+ *  It may have had its commitment and proof already provided
+ *  or rely on an attached [[KzgLibrary]] to compute them.
+ */
+export type BlobLike = BytesLike | {
+    data: BytesLike;
+    proof: BytesLike;
+    commitment: BytesLike;
+};
+/**
+ *  A KZG Library with the necessary functions to compute
+ *  BLOb commitments and proofs.
+ */
+export interface KzgLibrary {
+    blobToKzgCommitment: (blob: Uint8Array) => Uint8Array;
+    computeBlobKzgProof: (blob: Uint8Array, commitment: Uint8Array) => Uint8Array;
+}
+/**
+ *  A KZG Library with any of the various API configurations.
+ *  As the library is still experimental and the API is not
+ *  stable, depending on the version used the method names and
+ *  signatures are still in flux.
+ *
+ *  This allows any of the versions to be passed into Transaction
+ *  while providing a stable external API.
+ */
+export type KzgLibraryLike = KzgLibrary | {
+    blobToKZGCommitment: (blob: string) => string;
+    computeBlobKZGProof: (blob: string, commitment: string) => string;
+} | {
+    blobToKzgCommitment: (blob: string) => string | Uint8Array;
+    computeBlobProof: (blob: string, commitment: string) => string | Uint8Array;
+};
+/**
+ *  Any type that can be used where a numeric value is needed.
+ */
+export type Numeric = number | bigint;
+/**
+ *  Any type that can be used where a big number is needed.
+ */
+export type BigNumberish = string | Numeric;
+/**
+ *  A SignatureLike
+ *
+ *  @_docloc: api/crypto:Signing
+ */
+export type SignatureLike = Signature | string | {
+    r: string;
+    s: string;
+    v: BigNumberish;
+    yParity?: 0 | 1;
+    yParityAndS?: string;
+} | {
+    r: string;
+    yParityAndS: string;
+    yParity?: 0 | 1;
+    s?: string;
+    v?: number;
+} | {
+    r: string;
+    s: string;
+    yParity: 0 | 1;
+    v?: BigNumberish;
+    yParityAndS?: string;
+};
+/**
+ *  A **TransactionLike** is an object which is appropriate as a loose
+ *  input for many operations which will populate missing properties of
+ *  a transaction.
+ */
+/**
+ *  A single [[AccessList]] entry of storage keys (slots) for an address.
+ */
+export type AccessListEntry = {
+    address: string;
+    storageKeys: Array<string>;
+};
+/**
+ *  An ordered collection of [[AccessList]] entries.
+ */
+export type AccessList = Array<AccessListEntry>;
+/**
+ *  Any ethers-supported access list structure.
+ */
+export type AccessListish = AccessList | Array<[string, Array<string>]> | Record<string, Array<string>>;
+export interface AuthorizationLike {
+    address: string;
+    nonce: bigint;
+    chainId: bigint;
+    signature: SignatureLike;
+}
+export interface TransactionLike<A = string> {
+    /**
+     *  The type.
+     */
+    type?: null | number;
+    /**
+     *  The recipient address or ``null`` for an ``init`` transaction.
+     */
+    to?: null | A;
+    /**
+     *  The sender.
+     */
+    from?: null | A;
+    /**
+     *  The nonce.
+     */
+    nonce?: null | number;
+    /**
+     *  The maximum amount of gas that can be used.
+     */
+    gasLimit?: null | BigNumberish;
+    /**
+     *  The gas price for legacy and berlin transactions.
+     */
+    gasPrice?: null | BigNumberish;
+    /**
+     *  The maximum priority fee per gas for london transactions.
+     */
+    maxPriorityFeePerGas?: null | BigNumberish;
+    /**
+     *  The maximum total fee per gas for london transactions.
+     */
+    maxFeePerGas?: null | BigNumberish;
+    /**
+     *  The data.
+     */
+    data?: null | string;
+    /**
+     *  The value (in wei) to send.
+     */
+    value?: null | BigNumberish;
+    /**
+     *  The chain ID the transaction is valid on.
+     */
+    chainId?: null | BigNumberish;
+    /**
+     *  The transaction hash.
+     */
+    hash?: null | string;
+    /**
+     *  The signature provided by the sender.
+     */
+    signature?: null | SignatureLike;
+    /**
+     *  The access list for berlin and london transactions.
+     */
+    accessList?: null | AccessListish;
+    /**
+     *  The maximum fee per blob gas (see [[link-eip-4844]]).
+     */
+    maxFeePerBlobGas?: null | BigNumberish;
+    /**
+     *  The versioned hashes (see [[link-eip-4844]]).
+     */
+    blobVersionedHashes?: null | Array<string>;
+    /**
+     *  The blobs (if any) attached to this transaction (see [[link-eip-4844]]).
+     */
+    blobs?: null | Array<BlobLike>;
+    /**
+     *  An external library for computing the KZG commitments and
+     *  proofs necessary for EIP-4844 transactions (see [[link-eip-4844]]).
+     *
+     *  This is generally ``null``, unless you are creating BLOb
+     *  transactions.
+     */
+    kzg?: null | KzgLibraryLike;
+    /**
+     *  The [[link-eip-7594]] BLOb Wrapper Version used for PeerDAS.
+     *
+     *  For networks that use EIP-7594, this property is required to
+     *  serialize the sidecar correctly.
+     */
+    blobWrapperVersion?: null | number;
+    /**
+     *  The [[link-eip-7702]] authorizations (if any).
+     */
+    authorizationList?: null | Array<AuthorizationLike>;
+}

package/dist/lib.cjs/types/utils/transaction.d.ts

@@ -3,4 +3,4 @@ import { JRPCRequest } from "@web3auth/auth";
  * Transaction decoder for analytics.
  * Decodes eth_sendRawTransaction and eth_sendUserOperation requests.
  */
-export declare const transactionDecoder: (req: JRPCRequest<unknown>, chainId: string) => [string, string];
+export declare const transactionDecoder: (req: JRPCRequest<unknown>, chainId: string) => Promise<[sender: string, txHash: string]>;

package/dist/lib.cjs/types/utils/viem.d.ts

@@ -0,0 +1,8 @@
+import { TransactionSerializable } from "viem";
+import { TransactionLike } from "./interfaces";
+/**
+ * Prepare transaction params for signing.
+ * @param tx - The transaction to prepare.
+ * @returns The prepared transaction.
+ */
+export declare function prepareViemTx(tx: TransactionLike): TransactionSerializable;

package/dist/lib.cjs/utils/abis.js

@@ -9,6 +9,7 @@ const erc20Abi = [{
     type: "string"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: false,
@@ -25,6 +26,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: true,
@@ -35,6 +37,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: false,
@@ -54,6 +57,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: true,
@@ -64,6 +68,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: true,
@@ -77,6 +82,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: true,
@@ -87,6 +93,7 @@ const erc20Abi = [{
     type: "string"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   constant: false,
@@ -103,6 +110,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: false,
@@ -122,6 +130,7 @@ const erc20Abi = [{
     type: "bool"
   }],
   payable: false,
+  stateMutability: "nonpayable",
   type: "function"
 }, {
   constant: true,
@@ -138,6 +147,7 @@ const erc20Abi = [{
     type: "uint256"
   }],
   payable: false,
+  stateMutability: "view",
   type: "function"
 }, {
   inputs: [{
@@ -153,9 +163,11 @@ const erc20Abi = [{
     name: "_tokenSymbol",
     type: "string"
   }],
+  stateMutability: "nonpayable",
   type: "constructor"
 }, {
   payable: false,
+  stateMutability: "nonpayable",
   type: "fallback"
 }];
 const erc721Abi = [{

package/dist/lib.cjs/utils/conversionUtils.js

@@ -3,9 +3,8 @@
 var _objectDestructuringEmpty = require('@babel/runtime/helpers/objectDestructuringEmpty');
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
-var util = require('@ethereumjs/util');
 var bignumber_js = require('bignumber.js');
-var BN = require('bn.js');
+var hex = require('./hex.js');
 
 const _excluded = ["aBase", "bBase"],
   _excluded2 = ["aBase", "bBase"],
@@ -16,7 +15,7 @@ const BIG_NUMBER_GWEI_MULTIPLIER = new bignumber_js.BigNumber("1000000000");
 const BIG_NUMBER_ETH_MULTIPLIER = new bignumber_js.BigNumber("1");
 // Setter Maps
 const toBigNumber = {
-  hex: n => new bignumber_js.BigNumber(util.stripHexPrefix(n), 16),
+  hex: n => new bignumber_js.BigNumber(hex.stripHexPrefix(n), 16),
   dec: n => new bignumber_js.BigNumber(String(n), 10),
   BN: n => new bignumber_js.BigNumber(n.toString(16), 16)
 };
@@ -33,7 +32,7 @@ const toSpecifiedDenomination = {
 const baseChange = {
   hex: n => n.toString(16),
   dec: n => new bignumber_js.BigNumber(n).toString(10),
-  BN: n => new BN(n.toString(16))
+  BN: n => new bignumber_js.BigNumber(n.toString(16))
 };
 // Utility function for checking base types
 const isValidBase = base => Number.isInteger(base) && base > 1;

package/dist/lib.cjs/utils/eip5792Types.js

@@ -9,7 +9,6 @@ const EIP_5792_METHODS = {
   WALLET_GET_CALLS_STATUS: "wallet_getCallsStatus",
   WALLET_SHOW_CALLS_STATUS: "wallet_showCallsStatus"
 };
-const SUPPORTED_EIP_5792_VERSIONS = ["1.0", "2.0"];
 const EIP5792ErrorCode = {
   UnsupportedNonOptionalCapability: 5700,
   UnsupportedChainId: 5710,
@@ -38,4 +37,3 @@ exports.EIP5792ErrorCode = EIP5792ErrorCode;
 exports.EIP_5792_METHODS = EIP_5792_METHODS;
 exports.Eip5792AtomicStatus = Eip5792AtomicStatus;
 exports.GetCallsStatusCode = GetCallsStatusCode;
-exports.SUPPORTED_EIP_5792_VERSIONS = SUPPORTED_EIP_5792_VERSIONS;

package/dist/lib.cjs/utils/helpers.js

@@ -1,18 +1,19 @@
 'use strict';
 
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
-var util = require('@ethereumjs/util');
 var baseControllers = require('@toruslabs/base-controllers');
 var bignumber_js = require('bignumber.js');
 var log = require('loglevel');
+var viem = require('viem');
 var TransactionUtils = require('../Transaction/TransactionUtils.js');
 var constants = require('./constants.js');
+var hex = require('./hex.js');
 
-function hexToBn(hex) {
-  return new bignumber_js.BigNumber(util.stripHexPrefix(hex), 16);
+function hexToBn(hex$1) {
+  return new bignumber_js.BigNumber(hex.stripHexPrefix(hex$1), 16);
 }
 function BNToHex(bn) {
-  return util.addHexPrefix(bn.toString(16));
+  return hex.addHexPrefix(bn.toString(16));
 }
 function getEtherScanHashLink(txHash, chainId) {
   if (!constants.SUPPORTED_NETWORKS[chainId]) return "";
@@ -94,18 +95,18 @@ function formatTime(time) {
 }
 function isAddressByChainId(address, _chainId) {
   // TOOD: add rsk network checks.
-  return util.isValidAddress(address);
+  return viem.isAddress(address);
 }
 function toChecksumAddressByChainId(address, chainId) {
   // TOOD: add rsk network checks.
   if (!isAddressByChainId(address)) return address;
-  return util.toChecksumAddress(address);
+  return viem.getAddress(address);
 }
 const GAS_LIMITS = {
   // maximum gasLimit of a simple send
-  SIMPLE: util.addHexPrefix(21000 .toString(16)),
+  SIMPLE: viem.toHex(21000),
   // a base estimate for token transfers.
-  BASE_TOKEN_ESTIMATE: util.addHexPrefix(100000 .toString(16))
+  BASE_TOKEN_ESTIMATE: viem.toHex(100000)
 };
 function bnLessThan(a, b) {
   if (a === null || a === undefined || b === null || b === undefined) {

package/dist/lib.cjs/utils/hex.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var viem = require('viem');
+
+/**
+ * Removes '0x' from a given `String` if present
+ */
+const stripHexPrefix = str => {
+  if (typeof str !== "string") throw new Error(`[stripHexPrefix] input must be type 'string', received ${typeof str}`);
+  return viem.isHex(str) ? str.slice(2) : str;
+};
+/**
+ * Adds "0x" to a given `string` if it does not already start with "0x".
+ */
+const addHexPrefix = str => {
+  if (typeof str !== "string") {
+    return str;
+  }
+  return viem.isHex(str) ? str : `0x${str}`;
+};
+
+exports.addHexPrefix = addHexPrefix;
+exports.stripHexPrefix = stripHexPrefix;

package/dist/lib.cjs/utils/transaction.js

@@ -1,29 +1,25 @@
 'use strict';
 
-var common = require('@ethereumjs/common');
-var tx = require('@ethereumjs/tx');
-var util = require('@ethereumjs/util');
 var log = require('loglevel');
+var viem = require('viem');
 var constants = require('./constants.js');
+var hex = require('./hex.js');
 
 /**
  * Transaction decoder for analytics.
  * Decodes eth_sendRawTransaction and eth_sendUserOperation requests.
  */
-const transactionDecoder = (req, chainId) => {
+const transactionDecoder = async (req, chainId) => {
   let sender = "";
   let txHash = "";
   try {
     if (req.method === constants.METHOD_TYPES.ETH_SEND_RAW_TRANSACTION) {
       const rawTx = req.params[0];
-      const txBytes = util.hexToBytes(util.addHexPrefix(rawTx));
-      const tx$1 = tx.createTxFromRLP(txBytes, {
-        common: common.createCustomCommon({
-          chainId
-        }, common.Mainnet)
+      const normalizedRawTx = hex.addHexPrefix(rawTx);
+      sender = await viem.recoverTransactionAddress({
+        serializedTransaction: normalizedRawTx
       });
-      sender = tx$1.getSenderAddress().toString();
-      txHash = util.bytesToHex(tx$1.hash());
+      txHash = viem.keccak256(normalizedRawTx);
     } else if (req.method === constants.METHOD_TYPES.ETH_SEND_USER_OPERATION) {
       const userOpReq = req;
       sender = userOpReq.params.map(p => p.sender).join(",");