viem 2.50.4 → 2.51.0

package/tempo/Account.ts

@@ -4,7 +4,7 @@ import * as P256 from 'ox/P256'
 import * as PublicKey from 'ox/PublicKey'
 import * as Secp256k1 from 'ox/Secp256k1'
 import * as Signature from 'ox/Signature'
-import { KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
+import { Channel, KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
 import * as WebAuthnP256 from 'ox/WebAuthnP256'
 import * as WebCryptoP256 from 'ox/WebCryptoP256'
 import type {
@@ -27,6 +27,8 @@ export type Account_base<source extends string = string> = RequiredBy<
 > & {
   /** Key type. */
   keyType: SignatureEnvelope.Type
+  /** Sign fn. */
+  sign: NonNullable<LocalAccount['sign']>
   /** Sign transaction fn. */
   signTransaction: <
     serializer extends
@@ -40,6 +42,10 @@ export type Account_base<source extends string = string> = RequiredBy<
         }
       | undefined,
   ) => Promise<Hex.Hex>
+  /** Sign voucher fn. */
+  signVoucher: (
+    parameters: signVoucher.Parameters,
+  ) => Promise<signVoucher.ReturnValue>
 }
 
 export type RootAccount = Account_base<'root'> & {
@@ -56,6 +62,21 @@ export type RootAccount = Account_base<'root'> & {
 export type AccessKeyAccount = Account_base<'accessKey'> & {
   /** Access key ID. */
   accessKeyAddress: Address.Address
+  /**
+   * Signs a hash.
+   *
+   * By default, access key accounts sign through a keychain envelope so the
+   * signature authorizes the parent account.
+   *
+   * Set `raw` to `true` to sign directly with the access key, without keychain
+   * hashing or keychain enveloping.
+   */
+  sign: (parameters: {
+    /** Hash to sign. */
+    hash: Hex.Hex
+    /** Sign directly with the access key, without keychain hashing or enveloping. */
+    raw?: boolean | undefined
+  }) => Promise<Hex.Hex>
 }
 
 export type Account = OneOf<RootAccount | AccessKeyAccount>
@@ -377,6 +398,44 @@ export declare namespace fromWebCryptoP256 {
     from.ReturnValue<options>
 }
 
+export async function signVoucher(
+  account: LocalAccount,
+  parameters: signVoucher.Parameters,
+): Promise<signVoucher.ReturnValue> {
+  return account.sign!({
+    hash: getVoucherSignPayload(parameters),
+  })
+}
+
+function getVoucherSignPayload(parameters: signVoucher.Parameters) {
+  const { chainId, channel, cumulativeAmount } = parameters
+  const channelId =
+    typeof channel === 'string'
+      ? channel
+      : Channel.computeId(channel, {
+          chainId,
+        })
+
+  return Channel.getVoucherSignPayload({
+    chainId,
+    channelId,
+    cumulativeAmount,
+  })
+}
+
+export declare namespace signVoucher {
+  type Parameters = {
+    /** Chain ID. */
+    chainId: number | bigint
+    /** Channel descriptor or ID. */
+    channel: Channel.computeId.Channel | Hex.Hex
+    /** Total voucher amount signed for the channel. */
+    cumulativeAmount: bigint
+  }
+
+  type ReturnValue = Hex.Hex
+}
+
 export async function signKeyAuthorization(
   account: LocalAccount,
   parameters: signKeyAuthorization.Parameters,
@@ -431,7 +490,8 @@ function fromBase(parameters: fromBase.Parameters): Account_base {
     includePrefix: false,
   })
 
-  async function sign({ hash }: { hash: Hex.Hex }) {
+  async function sign({ hash, raw }: { hash: Hex.Hex; raw?: boolean }) {
+    if (raw) return await parameters.sign({ hash })
     const innerHash =
       parentAddress && internal_version === 'v2'
         ? keccak256(Hex.concat('0x04', hash, parentAddress))
@@ -496,6 +556,11 @@ function fromBase(parameters: fromBase.Parameters): Account_base {
     async signTypedData(typedData) {
       return await sign({ hash: hashTypedData(typedData) })
     },
+    async signVoucher(parameters) {
+      return await sign({
+        hash: getVoucherSignPayload(parameters),
+      })
+    },
     publicKey,
     source,
     type: 'local',

package/tempo/Decorator.ts

@@ -5,6 +5,7 @@ import type { Transport } from '../clients/transports/createTransport.js'
 import type { Chain } from '../types/chain.js'
 import * as accessKeyActions from './actions/accessKey.js'
 import * as ammActions from './actions/amm.js'
+import * as channelActions from './actions/channel.js'
 import * as dexActions from './actions/dex.js'
 import * as faucetActions from './actions/faucet.js'
 import * as feeActions from './actions/fee.js'
@@ -570,6 +571,280 @@ export type Decorator<
       parameters: ammActions.watchRebalanceSwap.Parameters,
     ) => () => void
   }
+  channel: {
+    /**
+     * Closes a TIP-20 channel reserve channel from the payee or operator side.
+     *
+     * @example
+     * ```ts
+     * import { parseUnits } from 'viem'
+     *
+     * const hash = await client.channel.close({
+     *   captureAmount: parseUnits('40', 6),
+     *   cumulativeAmount: parseUnits('80', 6),
+     *   channel,
+     *   signature: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    close: (
+      parameters: channelActions.close.Parameters<chain, account>,
+    ) => Promise<channelActions.close.ReturnValue>
+    /**
+     * Closes a TIP-20 channel reserve channel and waits for the transaction receipt.
+     *
+     * @example
+     * ```ts
+     * import { parseUnits } from 'viem'
+     *
+     * const result = await client.channel.closeSync({
+     *   captureAmount: parseUnits('40', 6),
+     *   cumulativeAmount: parseUnits('80', 6),
+     *   channel,
+     *   signature: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt and event data.
+     */
+    closeSync: (
+      parameters: channelActions.closeSync.Parameters<chain, account>,
+    ) => Promise<channelActions.closeSync.ReturnValue>
+    /**
+     * Gets TIP-20 channel reserve state for a channel ID or channel.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   chain: tempo.extend({ feeToken: '0x20c...001' }),
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const state = await client.channel.getStates({
+     *   channel: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns Channel state for a single channel, or channel states for multiple channels.
+     */
+    getStates: <
+      const channel extends
+        | channelActions.getStates.Channel
+        | readonly channelActions.getStates.Channel[],
+    >(
+      parameters: channelActions.getStates.Parameters<channel>,
+    ) => Promise<channelActions.getStates.ReturnValue<channel>>
+    /**
+     * Opens and funds a TIP-20 channel reserve channel.
+     *
+     * @example
+     * ```ts
+     * import { parseUnits } from 'viem'
+     *
+     * const hash = await client.channel.open({
+     *   deposit: parseUnits('100', 6),
+     *   payee: '0x...',
+     *   token: 1n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    open: (
+      parameters: channelActions.open.Parameters<chain, account>,
+    ) => Promise<channelActions.open.ReturnValue>
+    /**
+     * Opens and funds a TIP-20 channel reserve channel and waits for the transaction receipt.
+     *
+     * @example
+     * ```ts
+     * import { parseUnits } from 'viem'
+     *
+     * const result = await client.channel.openSync({
+     *   deposit: parseUnits('100', 6),
+     *   payee: '0x...',
+     *   token: 1n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt and event data.
+     */
+    openSync: (
+      parameters: channelActions.openSync.Parameters<chain, account>,
+    ) => Promise<channelActions.openSync.ReturnValue>
+    /**
+     * Starts the payer close timer for a TIP-20 channel reserve channel.
+     *
+     * @example
+     * ```ts
+     * const hash = await client.channel.requestClose({
+     *   channel,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    requestClose: (
+      parameters: channelActions.requestClose.Parameters<chain, account>,
+    ) => Promise<channelActions.requestClose.ReturnValue>
+    /**
+     * Starts the payer close timer and waits for the transaction receipt.
+     *
+     * @example
+     * ```ts
+     * const result = await client.channel.requestCloseSync({
+     *   channel,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt and event data.
+     */
+    requestCloseSync: (
+      parameters: channelActions.requestCloseSync.Parameters<chain, account>,
+    ) => Promise<channelActions.requestCloseSync.ReturnValue>
+    /**
+     * Settles a TIP-20 channel reserve voucher.
+     *
+     * @example
+     * ```ts
+     * import { parseUnits } from 'viem'
+     *
+     * const hash = await client.channel.settle({
+     *   cumulativeAmount: parseUnits('40', 6),
+     *   channel,
+     *   signature: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    settle: (
+      parameters: channelActions.settle.Parameters<chain, account>,
+    ) => Promise<channelActions.settle.ReturnValue>
+    /**
+     * Settles a TIP-20 channel reserve voucher and waits for the transaction receipt.
+     *
+     * @example
+     * ```ts
+     * import { parseUnits } from 'viem'
+     *
+     * const result = await client.channel.settleSync({
+     *   cumulativeAmount: parseUnits('40', 6),
+     *   channel,
+     *   signature: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt and event data.
+     */
+    settleSync: (
+      parameters: channelActions.settleSync.Parameters<chain, account>,
+    ) => Promise<channelActions.settleSync.ReturnValue>
+    /**
+     * Signs a TIP-20 channel reserve voucher.
+     *
+     * @example
+     * ```ts
+     * import { parseUnits } from 'viem'
+     *
+     * const signature = await client.channel.signVoucher({
+     *   channel,
+     *   cumulativeAmount: parseUnits('40', 6),
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The voucher signature.
+     */
+    signVoucher: (
+      parameters: channelActions.signVoucher.Parameters<account>,
+    ) => Promise<channelActions.signVoucher.ReturnValue>
+    /**
+     * Adds deposit to a TIP-20 channel reserve channel.
+     *
+     * @example
+     * ```ts
+     * import { parseUnits } from 'viem'
+     *
+     * const hash = await client.channel.topUp({
+     *   additionalDeposit: parseUnits('50', 6),
+     *   channel,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    topUp: (
+      parameters: channelActions.topUp.Parameters<chain, account>,
+    ) => Promise<channelActions.topUp.ReturnValue>
+    /**
+     * Adds deposit to a TIP-20 channel reserve channel and waits for the transaction receipt.
+     *
+     * @example
+     * ```ts
+     * import { parseUnits } from 'viem'
+     *
+     * const result = await client.channel.topUpSync({
+     *   additionalDeposit: parseUnits('50', 6),
+     *   channel,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt and event data.
+     */
+    topUpSync: (
+      parameters: channelActions.topUpSync.Parameters<chain, account>,
+    ) => Promise<channelActions.topUpSync.ReturnValue>
+    /**
+     * Withdraws payer funds after the close grace period elapses.
+     *
+     * @example
+     * ```ts
+     * const hash = await client.channel.withdraw({
+     *   channel,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    withdraw: (
+      parameters: channelActions.withdraw.Parameters<chain, account>,
+    ) => Promise<channelActions.withdraw.ReturnValue>
+    /**
+     * Withdraws payer funds and waits for the transaction receipt.
+     *
+     * @example
+     * ```ts
+     * const result = await client.channel.withdrawSync({
+     *   channel,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt and event data.
+     */
+    withdrawSync: (
+      parameters: channelActions.withdrawSync.Parameters<chain, account>,
+    ) => Promise<channelActions.withdrawSync.ReturnValue>
+  }
   dex: {
     /**
      * Buys a specific amount of tokens.
@@ -2507,6 +2782,7 @@ export type Decorator<
      *   name: 'My Token',
      *   symbol: 'MTK',
      *   currency: 'USD',
+     *   logoURI: 'https://example.com/token.svg',
      * })
      * ```
      *
@@ -2537,6 +2813,7 @@ export type Decorator<
      *   name: 'My Token',
      *   symbol: 'MTK',
      *   currency: 'USD',
+     *   logoURI: 'https://example.com/token.svg',
      * })
      * ```
      *
@@ -2602,7 +2879,7 @@ export type Decorator<
       parameters: tokenActions.getBalance.Parameters<account>,
     ) => Promise<tokenActions.getBalance.ReturnValue>
     /**
-     * Gets TIP20 token metadata including name, symbol, currency, decimals, and total supply.
+     * Gets TIP20 token metadata including name, symbol, logo URI, currency, decimals, and total supply.
      *
      * @example
      * ```ts
@@ -4299,6 +4576,27 @@ export function decorator() {
         watchRebalanceSwap: (parameters) =>
           ammActions.watchRebalanceSwap(client, parameters),
       },
+      channel: {
+        close: (parameters) => channelActions.close(client, parameters),
+        closeSync: (parameters) => channelActions.closeSync(client, parameters),
+        getStates: (parameters) => channelActions.getStates(client, parameters),
+        open: (parameters) => channelActions.open(client, parameters),
+        openSync: (parameters) => channelActions.openSync(client, parameters),
+        requestClose: (parameters) =>
+          channelActions.requestClose(client, parameters),
+        requestCloseSync: (parameters) =>
+          channelActions.requestCloseSync(client, parameters),
+        settle: (parameters) => channelActions.settle(client, parameters),
+        settleSync: (parameters) =>
+          channelActions.settleSync(client, parameters),
+        signVoucher: (parameters) =>
+          channelActions.signVoucher(client, parameters),
+        topUp: (parameters) => channelActions.topUp(client, parameters),
+        topUpSync: (parameters) => channelActions.topUpSync(client, parameters),
+        withdraw: (parameters) => channelActions.withdraw(client, parameters),
+        withdrawSync: (parameters) =>
+          channelActions.withdrawSync(client, parameters),
+      },
       dex: {
         buy: (parameters) => dexActions.buy(client, parameters),
         buySync: (parameters) => dexActions.buySync(client, parameters),

package/tempo/Transaction.ts

@@ -303,6 +303,12 @@ async function serializeTempo(
     if (feePayerSignature === null || feePayer) return null
     return undefined
   })()
+  const hasPrefilledFeePayerSignature =
+    typeof transaction.feePayerSignature !== 'undefined' &&
+    transaction.feePayerSignature !== null
+  const shouldStripFeeTokenForSponsorship =
+    (feePayer === true && (!signature || !feePayerSignature)) ||
+    (!signature && hasPrefilledFeePayerSignature)
 
   const transaction_ox = {
     ...rest,
@@ -325,16 +331,11 @@ async function serializeTempo(
     ...(nonce ? { nonce: BigInt(nonce) } : {}),
   } satisfies TxTempo.TxEnvelopeTempo
 
-  // If we have marked the transaction as intended to be paid by a fee
-  // payer (feePayer: true), we strip the fee token from the sender's
-  // sign payload — per TIP-76 the sender does not commit to it; the fee
-  // payer chooses and commits to the token via its own signature.
-  //
-  // Once the fee payer has signed (`feePayerSignature` is populated),
-  // the relay has chosen a token and signed over it. The broadcast
-  // envelope must therefore include `feeToken` so the chain can verify
-  // the fee payer's signature and identify which token to charge.
-  if (feePayer === true && !feePayerSignature) delete transaction_ox.feeToken
+  // Sender does not commit to `feeToken` under sponsorship. Strip it
+  // for the sender sign payload and the partial sponsorship handoff envelope.
+  // Keep it only on the final broadcast envelope so the chain can verify
+  // the fee payer.
+  if (shouldStripFeeTokenForSponsorship) delete transaction_ox.feeToken
 
   if (signature && typeof transaction.feePayer === 'object') {
     const tx = TxTempo.from(transaction_ox, {
@@ -364,7 +365,13 @@ async function serializeTempo(
     })
   }
 
-  if (feePayer === true) {
+  if (feePayer === true || (!signature && hasPrefilledFeePayerSignature)) {
+    // Fee payer signature was prefilled during `eth_fillTransaction` -- emit
+    // a full envelope with both signatures to skip `eth_signRawTransaction`.
+    if (signature && feePayerSignature)
+      return TxTempo.serialize(transaction_ox, {
+        signature,
+      })
     if (signature)
       return TxTempo.serialize(transaction_ox, {
         format: 'feePayer',