viem 0.0.0-w-20230822145918 → 0.0.0-w-20230829165118

package/src/actions/wallet/prepareTransactionRequest.ts

@@ -0,0 +1,179 @@
+import type { Account } from '../../accounts/types.js'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import { internal_estimateFeesPerGas } from '../../actions/public/estimateFeesPerGas.js'
+import {
+  type EstimateGasParameters,
+  estimateGas,
+} from '../../actions/public/estimateGas.js'
+import { getBlock } from '../../actions/public/getBlock.js'
+import { getTransactionCount } from '../../actions/public/getTransactionCount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../errors/account.js'
+import {
+  Eip1559FeesNotSupportedError,
+  MaxFeePerGasTooLowError,
+} from '../../errors/fee.js'
+import type { GetAccountParameter } from '../../types/account.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetChain } from '../../types/chain.js'
+import type { TransactionSerializable } from '../../types/transaction.js'
+import type { UnionOmit } from '../../types/utils.js'
+import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
+import type { AssertRequestParameters } from '../../utils/transaction/assertRequest.js'
+import { assertRequest } from '../../utils/transaction/assertRequest.js'
+import { getTransactionType } from '../../utils/transaction/getTransactionType.js'
+
+export type PrepareTransactionRequestParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+> = UnionOmit<
+  FormattedTransactionRequest<
+    TChainOverride extends Chain ? TChainOverride : TChain
+  >,
+  'from'
+> &
+  GetAccountParameter<TAccount> &
+  GetChain<TChain, TChainOverride>
+
+export type PrepareTransactionRequestReturnType<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+> = UnionOmit<
+  FormattedTransactionRequest<
+    TChainOverride extends Chain ? TChainOverride : TChain
+  >,
+  'from'
+> &
+  GetAccountParameter<TAccount> &
+  GetChain<TChain, TChainOverride>
+
+/**
+ * Prepares a transaction request for signing.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/prepareTransactionRequest.html
+ *
+ * @param args - {@link PrepareTransactionRequestParameters}
+ * @returns The transaction request. {@link PrepareTransactionRequestReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { prepareTransactionRequest } from 'viem/actions'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const request = await prepareTransactionRequest(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { prepareTransactionRequest } from 'viem/actions'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const request = await prepareTransactionRequest(client, {
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ */
+export async function prepareTransactionRequest<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
+): Promise<
+  PrepareTransactionRequestReturnType<TChain, TAccount, TChainOverride>
+> {
+  const { account: account_ = client.account, chain, gas, nonce, type } = args
+  if (!account_) throw new AccountNotFoundError()
+  const account = parseAccount(account_)
+
+  const block = await getBlock(client, { blockTag: 'latest' })
+
+  const request = { ...args, from: account.address }
+
+  if (typeof nonce === 'undefined')
+    request.nonce = await getTransactionCount(client, {
+      address: account.address,
+      blockTag: 'pending',
+    })
+
+  if (typeof type === 'undefined') {
+    try {
+      request.type = getTransactionType(
+        request as TransactionSerializable,
+      ) as any
+    } catch {
+      // infer type from block
+      request.type =
+        typeof block.baseFeePerGas === 'bigint' ? 'eip1559' : 'legacy'
+    }
+  }
+
+  if (request.type === 'eip1559') {
+    // EIP-1559 fees
+    const { maxFeePerGas, maxPriorityFeePerGas } =
+      await internal_estimateFeesPerGas(client, {
+        block,
+        chain,
+        request: request as PrepareTransactionRequestParameters,
+      })
+
+    if (
+      typeof args.maxPriorityFeePerGas === 'undefined' &&
+      args.maxFeePerGas &&
+      args.maxFeePerGas < maxPriorityFeePerGas
+    )
+      throw new MaxFeePerGasTooLowError({
+        maxPriorityFeePerGas,
+      })
+
+    request.maxPriorityFeePerGas = maxPriorityFeePerGas
+    request.maxFeePerGas = maxFeePerGas
+  } else {
+    // Legacy fees
+    if (
+      typeof args.maxFeePerGas !== 'undefined' ||
+      typeof args.maxPriorityFeePerGas !== 'undefined'
+    )
+      throw new Eip1559FeesNotSupportedError()
+
+    const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
+      block,
+      chain,
+      request: request as PrepareTransactionRequestParameters,
+      type: 'legacy',
+    })
+    request.gasPrice = gasPrice_
+  }
+
+  if (typeof gas === 'undefined')
+    request.gas = await estimateGas(client, {
+      ...request,
+      account: { address: account.address, type: 'json-rpc' },
+    } as EstimateGasParameters)
+
+  assertRequest(request as AssertRequestParameters)
+
+  return request as PrepareTransactionRequestReturnType<
+    TChain,
+    TAccount,
+    TChainOverride
+  >
+}

