viem 0.0.0-portable-types-20230523145621 → 0.0.0-refactor-generics-20230831161903

package/src/utils/rpc.ts

@@ -2,7 +2,6 @@ import type { MessageEvent, WebSocket } from 'isomorphic-ws'
 
 import {
   HttpRequestError,
-  RpcRequestError,
   TimeoutError,
   WebSocketRequestError,
 } from '../errors/request.js'
@@ -41,7 +40,7 @@ type Subscription<TResult, TError> = {
   )
 }
 
-type RpcRequest = { method: string; params?: any }
+export type RpcRequest = { method: string; params?: any }
 
 export type RpcResponse<TResult = any, TError = any> = {
   jsonrpc: `${number}`
@@ -55,26 +54,39 @@ export type RpcResponse<TResult = any, TError = any> = {
 ///////////////////////////////////////////////////
 // HTTP
 
-export type HttpOptions = {
-  // The RPC request body.
-  body: RpcRequest
-  // Request configuration to pass to `fetch`.
-  fetchOptions?: Omit<RequestInit, 'body'>
-  // The timeout (in ms) for the request.
-  timeout?: number
-}
+export type HttpOptions<TBody extends RpcRequest | RpcRequest[] = RpcRequest,> =
+  {
+    // The RPC request body.
+    body: TBody
+    // Request configuration to pass to `fetch`.
+    fetchOptions?: Omit<RequestInit, 'body'>
+    // The timeout (in ms) for the request.
+    timeout?: number
+  }
 
-async function http(
+export type HttpReturnType<
+  TBody extends RpcRequest | RpcRequest[] = RpcRequest,
+> = TBody extends RpcRequest[] ? RpcResponse[] : RpcResponse
+
+async function http<TBody extends RpcRequest | RpcRequest[]>(
   url: string,
-  { body, fetchOptions = {}, timeout = 10_000 }: HttpOptions,
-) {
+  { body, fetchOptions = {}, timeout = 10_000 }: HttpOptions<TBody>,
+): Promise<HttpReturnType<TBody>> {
   const { headers, method, signal: signal_ } = fetchOptions
   try {
     const response = await withTimeout(
       async ({ signal }) => {
         const response = await fetch(url, {
           ...fetchOptions,
-          body: stringify({ jsonrpc: '2.0', id: id++, ...body }),
+          body: Array.isArray(body)
+            ? stringify(
+                body.map((body) => ({
+                  jsonrpc: '2.0',
+                  id: id++,
+                  ...body,
+                })),
+              )
+            : stringify({ jsonrpc: '2.0', id: id++, ...body }),
           headers: {
             ...headers,
             'Content-Type': 'application/json',
@@ -108,13 +120,9 @@ async function http(
       })
     }
 
-    if (data.error) {
-      throw new RpcRequestError({ body, error: data.error, url })
-    }
-    return data as RpcResponse
+    return data
   } catch (err) {
     if (err instanceof HttpRequestError) throw err
-    if (err instanceof RpcRequestError) throw err
     if (err instanceof TimeoutError) throw err
     throw new HttpRequestError({
       body,
@@ -136,19 +144,16 @@ export type Socket = WebSocket & {
   subscriptions: CallbackMap
 }
 
-const sockets = new Map<string, Socket>()
+const sockets = /*#__PURE__*/ new Map<string, Socket>()
 
-export async function getSocket(url_: string) {
-  const url = new URL(url_)
-  const urlKey = url.toString()
-
-  let socket = sockets.get(urlKey)
+export async function getSocket(url: string) {
+  let socket = sockets.get(url)
 
   // If the socket already exists, return it.
   if (socket) return socket
 
   const { schedule } = createBatchScheduler<undefined, [Socket]>({
-    id: urlKey,
+    id: url,
     fn: async () => {
       let WebSocket = await import('isomorphic-ws')
       // Workaround for Vite.
@@ -180,7 +185,7 @@ export async function getSocket(url_: string) {
         if (!isSubscription) cache.delete(id)
       }
       const onClose = () => {
-        sockets.delete(urlKey)
+        sockets.delete(url)
         webSocket.removeEventListener('close', onClose)
         webSocket.removeEventListener('message', onMessage)
       }
@@ -203,7 +208,7 @@ export async function getSocket(url_: string) {
         requests,
         subscriptions,
       })
-      sockets.set(urlKey, socket)
+      sockets.set(url, socket)
 
       return [socket]
     },
@@ -213,21 +218,19 @@ export async function getSocket(url_: string) {
   return socket_
 }
 
+export type WebSocketOptions = {
+  /** The RPC request body. */
+  body: RpcRequest
+  /** The callback to invoke on response. */
+  onResponse?: (message: RpcResponse) => void
+}
+
+export type WebSocketReturnType = Socket
+
 function webSocket(
   socket: Socket,
-  {
-    body,
-    onData,
-    onError,
-  }: {
-    // The RPC request body.
-    body: RpcRequest
-    // The callback to invoke when the request is successful.
-    onData?: (message: RpcResponse) => void
-    // The callback to invoke if the request errors.
-    onError?: (message: RpcResponse['error']) => void
-  },
-) {
+  { body, onResponse }: WebSocketOptions,
+): WebSocketReturnType {
   if (
     socket.readyState === socket.CLOSED ||
     socket.readyState === socket.CLOSING
@@ -245,13 +248,7 @@ function webSocket(
 
     if (typeof message.id === 'number' && id_ !== message.id) return
 
-    if (message.error) {
-      onError?.(
-        new RpcRequestError({ body, error: message.error, url: socket.url }),
-      )
-    } else {
-      onData?.(message)
-    }
+    onResponse?.(message)
 
     // If we are subscribing to a topic, we want to set up a listener for incoming
     // messages.
@@ -271,25 +268,25 @@ function webSocket(
   return socket
 }
 
+export type WebSocketAsyncOptions = {
+  /** The RPC request body. */
+  body: RpcRequest
+  /** The timeout (in ms) for the request. */
+  timeout?: number
+}
+
+export type WebSocketAsyncReturnType = RpcResponse
+
 async function webSocketAsync(
   socket: Socket,
-  {
-    body,
-    timeout = 10_000,
-  }: {
-    // The RPC request body.
-    body: RpcRequest
-    // The timeout (in ms) for the request.
-    timeout?: number
-  },
-) {
+  { body, timeout = 10_000 }: WebSocketAsyncOptions,
+): Promise<WebSocketAsyncReturnType> {
   return withTimeout(
     () =>
-      new Promise<RpcResponse>((onData, onError) =>
+      new Promise<RpcResponse>((onResponse) =>
         rpc.webSocket(socket, {
           body,
-          onData,
-          onError,
+          onResponse,
         }),
       ),
     {

package/src/utils/signature/hashMessage.ts

@@ -1,6 +1,6 @@
-import type { ByteArray, Hex } from '../../types/misc.js'
+import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
 import { concat } from '../data/concat.js'
-import { stringToBytes } from '../encoding/toBytes.js'
+import { stringToBytes, toBytes } from '../encoding/toBytes.js'
 import { keccak256 } from '../hash/keccak256.js'
 
 type To = 'hex' | 'bytes'
@@ -10,10 +10,14 @@ export type HashMessage<TTo extends To> =
   | (TTo extends 'hex' ? Hex : never)
 
 export function hashMessage<TTo extends To = 'hex'>(
-  message: string,
+  message: SignableMessage,
   to_?: TTo,
 ): HashMessage<TTo> {
-  const messageBytes = stringToBytes(message)
+  const messageBytes = (() => {
+    if (typeof message === 'string') return stringToBytes(message)
+    if (message.raw instanceof Uint8Array) return message.raw
+    return toBytes(message.raw)
+  })()
   const prefixBytes = stringToBytes(
     `\x19Ethereum Signed Message:\n${messageBytes.length}`,
   )

package/src/utils/signature/hashTypedData.ts

@@ -23,7 +23,7 @@ export type HashTypedDataParameters<
 export type HashTypedDataReturnType = Hex
 
 export function hashTypedData<
-  TTypedData extends TypedData | { [key: string]: unknown },
+  const TTypedData extends TypedData | { [key: string]: unknown },
   TPrimaryType extends string = string,
 >({
   domain: domain_,
@@ -34,9 +34,12 @@ export function hashTypedData<
   const domain: TypedDataDomain = typeof domain_ === 'undefined' ? {} : domain_
   const types = {
     EIP712Domain: [
-      domain?.name && { name: 'name', type: 'string' },
+      typeof domain?.name === 'string' && { name: 'name', type: 'string' },
       domain?.version && { name: 'version', type: 'string' },
-      domain?.chainId && { name: 'chainId', type: 'uint256' },
+      typeof domain?.chainId === 'number' && {
+        name: 'chainId',
+        type: 'uint256',
+      },
       domain?.verifyingContract && {
         name: 'verifyingContract',
         type: 'address',

package/src/utils/signature/hexToSignature.ts

@@ -0,0 +1,20 @@
+import { secp256k1 } from '@noble/curves/secp256k1'
+
+import type { Hex, Signature } from '../../types/misc.js'
+import { numberToHex } from '../../utils/encoding/toHex.js'
+
+/**
+ * @description Parses a hex formatted signature into a structured signature.
+ *
+ * @param signatureHex Signature in hex format.
+ * @returns The structured signature.
+ *
+ * @example
+ * hexToSignature('0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c')
+ * // { r: '0x...', s: '0x...', v: 28n }
+ */
+export function hexToSignature(signatureHex: Hex): Signature {
+  const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130))
+  const v = BigInt(`0x${signatureHex.slice(130)}`)
+  return { r: numberToHex(r), s: numberToHex(s), v }
+}

package/src/utils/signature/recoverMessageAddress.ts

@@ -1,12 +1,12 @@
 import type { Address } from 'abitype'
 
-import type { ByteArray, Hex } from '../../types/misc.js'
+import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
 
 import { hashMessage } from './hashMessage.js'
 import { recoverAddress } from './recoverAddress.js'
 
 export type RecoverMessageAddressParameters = {
-  message: string
+  message: SignableMessage
   signature: Hex | ByteArray
 }
 export type RecoverMessageAddressReturnType = Address

package/src/utils/signature/recoverTypedDataAddress.ts

@@ -15,7 +15,7 @@ export type RecoverTypedDataAddressParameters<
 export type RecoverTypedDataAddressReturnType = Address
 
 export async function recoverTypedDataAddress<
-  TTypedData extends TypedData | { [key: string]: unknown },
+  const TTypedData extends TypedData | { [key: string]: unknown },
   TPrimaryType extends string = string,
 >({
   domain,
@@ -33,7 +33,7 @@ export async function recoverTypedDataAddress<
       message,
       primaryType,
       types,
-    } as RecoverTypedDataAddressParameters),
+    } as unknown as RecoverTypedDataAddressParameters),
     signature,
   })
 }

package/src/utils/signature/signatureToHex.ts

@@ -0,0 +1,26 @@
+import { secp256k1 } from '@noble/curves/secp256k1'
+
+import type { Hex, Signature } from '../../types/misc.js'
+import { hexToBigInt } from '../../utils/encoding/fromHex.js'
+import { toHex } from '../../utils/encoding/toHex.js'
+
+/**
+ * @description Converts a signature into hex format.
+ *
+ * @param signature The signature to convert.
+ * @returns The signature in hex format.
+ *
+ * @example
+ * signatureToHex({
+ *   r: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',
+ *   s: '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
+ *   v: 28n
+ * })
+ * // "0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c"
+ */
+export function signatureToHex({ r, s, v }: Signature): Hex {
+  return `0x${new secp256k1.Signature(
+    hexToBigInt(r),
+    hexToBigInt(s),
+  ).toCompactHex()}${toHex(v).slice(2)}`
+}

package/src/utils/signature/verifyTypedData.ts

@@ -35,7 +35,7 @@ export type VerifyTypedDataReturnType = boolean
  * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}
  */
 export async function verifyTypedData<
-  TTypedData extends TypedData | { [key: string]: unknown },
+  const TTypedData extends TypedData | { [key: string]: unknown },
   TPrimaryType extends string = string,
 >({
   address,

package/src/utils/transaction/assertRequest.ts

@@ -6,7 +6,9 @@ import { FeeConflictError } from '../../errors/transaction.js'
 import type { Chain } from '../../types/chain.js'
 import { isAddress } from '../address/isAddress.js'
 
-export function assertRequest(args: Partial<SendTransactionParameters<Chain>>) {
+export type AssertRequestParameters = Partial<SendTransactionParameters<Chain>>
+
+export function assertRequest(args: AssertRequestParameters) {
   const {
     account: account_,
     gasPrice,

package/src/utils/transaction/getTransactionType.ts

@@ -1,24 +1,25 @@
 import { InvalidSerializableTransactionError } from '../../errors/transaction.js'
 import type {
-  AccessList,
   TransactionSerializable,
+  TransactionSerializableEIP1559,
+  TransactionSerializableEIP2930,
+  TransactionSerializableGeneric,
+  TransactionSerializableLegacy,
 } from '../../types/transaction.js'
 
 export type GetTransactionType<
   TTransactionSerializable extends TransactionSerializable = TransactionSerializable,
 > =
-  | (TTransactionSerializable['maxFeePerGas'] extends bigint
-      ? 'eip1559'
+  | (TTransactionSerializable extends TransactionSerializableLegacy
+      ? 'legacy'
       : never)
-  | (TTransactionSerializable['maxPriorityFeePerGas'] extends bigint
+  | (TTransactionSerializable extends TransactionSerializableEIP1559
       ? 'eip1559'
       : never)
-  | (TTransactionSerializable['gasPrice'] extends bigint
-      ? TTransactionSerializable['accessList'] extends AccessList
-        ? 'eip2930'
-        : 'legacy'
+  | (TTransactionSerializable extends TransactionSerializableEIP2930
+      ? 'eip2930'
       : never)
-  | (TTransactionSerializable['type'] extends string
+  | (TTransactionSerializable extends TransactionSerializableGeneric
       ? TTransactionSerializable['type']
       : never)
 

package/src/utils/transaction/parseTransaction.ts

@@ -66,10 +66,7 @@ export function parseTransaction<TSerialized extends TransactionSerialized>(
 function parseTransactionEIP1559(
   serializedTransaction: TransactionSerializedEIP1559,
 ): TransactionSerializableEIP1559 {
-  const transactionArray = fromRlp(
-    `0x${serializedTransaction.slice(4)}` as Hex,
-    'hex',
-  )
+  const transactionArray = toTransactionArray(serializedTransaction)
 
   const [
     chainId,
@@ -140,10 +137,7 @@ function parseTransactionEIP2930(
   serializedTransaction: TransactionSerializedEIP2930,
 ): Omit<TransactionRequestEIP2930, 'from'> &
   ({ chainId: number } | ({ chainId: number } & Signature)) {
-  const transactionArray = fromRlp(
-    `0x${serializedTransaction.slice(4)}` as Hex,
-    'hex',
-  )
+  const transactionArray = toTransactionArray(serializedTransaction)
 
   const [chainId, nonce, gasPrice, gas, to, value, data, accessList, v, r, s] =
     transactionArray
@@ -263,7 +257,11 @@ function parseTransactionLegacy(
   return transaction
 }
 
-function parseAccessList(accessList_: RecursiveArray<Hex>): AccessList {
+export function toTransactionArray(serializedTransaction: string) {
+  return fromRlp(`0x${serializedTransaction.slice(4)}` as Hex, 'hex')
+}
+
+export function parseAccessList(accessList_: RecursiveArray<Hex>): AccessList {
   const accessList: AccessList = []
   for (let i = 0; i < accessList_.length; i++) {
     const [address, storageKeys] = accessList_[i] as [Hex, Hex[]]

package/src/utils/transaction/serializeAccessList.ts

@@ -0,0 +1,39 @@
+import { InvalidAddressError } from '../../errors/address.js'
+import { InvalidStorageKeySizeError } from '../../errors/transaction.js'
+import type { Hex } from '../../types/misc.js'
+import type { AccessList } from '../../types/transaction.js'
+import { isAddress } from '../address/isAddress.js'
+import { type RecursiveArray } from '../encoding/toRlp.js'
+
+/*
+ * Serialize an  EIP-2930 access list
+ * @remarks
+ * Use to create a transaction serializer with support for EIP-2930 access lists
+ *
+ * @param accessList - Array of objects of address and arrays of Storage Keys
+ * @throws InvalidAddressError, InvalidStorageKeySizeError
+ * @returns Array of hex strings
+ */
+export function serializeAccessList(
+  accessList?: AccessList,
+): RecursiveArray<Hex> {
+  if (!accessList || accessList.length === 0) return []
+
+  const serializedAccessList: RecursiveArray<Hex> = []
+  for (let i = 0; i < accessList.length; i++) {
+    const { address, storageKeys } = accessList[i]
+
+    for (let j = 0; j < storageKeys.length; j++) {
+      if (storageKeys[j].length - 2 !== 64) {
+        throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] })
+      }
+    }
+
+    if (!isAddress(address)) {
+      throw new InvalidAddressError({ address })
+    }
+
+    serializedAccessList.push([address, storageKeys])
+  }
+  return serializedAccessList
+}

package/src/utils/transaction/serializeTransaction.ts

@@ -1,11 +1,6 @@
-import { InvalidAddressError } from '../../errors/address.js'
-import {
-  InvalidLegacyVError,
-  InvalidStorageKeySizeError,
-} from '../../errors/transaction.js'
-import type { Hex, Signature } from '../../types/misc.js'
+import { InvalidLegacyVError } from '../../errors/transaction.js'
+import type { Signature } from '../../types/misc.js'
 import type {
-  AccessList,
   TransactionSerializable,
   TransactionSerializableEIP1559,
   TransactionSerializableEIP2930,
@@ -16,11 +11,10 @@ import type {
   TransactionSerializedLegacy,
   TransactionType,
 } from '../../types/transaction.js'
-import { isAddress } from '../address/isAddress.js'
 import { concatHex } from '../data/concat.js'
 import { trim } from '../data/trim.js'
 import { toHex } from '../encoding/toHex.js'
-import { type RecursiveArray, toRlp } from '../encoding/toRlp.js'
+import { toRlp } from '../encoding/toRlp.js'
 
 import {
   assertTransactionEIP1559,
@@ -31,12 +25,17 @@ import {
   type GetTransactionType,
   getTransactionType,
 } from './getTransactionType.js'
+import { serializeAccessList } from './serializeAccessList.js'
 
 export type SerializedTransactionReturnType<
   TTransactionSerializable extends TransactionSerializable = TransactionSerializable,
   TTransactionType extends TransactionType = GetTransactionType<TTransactionSerializable>,
 > = TransactionSerialized<TTransactionType>
 
+export type SerializeTransactionFn<
+  TTransactionSerializable extends TransactionSerializable = TransactionSerializable,
+> = typeof serializeTransaction<TTransactionSerializable>
+
 export function serializeTransaction<
   TTransactionSerializable extends TransactionSerializable,
 >(
@@ -49,18 +48,18 @@ export function serializeTransaction<
     return serializeTransactionEIP1559(
       transaction as TransactionSerializableEIP1559,
       signature,
-    ) as SerializedTransactionReturnType
+    ) as SerializedTransactionReturnType<TTransactionSerializable>
 
   if (type === 'eip2930')
     return serializeTransactionEIP2930(
       transaction as TransactionSerializableEIP2930,
       signature,
-    ) as SerializedTransactionReturnType
+    ) as SerializedTransactionReturnType<TTransactionSerializable>
 
   return serializeTransactionLegacy(
     transaction as TransactionSerializableLegacy,
     signature,
-  ) as SerializedTransactionReturnType
+  ) as SerializedTransactionReturnType<TTransactionSerializable>
 }
 
 function serializeTransactionEIP1559(
@@ -183,25 +182,3 @@ function serializeTransactionLegacy(
 
   return toRlp(serializedTransaction)
 }
-
-function serializeAccessList(accessList?: AccessList): RecursiveArray<Hex> {
-  if (!accessList || accessList.length === 0) return []
-
-  const serializedAccessList: RecursiveArray<Hex> = []
-  for (let i = 0; i < accessList.length; i++) {
-    const { address, storageKeys } = accessList[i]
-
-    for (let j = 0; j < storageKeys.length; j++) {
-      if (storageKeys[j].length - 2 !== 64) {
-        throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] })
-      }
-    }
-
-    if (!isAddress(address)) {
-      throw new InvalidAddressError({ address })
-    }
-
-    serializedAccessList.push([address, storageKeys])
-  }
-  return serializedAccessList
-}

package/src/utils/typedData.ts

@@ -11,7 +11,7 @@ import { numberToHex } from './encoding/toHex.js'
 import { bytesRegex, integerRegex } from './regex.js'
 
 export function validateTypedData<
-  TTypedData extends TypedData | { [key: string]: unknown },
+  const TTypedData extends TypedData | { [key: string]: unknown },
   TPrimaryType extends string = string,
 >({
   domain,
@@ -63,8 +63,7 @@ export function validateTypedData<
   }
 
   // Validate domain types.
-  if (types['EIP712Domain'] && domain)
-    validateData(types['EIP712Domain'], domain)
+  if (types.EIP712Domain && domain) validateData(types.EIP712Domain, domain)
 
   if (primaryType !== 'EIP712Domain') {
     // Validate message types.

package/src/utils/unit/parseEther.ts

@@ -2,6 +2,6 @@ import { etherUnits } from '../../constants/unit.js'
 
 import { parseUnits } from './parseUnits.js'
 
-export function parseEther(ether: `${number}`, unit: 'wei' | 'gwei' = 'wei') {
+export function parseEther(ether: string, unit: 'wei' | 'gwei' = 'wei') {
   return parseUnits(ether, etherUnits[unit])
 }

package/src/utils/unit/parseGwei.ts

@@ -2,6 +2,6 @@ import { gweiUnits } from '../../constants/unit.js'
 
 import { parseUnits } from './parseUnits.js'
 
-export function parseGwei(ether: `${number}`, unit: 'wei' = 'wei') {
+export function parseGwei(ether: string, unit: 'wei' = 'wei') {
   return parseUnits(ether, gweiUnits[unit])
 }

package/src/utils/unit/parseUnits.ts

@@ -1,4 +1,4 @@
-export function parseUnits(value: `${number}`, decimals: number) {
+export function parseUnits(value: string, decimals: number) {
   let [integer, fraction = '0'] = value.split('.')
 
   const negative = integer.startsWith('-')
@@ -9,16 +9,27 @@ export function parseUnits(value: `${number}`, decimals: number) {
 
   // round off if the fraction is larger than the number of decimals.
   if (decimals === 0) {
-    integer = `${Math.round(Number(`${integer}.${fraction}`))}`
+    if (Math.round(Number(`.${fraction}`)) === 1)
+      integer = `${BigInt(integer) + 1n}`
     fraction = ''
   } else if (fraction.length > decimals) {
-    const [before, after] = [
-      fraction.slice(0, decimals),
+    const [left, unit, right] = [
+      fraction.slice(0, decimals - 1),
+      fraction.slice(decimals - 1, decimals),
       fraction.slice(decimals),
     ]
-    fraction = `${
-      /^0+$/.test(before) ? before.slice(0, before.length - 1) : ''
-    }${Math.round(Number(`${before}.${after}`))}`
+
+    const rounded = Math.round(Number(`${unit}.${right}`))
+    if (rounded > 9)
+      fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, '0')
+    else fraction = `${left}${rounded}`
+
+    if (fraction.length > decimals) {
+      fraction = fraction.slice(1)
+      integer = `${BigInt(integer) + 1n}`
+    }
+
+    fraction = fraction.slice(0, decimals)
   } else {
     fraction = fraction.padEnd(decimals, '0')
   }

package/src/wallet.ts

@@ -17,7 +17,6 @@ export {
 } from './actions/wallet/requestPermissions.js'
 export {
   sendTransaction,
-  type FormattedTransactionRequest,
   type SendTransactionParameters,
   type SendTransactionReturnType,
 } from './actions/wallet/sendTransaction.js'

package/dist/cjs/accounts/utils/signatureToHex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"signatureToHex.js","sourceRoot":"","sources":["../../../../src/accounts/utils/signatureToHex.ts"],"names":[],"mappings":";;;AAAA,uDAAmD;AAGnD,gEAA6D;AAC7D,4DAAqD;AAErD,SAAgB,cAAc,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAa;IACnD,OAAO,KAAK,IAAI,qBAAS,CAAC,SAAS,CACjC,IAAA,wBAAW,EAAC,CAAC,CAAC,EACd,IAAA,wBAAW,EAAC,CAAC,CAAC,CACf,CAAC,YAAY,EAAE,GAAG,IAAA,gBAAK,EAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;AACxC,CAAC;AALD,wCAKC"}