viem 2.50.4 → 2.51.2

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 {
@@ -19,6 +19,7 @@ import { keccak256 } from '../utils/hash/keccak256.js'
 import { hashMessage } from '../utils/signature/hashMessage.js'
 import { hashTypedData } from '../utils/signature/hashTypedData.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
+import type { KeyAuthorizationManager } from './KeyAuthorizationManager.js'
 import * as Transaction from './Transaction.js'
 
 export type Account_base<source extends string = string> = RequiredBy<
@@ -27,6 +28,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 +43,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 +63,23 @@ export type RootAccount = Account_base<'root'> & {
 export type AccessKeyAccount = Account_base<'accessKey'> & {
   /** Access key ID. */
   accessKeyAddress: Address.Address
+  /** Pending key authorization manager. */
+  keyAuthorizationManager?: KeyAuthorizationManager | undefined
+  /**
+   * 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>
@@ -104,12 +128,13 @@ export function fromHeadlessWebAuthn<
   privateKey: Hex.Hex,
   options: options | fromHeadlessWebAuthn.Options,
 ): fromHeadlessWebAuthn.ReturnValue<options> {
-  const { access, rpId, origin, internal_version } = options
+  const { access, keyAuthorizationManager, rpId, origin, internal_version } =
+    options
 
   const publicKey = P256.getPublicKey({ privateKey })
 
   return from({
-    access,
+    ...(access ? { access, keyAuthorizationManager } : {}),
     internal_version,
     keyType: 'webAuthn',
     publicKey,
@@ -140,7 +165,10 @@ export declare namespace fromHeadlessWebAuthn {
     WebAuthnP256.getSignPayload.Options,
     'challenge' | 'rpId' | 'origin'
   > &
-    Pick<from.Parameters, 'access' | 'internal_version'> & {
+    Pick<
+      from.Parameters,
+      'access' | 'internal_version' | 'keyAuthorizationManager'
+    > & {
       rpId: string
       origin: string
     }
@@ -166,11 +194,11 @@ export function fromP256<const options extends fromP256.Options>(
   privateKey: Hex.Hex,
   options: options | fromP256.Options = {},
 ): fromP256.ReturnValue<options> {
-  const { access, internal_version } = options
+  const { access, keyAuthorizationManager, internal_version } = options
   const publicKey = P256.getPublicKey({ privateKey })
 
   return from({
-    access,
+    ...(access ? { access, keyAuthorizationManager } : {}),
     internal_version,
     keyType: 'p256',
     publicKey,
@@ -186,7 +214,10 @@ export function fromP256<const options extends fromP256.Options>(
 }
 
 export declare namespace fromP256 {
-  export type Options = Pick<from.Parameters, 'access' | 'internal_version'>
+  export type Options = Pick<
+    from.Parameters,
+    'access' | 'internal_version' | 'keyAuthorizationManager'
+  >
 
   export type ReturnValue<options extends Options = Options> =
     from.ReturnValue<options>
@@ -209,11 +240,11 @@ export function fromSecp256k1<const options extends fromSecp256k1.Options>(
   privateKey: Hex.Hex,
   options: options | fromSecp256k1.Options = {},
 ): fromSecp256k1.ReturnValue<options> {
-  const { access, internal_version } = options
+  const { access, keyAuthorizationManager, internal_version } = options
   const publicKey = Secp256k1.getPublicKey({ privateKey })
 
   return from({
-    access,
+    ...(access ? { access, keyAuthorizationManager } : {}),
     internal_version,
     keyType: 'secp256k1',
     publicKey,
@@ -226,7 +257,10 @@ export function fromSecp256k1<const options extends fromSecp256k1.Options>(
 }
 
 export declare namespace fromSecp256k1 {
-  export type Options = Pick<from.Parameters, 'access' | 'internal_version'>
+  export type Options = Pick<
+    from.Parameters,
+    'access' | 'internal_version' | 'keyAuthorizationManager'
+  >
 
   export type ReturnValue<options extends Options = Options> =
     from.ReturnValue<options>
@@ -350,11 +384,11 @@ export function fromWebCryptoP256<
   keyPair: Awaited<ReturnType<typeof WebCryptoP256.createKeyPair>>,
   options: options | fromWebCryptoP256.Options = {},
 ): fromWebCryptoP256.ReturnValue<options> {
-  const { access, internal_version } = options
+  const { access, keyAuthorizationManager, internal_version } = options
   const { publicKey, privateKey } = keyPair
 
   return from({
-    access,
+    ...(access ? { access, keyAuthorizationManager } : {}),
     internal_version,
     keyType: 'p256',
     publicKey,
@@ -371,12 +405,59 @@ export function fromWebCryptoP256<
 }
 
 export declare namespace fromWebCryptoP256 {
-  export type Options = Pick<from.Parameters, 'access' | 'internal_version'>
+  export type Options = Pick<
+    from.Parameters,
+    'access' | 'internal_version' | 'keyAuthorizationManager'
+  >
 
   export type ReturnValue<options extends Options = Options> =
     from.ReturnValue<options>
 }
 
+export async function signVoucher(
+  account: LocalAccount,
+  parameters: signVoucher.Parameters,
+): Promise<signVoucher.ReturnValue> {
+  const hash = getVoucherSignPayload(parameters)
+  if (isAccessKeyAccount(account)) return account.sign({ hash, raw: true })
+  return account.sign!({ hash })
+}
+
+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
+}
+
+function isAccessKeyAccount(
+  account: LocalAccount,
+): account is AccessKeyAccount {
+  return account.source === 'accessKey' && 'accessKeyAddress' in account
+}
+
 export async function signKeyAuthorization(
   account: LocalAccount,
   parameters: signKeyAuthorization.Parameters,
@@ -431,7 +512,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 +578,11 @@ function fromBase(parameters: fromBase.Parameters): Account_base {
     async signTypedData(typedData) {
       return await sign({ hash: hashTypedData(typedData) })
     },
+    async signVoucher(parameters) {
+      const hash = getVoucherSignPayload(parameters)
+      if (parentAddress) return await sign({ hash, raw: true })
+      return await sign({ hash })
+    },
     publicKey,
     source,
     type: 'local',
@@ -510,6 +597,8 @@ declare namespace fromBase {
     publicKey: PublicKey.PublicKey
     /** Key type. */
     keyType?: SignatureEnvelope.Type | undefined
+    /** Pending key authorization manager. */
+    keyAuthorizationManager?: KeyAuthorizationManager | undefined
     /** Sign function. */
     sign: NonNullable<LocalAccount['sign']>
     /** Source. */
@@ -564,12 +653,13 @@ declare namespace fromRoot {
 
 // biome-ignore lint/correctness/noUnusedVariables: _
 function fromAccessKey(parameters: fromAccessKey.Parameters): AccessKeyAccount {
-  const { access } = parameters
+  const { access, keyAuthorizationManager } = parameters
   const { address: parentAddress } = parseAccount(access)
   const account = fromBase({ ...parameters, parentAddress })
   return {
     ...account,
     accessKeyAddress: Address.fromPublicKey(parameters.publicKey),
+    keyAuthorizationManager,
     source: 'accessKey',
   }
 }
@@ -582,6 +672,8 @@ declare namespace fromAccessKey {
      * the parent account's address as the keychain address.
      */
     access: viem_Account | Address.Address
+    /** Pending key authorization manager. */
+    keyAuthorizationManager?: KeyAuthorizationManager | undefined
   }
 
   export type ReturnValue = AccessKeyAccount

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/KeyAuthorizationManager.ts

@@ -0,0 +1,51 @@
+import type { Address } from 'abitype'
+import type { KeyAuthorization } from 'ox/tempo'
+import type { MaybePromise } from '../types/utils.js'
+
+export type Key = {
+  address: Address
+  accessKey: Address
+  chainId: number
+}
+
+export type KeyAuthorizationManager = {
+  get(key: Key): MaybePromise<KeyAuthorization.Signed | undefined>
+  remove(key: Key): MaybePromise<void>
+  set(key: Key, keyAuthorization: KeyAuthorization.Signed): MaybePromise<void>
+}
+
+export function from(options: from.Options): KeyAuthorizationManager {
+  return options.source
+}
+
+export declare namespace from {
+  type Options = {
+    source: KeyAuthorizationManager
+  }
+}
+
+export function memory(): KeyAuthorizationManager {
+  const keyAuthorizations = new Map<string, KeyAuthorization.Signed>()
+
+  return from({
+    source: {
+      get(key) {
+        return keyAuthorizations.get(serializeKey(key))
+      },
+      remove(key) {
+        keyAuthorizations.delete(serializeKey(key))
+      },
+      set(key, keyAuthorization) {
+        keyAuthorizations.set(serializeKey(key), keyAuthorization)
+      },
+    },
+  })
+}
+
+function serializeKey(key: Key) {
+  return [
+    key.chainId,
+    key.address.toLowerCase(),
+    key.accessKey.toLowerCase(),
+  ].join(':')
+}