package/src/actions/wallet/sendRawTransaction.ts

@@ -0,0 +1,48 @@
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Chain } from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
+import type { TransactionSerialized } from '../../types/transaction.js'
+
+export type SendRawTransactionParameters = {
+  /**
+   * The signed serialized tranasction.
+   */
+  serializedTransaction: TransactionSerialized
+}
+
+export type SendRawTransactionReturnType = Hash
+
+/**
+ * Sends a **signed** transaction to the network
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/sendRawTransaction.html
+ * - JSON-RPC Method: [`eth_sendRawTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendRawTransactionParameters}
+ * @returns The transaction hash. {@link SendRawTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { sendRawTransaction } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const hash = await sendRawTransaction(client, {
+ *   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+ * })
+ */
+export async function sendRawTransaction<TChain extends Chain | undefined,>(
+  client: Client<Transport, TChain>,
+  { serializedTransaction }: SendRawTransactionParameters,
+): Promise<SendRawTransactionReturnType> {
+  return client.request({
+    method: 'eth_sendRawTransaction',
+    params: [serializedTransaction],
+  })
+}

package/src/actions/wallet/sendTransaction.ts

@@ -5,7 +5,8 @@ import type { Transport } from '../../clients/transports/createTransport.js'
 import { AccountNotFoundError } from '../../errors/account.js'
 import type { BaseError } from '../../errors/base.js'
 import type { GetAccountParameter } from '../../types/account.js'
-import type { Chain, GetChain } from '../../types/chain.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetChain } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
 import type {
   TransactionRequest,
@@ -23,8 +24,9 @@ import {
   type AssertRequestParameters,
   assertRequest,
 } from '../../utils/transaction/assertRequest.js'
-import { prepareRequest } from '../../utils/transaction/prepareRequest.js'
 import { getChainId } from '../public/getChainId.js'
+import { prepareTransactionRequest } from './prepareTransactionRequest.js'
+import { sendRawTransaction } from './sendRawTransaction.js'
 
 export type SendTransactionParameters<
   TChain extends Chain | undefined = Chain | undefined,
@@ -129,7 +131,7 @@ export async function sendTransaction<
 
     if (account.type === 'local') {
       // Prepare the request for signing (assign appropriate fees, etc.)
-      const request = await prepareRequest(client, {
+      const request = await prepareTransactionRequest(client, {
         account,
         accessList,
         chain,
@@ -147,16 +149,15 @@ export async function sendTransaction<
       if (!chainId) chainId = await getChainId(client)
 
       const serializer = chain?.serializers?.transaction
-      const signedRequest = (await account.signTransaction(
+      const serializedTransaction = (await account.signTransaction(
         {
           ...request,
           chainId,
         } as TransactionSerializable,
         { serializer },
       )) as Hash
-      return await client.request({
-        method: 'eth_sendRawTransaction',
-        params: [signedRequest],
+      return await sendRawTransaction(client, {
+        serializedTransaction,
       })
     }
 

package/src/actions/wallet/signTransaction.ts

@@ -0,0 +1,137 @@
+import type { Account } from '../../accounts/types.js'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../errors/account.js'
+import type { GetAccountParameter } from '../../types/account.js'
+import type { Chain, GetChain } from '../../types/chain.js'
+import { type RpcTransactionRequest } from '../../types/rpc.js'
+import type {
+  TransactionRequest,
+  TransactionSerializable,
+  TransactionSerialized,
+} from '../../types/transaction.js'
+import type { UnionOmit } from '../../types/utils.js'
+import { assertCurrentChain } from '../../utils/chain.js'
+import {
+  type FormattedTransactionRequest,
+  formatTransactionRequest,
+} from '../../utils/formatters/transactionRequest.js'
+import { numberToHex } from '../../utils/index.js'
+import { assertRequest } from '../../utils/transaction/assertRequest.js'
+import { getChainId } from '../public/getChainId.js'
+
+export type SignTransactionParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+> = UnionOmit<
+  FormattedTransactionRequest<
+    TChainOverride extends Chain ? TChainOverride : TChain
+  >,
+  'from'
+> &
+  GetAccountParameter<TAccount> &
+  GetChain<TChain, TChainOverride>
+
+export type SignTransactionReturnType = TransactionSerialized
+
+/**
+ * Signs a transaction.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/signTransaction.html
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`eth_signTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+ *   - Local Accounts: Signs locally. No JSON-RPC request.
+ *
+ * @param args - {@link SignTransactionParameters}
+ * @returns The signed serialized tranasction. {@link SignTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signTransaction } from 'viem/actions'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTransaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signTransaction } from 'viem/actions'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTransaction(client, {
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ */
+export async function signTransaction<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: SignTransactionParameters<TChain, TAccount, TChainOverride>,
+): Promise<SignTransactionReturnType> {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    ...transaction
+  } = args
+
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/docs/actions/wallet/signTransaction',
+    })
+  const account = parseAccount(account_)
+
+  assertRequest({
+    account,
+    ...args,
+  })
+
+  const chainId = await getChainId(client)
+  if (chain !== null)
+    assertCurrentChain({
+      currentChainId: chainId,
+      chain,
+    })
+
+  const formatters = chain?.formatters || client.chain?.formatters
+  const format =
+    formatters?.transactionRequest?.format || formatTransactionRequest
+
+  if (account.type === 'local')
+    return account.signTransaction(
+      {
+        chainId,
+        ...transaction,
+      } as unknown as TransactionSerializable,
+      { serializer: client.chain?.serializers?.transaction },
+    ) as Promise<SignTransactionReturnType>
+
+  return await client.request({
+    method: 'eth_signTransaction',
+    params: [
+      {
+        ...format(transaction as unknown as TransactionRequest),
+        chainId: numberToHex(chainId),
+        from: account.address,
+      } as unknown as RpcTransactionRequest,
+    ],
+  })
+}

package/src/chains/celo/formatters.ts

@@ -1,5 +1,6 @@
 import { type ChainFormatters } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
+import type { RpcTransaction } from '../../types/rpc.js'
 import { hexToBigInt } from '../../utils/encoding/fromHex.js'
 import { numberToHex } from '../../utils/encoding/toHex.js'
 import { defineBlock } from '../../utils/formatters/block.js'
@@ -12,13 +13,11 @@ import { defineTransactionRequest } from '../../utils/formatters/transactionRequ
 import type {
   CeloBlockOverrides,
   CeloRpcTransaction,
-  CeloRpcTransactionOverrides,
   CeloRpcTransactionReceiptOverrides,
-  CeloRpcTransactionRequestOverrides,
+  CeloRpcTransactionRequest,
   CeloTransaction,
-  CeloTransactionOverrides,
   CeloTransactionReceiptOverrides,
-  CeloTransactionRequestOverrides,
+  CeloTransactionRequest,
 } from './types.js'
 
 export const formattersCelo = {
@@ -34,7 +33,7 @@ export const formattersCelo = {
       const transactions = args.transactions?.map((transaction) => {
         if (typeof transaction === 'string') return transaction
         return {
-          ...formatTransaction(transaction),
+          ...formatTransaction(transaction as RpcTransaction),
           feeCurrency: transaction.feeCurrency,
           gatewayFee: transaction.gatewayFee
             ? hexToBigInt(transaction.gatewayFee)
@@ -49,12 +48,12 @@ export const formattersCelo = {
     },
   }),
   transaction: /*#__PURE__*/ defineTransaction({
-    format(args: CeloRpcTransactionOverrides): CeloTransactionOverrides {
+    format(args: CeloRpcTransaction): CeloTransaction {
       return {
         feeCurrency: args.feeCurrency,
         gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
         gatewayFeeRecipient: args.gatewayFeeRecipient,
-      }
+      } as CeloTransaction
     },
   }),
   transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
@@ -69,17 +68,17 @@ export const formattersCelo = {
     },
   }),
   transactionRequest: /*#__PURE__*/ defineTransactionRequest({
-    format(
-      args: CeloTransactionRequestOverrides,
-    ): CeloRpcTransactionRequestOverrides {
-      return {
+    format(args: CeloTransactionRequest): CeloRpcTransactionRequest {
+      const request = {
         feeCurrency: args.feeCurrency,
         gatewayFee:
           typeof args.gatewayFee !== 'undefined'
             ? numberToHex(args.gatewayFee)
             : undefined,
         gatewayFeeRecipient: args.gatewayFeeRecipient,
-      }
+      } as CeloRpcTransactionRequest
+      if (args.type === 'cip42') request.type = '0x7c'
+      return request
     },
   }),
 } as const satisfies ChainFormatters

package/src/chains/celo/parsers.ts

@@ -0,0 +1,123 @@
+import { InvalidSerializedTransactionError } from '../../errors/transaction.js'
+import type { Hex } from '../../types/misc.js'
+import { isHex } from '../../utils/data/isHex.js'
+import { sliceHex } from '../../utils/data/slice.js'
+import { hexToBigInt, hexToNumber } from '../../utils/encoding/fromHex.js'
+import type { RecursiveArray } from '../../utils/encoding/toRlp.js'
+import type { GetSerializedTransactionType } from '../../utils/transaction/getSerializedTransactionType.js'
+import {
+  type ParseTransactionReturnType,
+  parseAccessList,
+  parseTransaction,
+  toTransactionArray,
+} from '../../utils/transaction/parseTransaction.js'
+import { assertTransactionCIP42 } from './serializers.js'
+import type {
+  CeloTransactionSerialized,
+  CeloTransactionType,
+  TransactionSerializableCIP42,
+  TransactionSerializedCIP42,
+} from './types.js'
+
+export type ParseTransactionCeloReturnType<
+  TSerialized extends CeloTransactionSerialized = CeloTransactionSerialized,
+  TType extends CeloTransactionType = GetSerializedTransactionType<TSerialized>,
+> = TSerialized extends TransactionSerializedCIP42
+  ? TransactionSerializableCIP42
+  : ParseTransactionReturnType<TSerialized, TType>
+
+export function parseTransactionCelo<
+  TSerialized extends CeloTransactionSerialized,
+>(
+  serializedTransaction: TSerialized,
+): ParseTransactionCeloReturnType<TSerialized> {
+  const serializedType = sliceHex(serializedTransaction, 0, 1)
+
+  if (serializedType === '0x7c')
+    return parseTransactionCIP42(
+      serializedTransaction as TransactionSerializedCIP42,
+    ) as ParseTransactionCeloReturnType<TSerialized>
+
+  return parseTransaction(
+    serializedTransaction,
+  ) as ParseTransactionCeloReturnType<TSerialized>
+}
+
+function parseTransactionCIP42(
+  serializedTransaction: TransactionSerializedCIP42,
+): TransactionSerializableCIP42 {
+  const transactionArray = toTransactionArray(serializedTransaction)
+
+  const [
+    chainId,
+    nonce,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    gas,
+    feeCurrency,
+    gatewayFeeRecipient,
+    gatewayFee,
+    to,
+    value,
+    data,
+    accessList,
+    v,
+    r,
+    s,
+  ] = transactionArray
+
+  if (transactionArray.length !== 15 && transactionArray.length !== 12) {
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        feeCurrency,
+        to,
+        gatewayFeeRecipient,
+        gatewayFee,
+        value,
+        data,
+        accessList,
+        ...(transactionArray.length > 12
+          ? {
+              v,
+              r,
+              s,
+            }
+          : {}),
+      },
+      serializedTransaction,
+      type: 'cip42',
+    })
+  }
+
+  const transaction: Partial<TransactionSerializableCIP42> = {
+    chainId: hexToNumber(chainId as Hex),
+    type: 'cip42',
+  }
+
+  if (isHex(to) && to !== '0x') transaction.to = to
+  if (isHex(gas) && gas !== '0x') transaction.gas = hexToBigInt(gas)
+  if (isHex(data) && data !== '0x') transaction.data = data
+  if (isHex(nonce) && nonce !== '0x') transaction.nonce = hexToNumber(nonce)
+  if (isHex(value) && value !== '0x') transaction.value = hexToBigInt(value)
+  if (isHex(feeCurrency) && feeCurrency !== '0x')
+    transaction.feeCurrency = feeCurrency
+  if (isHex(gatewayFeeRecipient) && gatewayFeeRecipient !== '0x')
+    transaction.gatewayFeeRecipient = gatewayFeeRecipient
+  if (isHex(gatewayFee) && gatewayFee !== '0x')
+    transaction.gatewayFee = hexToBigInt(gatewayFee)
+  if (isHex(maxFeePerGas) && maxFeePerGas !== '0x')
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas)
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== '0x')
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas)
+  if (accessList.length !== 0 && accessList !== '0x')
+    transaction.accessList = parseAccessList(accessList as RecursiveArray<Hex>)
+
+  assertTransactionCIP42(transaction as TransactionSerializableCIP42)
+
+  return transaction as TransactionSerializableCIP42
+}