tempo.ts 0.11.1 → 0.12.1

package/src/viem/Formatters.ts

@@ -1,164 +0,0 @@
-// TODO: Find opportunities to make this file less duplicated + more simplified with Viem v3.
-
-import * as Hex from 'ox/Hex'
-import {
-  Transaction as ox_Transaction,
-  TransactionRequest as ox_TransactionRequest,
-} from 'ox/tempo'
-import {
-  type Chain,
-  type Account as viem_Account,
-  formatTransaction as viem_formatTransaction,
-  formatTransactionReceipt as viem_formatTransactionReceipt,
-  formatTransactionRequest as viem_formatTransactionRequest,
-} from 'viem'
-import { type Address, parseAccount } from 'viem/accounts'
-import type { UnionOmit } from '../internal/types.js'
-import type { Account } from './Account.js'
-import type { GetFeeTokenParameter } from './internal/types.js'
-import {
-  isTempo,
-  type Transaction,
-  type TransactionReceipt,
-  type TransactionReceiptRpc,
-  type TransactionRequest,
-  type TransactionRequestRpc,
-  type TransactionRpc,
-} from './Transaction.js'
-
-export function formatTransaction(
-  transaction: TransactionRpc,
-): Transaction<bigint, number, boolean> {
-  if (!isTempo(transaction)) return viem_formatTransaction(transaction as never)
-
-  const {
-    feePayerSignature,
-    gasPrice: _,
-    nonce,
-    ...tx
-  } = ox_Transaction.fromRpc(transaction as never) as ox_Transaction.Tempo
-
-  return {
-    ...tx,
-    accessList: tx.accessList!,
-    feePayerSignature: feePayerSignature
-      ? {
-          r: Hex.fromNumber(feePayerSignature.r, { size: 32 }),
-          s: Hex.fromNumber(feePayerSignature.s, { size: 32 }),
-          v: BigInt(feePayerSignature.v ?? 27),
-          yParity: feePayerSignature.yParity,
-        }
-      : undefined,
-    nonce: Number(nonce),
-    typeHex:
-      ox_Transaction.toRpcType[
-        tx.type as keyof typeof ox_Transaction.toRpcType
-      ],
-    type: tx.type as 'tempo',
-  }
-}
-
-export function formatTransactionReceipt(
-  receipt: TransactionReceiptRpc,
-): TransactionReceipt {
-  return viem_formatTransactionReceipt(receipt as never)
-}
-
-type Request<chain extends Chain | undefined> = UnionOmit<
-  TransactionRequest,
-  'feeToken'
-> &
-  GetFeeTokenParameter<chain>
-export function formatTransactionRequest<chain extends Chain | undefined>(
-  r: Request<chain>,
-  action?: string | undefined,
-): TransactionRequestRpc {
-  const request = r as Request<chain> & {
-    account?: viem_Account | Address | undefined
-  }
-  const account = request.account
-    ? parseAccount<Account | viem_Account | Address>(request.account)
-    : undefined
-
-  // Convert EIP-1559 transactions to Tempo transactions.
-  if (request.type === 'eip1559') (request as any).type = 'tempo'
-
-  // If the request is not a Tempo transaction, route to Viem formatter.
-  if (!isTempo(request))
-    return viem_formatTransactionRequest(
-      r as never,
-      action,
-    ) as TransactionRequestRpc
-
-  if (action)
-    request.calls = request.calls ?? [
-      {
-        to:
-          r.to ||
-          (!r.data || r.data === '0x'
-            ? '0x0000000000000000000000000000000000000000'
-            : undefined),
-        value: r.value,
-        data: r.data,
-      },
-    ]
-
-  const rpc = ox_TransactionRequest.toRpc({
-    ...request,
-    type: 'tempo',
-  } as never)
-
-  if (action === 'estimateGas') {
-    rpc.maxFeePerGas = undefined
-    rpc.maxPriorityFeePerGas = undefined
-  }
-
-  // JSON-RPC accounts (wallets) don't support Tempo transactions yet,
-  // we will omit the type to attempt to make them compatible
-  // with the base transaction structure.
-  // TODO: `calls` will not be supported by a lot of JSON-RPC accounts (wallet),
-  // use `wallet_sendCalls` or sequential `eth_sendTransaction` to mimic the
-  // behavior of `calls`.
-  if (account?.type === 'json-rpc') {
-    if (rpc.calls?.length && rpc.calls.length > 1)
-      throw new Error(
-        'Batch calls are not supported with JSON-RPC accounts yet.',
-      )
-    rpc.type = undefined
-  }
-
-  // We rely on `calls` for Tempo transactions.
-  // However, `calls` may not be supported by JSON-RPC accounts (wallets) yet,
-  // so we will not remove the `data`, `to`, and `value` fields to make it
-  // compatible with the base transaction structure.
-  if (account?.type !== 'json-rpc') {
-    rpc.to = undefined
-    rpc.data = undefined
-    rpc.value = undefined
-  }
-
-  const [keyType, keyData] = (() => {
-    const type =
-      account && 'keyType' in account ? account.keyType : account?.source
-    if (!type) return [undefined, undefined]
-    if (type === 'webAuthn')
-      // TODO: derive correct bytes size of key data based on webauthn create metadata.
-      return ['webAuthn', `0x${'ff'.repeat(1400)}`]
-    if (['p256', 'secp256k1'].includes(type)) return [type, undefined]
-    return [undefined, undefined]
-  })()
-
-  return {
-    ...rpc,
-    ...(keyType ? { keyType } : {}),
-    ...(keyData ? { keyData } : {}),
-    ...(request.feePayer
-      ? {
-          feePayer:
-            typeof request.feePayer === 'object'
-              ? parseAccount(request.feePayer)
-              : request.feePayer,
-        }
-      : {}),
-  } as never
-}

package/src/viem/P256.ts

@@ -1 +0,0 @@
-export { randomPrivateKey } from 'ox/P256'

package/src/viem/Secp256k1.ts

@@ -1 +0,0 @@
-export { randomPrivateKey } from 'ox/Secp256k1'

package/src/viem/Storage.ts

@@ -1,110 +0,0 @@
-import { createStore, del, get, set } from 'idb-keyval'
-import * as Json from 'ox/Json'
-
-import type { MaybePromise } from '../internal/types.js'
-import { normalizeValue } from './internal/utils.js'
-
-export type Storage<
-  schema extends Record<string, unknown> = Record<string, unknown>,
-> = {
-  getItem: <name extends keyof schema>(
-    name: name,
-  ) => MaybePromise<schema[name] | null>
-  removeItem: <name extends keyof schema>(name: name) => MaybePromise<void>
-  setItem: <name extends keyof schema>(
-    name: name,
-    value: schema[name],
-  ) => MaybePromise<void>
-}
-
-export function from<schema extends Record<string, unknown>>(
-  storage: Storage,
-  options: { key?: string | undefined } = {},
-): Storage<schema> {
-  const key = (name: any) => `${options.key ? `${options.key}:` : ''}${name}`
-  return {
-    getItem: (name) => storage.getItem(key(name)) as never,
-    removeItem: (name) => storage.removeItem(key(name)),
-    setItem: (name, value) => storage.setItem(key(name), value),
-  }
-}
-
-export namespace from {
-  export type Options = {
-    key?: string | undefined
-  }
-}
-
-export function idb<schema extends Record<string, unknown>>() {
-  const store =
-    typeof indexedDB !== 'undefined'
-      ? createStore('tempo.ts', 'store')
-      : undefined
-  return from<schema>({
-    async getItem(name) {
-      const value = await get(name, store)
-      if (value === null) return null
-      return value
-    },
-    async removeItem(name) {
-      await del(name, store)
-    },
-    async setItem(name, value) {
-      await set(name, normalizeValue(value), store)
-    },
-  })
-}
-
-export function localStorage<schema extends Record<string, unknown>>(
-  options: localStorage.Options = {},
-) {
-  if (typeof window === 'undefined') return memory<schema>()
-  return from<schema>(
-    {
-      async getItem(name) {
-        const item = window.localStorage.getItem(name)
-        if (item === null) return null
-        try {
-          return Json.parse(item)
-        } catch {
-          return null
-        }
-      },
-      async removeItem(name) {
-        window.localStorage.removeItem(name)
-      },
-      async setItem(name, value) {
-        window.localStorage.setItem(name, Json.stringify(value))
-      },
-    },
-    options,
-  )
-}
-
-export namespace localStorage {
-  export type Options = from.Options
-}
-
-const store = new Map<string, any>()
-export function memory<schema extends Record<string, unknown>>(
-  options: memory.Options = {},
-) {
-  return from<schema>(
-    {
-      getItem(name) {
-        return store.get(name) ?? null
-      },
-      removeItem(name) {
-        store.delete(name)
-      },
-      setItem(name, value) {
-        store.set(name, value)
-      },
-    },
-    options,
-  )
-}
-
-export namespace memory {
-  export type Options = from.Options
-}

package/src/viem/TokenIds.ts

@@ -1 +0,0 @@
-export const pathUsd = 0n

package/src/viem/Transaction.ts

@@ -1,382 +0,0 @@
-// TODO: Find opportunities to make this file less duplicated + more simplified with Viem v3.
-
-import * as Hex from 'ox/Hex'
-import * as Secp256k1 from 'ox/Secp256k1'
-import * as Signature from 'ox/Signature'
-import {
-  type AuthorizationTempo,
-  type KeyAuthorization,
-  type TransactionReceipt as ox_TransactionReceipt,
-  SignatureEnvelope,
-  TxEnvelopeTempo as TxTempo,
-} from 'ox/tempo'
-import {
-  type AccessList,
-  type Account,
-  type Address,
-  type FeeValuesEIP1559,
-  type ParseTransactionReturnType,
-  type TransactionBase,
-  type TransactionRequestBase,
-  type TransactionSerializableBase,
-  type TransactionSerializedGeneric,
-  getTransactionType as viem_getTransactionType,
-  parseTransaction as viem_parseTransaction,
-  type RpcTransaction as viem_RpcTransaction,
-  type RpcTransactionRequest as viem_RpcTransactionRequest,
-  type Signature as viem_Signature,
-  serializeTransaction as viem_serializeTransaction,
-  type Transaction as viem_Transaction,
-  type TransactionReceipt as viem_TransactionReceipt,
-  type TransactionRequest as viem_TransactionRequest,
-  type TransactionSerializable as viem_TransactionSerializable,
-  type TransactionSerialized as viem_TransactionSerialized,
-  type TransactionType as viem_TransactionType,
-} from 'viem'
-import type { ExactPartial, OneOf, PartialBy } from '../internal/types.js'
-
-export type Transaction<
-  bigintType = bigint,
-  numberType = number,
-  pending extends boolean = false,
-> = OneOf<
-  | viem_Transaction<bigintType, numberType, pending>
-  | TransactionTempo<bigintType, numberType, pending>
->
-export type TransactionRpc<pending extends boolean = false> = OneOf<
-  | viem_RpcTransaction<pending>
-  | (Omit<
-      TransactionTempo<Hex.Hex, Hex.Hex, pending, '0x76'>,
-      'authorizationList' | 'keyAuthorization' | 'signature'
-    > & {
-      authorizationList?: AuthorizationTempo.ListRpc | undefined
-      keyAuthorization?: KeyAuthorization.Rpc | null | undefined
-      signature: SignatureEnvelope.SignatureEnvelopeRpc
-    })
->
-
-export type TransactionTempo<
-  quantity = bigint,
-  index = number,
-  isPending extends boolean = boolean,
-  type = 'tempo',
-> = PartialBy<
-  Omit<
-    TransactionBase<quantity, index, isPending>,
-    'data' | 'input' | 'value' | 'to'
-  >,
-  'r' | 's' | 'v' | 'yParity'
-> & {
-  accessList: AccessList
-  authorizationList?: AuthorizationTempo.ListSigned<quantity, index> | undefined
-  calls: readonly TxTempo.Call<quantity>[]
-  chainId: index
-  feeToken?: Address | undefined
-  feePayerSignature?: viem_Signature | undefined
-  keyAuthorization?: KeyAuthorization.Signed<quantity, index> | null | undefined
-  nonceKey?: quantity | undefined
-  signature: SignatureEnvelope.SignatureEnvelope
-  type: type
-  validBefore?: index | undefined
-  validAfter?: index | undefined
-} & FeeValuesEIP1559<quantity>
-
-export type TransactionRequest<
-  bigintType = bigint,
-  numberType = number,
-> = OneOf<
-  | viem_TransactionRequest<bigintType, numberType>
-  | TransactionRequestTempo<bigintType, numberType>
->
-export type TransactionRequestRpc = OneOf<
-  viem_RpcTransactionRequest | TransactionRequestTempo<Hex.Hex, Hex.Hex, '0x76'>
->
-
-export type TransactionReceipt<
-  quantity = bigint,
-  index = number,
-  status = 'success' | 'reverted',
-  type = TransactionType,
-> = viem_TransactionReceipt<quantity, index, status, type> & {
-  feePayer?: Address | undefined
-  feeToken?: Address | undefined
-}
-
-export type TransactionReceiptRpc = TransactionReceipt<
-  Hex.Hex,
-  Hex.Hex,
-  ox_TransactionReceipt.RpcStatus,
-  ox_TransactionReceipt.RpcType
->
-
-export type TransactionRequestTempo<
-  quantity = bigint,
-  index = number,
-  type = 'tempo',
-> = TransactionRequestBase<quantity, index, type> &
-  ExactPartial<FeeValuesEIP1559<quantity>> & {
-    accessList?: AccessList | undefined
-    keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
-    calls?: readonly TxTempo.Call<quantity>[] | undefined
-    feePayer?: Account | true | undefined
-    feeToken?: Address | bigint | undefined
-    nonceKey?: 'random' | quantity | undefined
-    validBefore?: index | undefined
-    validAfter?: index | undefined
-  }
-
-export type TransactionSerializable = OneOf<
-  viem_TransactionSerializable | TransactionSerializableTempo
->
-
-export type TransactionSerializableTempo<
-  quantity = bigint,
-  index = number,
-> = TransactionSerializableBase<quantity, index> &
-  ExactPartial<FeeValuesEIP1559<quantity>> & {
-    accessList?: AccessList | undefined
-    calls: readonly TxTempo.Call<quantity>[]
-    chainId: number
-    feeToken?: Address | bigint | undefined
-    feePayerSignature?: viem_Signature | null | undefined
-    keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
-    nonceKey?: quantity | undefined
-    signature?: SignatureEnvelope.SignatureEnvelope<quantity, index> | undefined
-    validBefore?: index | undefined
-    validAfter?: index | undefined
-    type?: 'tempo' | undefined
-  }
-
-export type TransactionSerialized<
-  type extends TransactionType = TransactionType,
-> = viem_TransactionSerialized<type> | TransactionSerializedTempo
-
-export type TransactionSerializedTempo = `0x76${string}`
-
-export type TransactionType = viem_TransactionType | 'tempo'
-
-export function getType(
-  transaction: Record<string, unknown>,
-): Transaction['type'] {
-  if (
-    typeof transaction.calls !== 'undefined' ||
-    typeof transaction.feePayer !== 'undefined' ||
-    typeof transaction.feeToken !== 'undefined' ||
-    typeof transaction.nonceKey !== 'undefined' ||
-    typeof transaction.signature !== 'undefined' ||
-    typeof transaction.validBefore !== 'undefined' ||
-    typeof transaction.validAfter !== 'undefined'
-  )
-    return 'tempo' as never
-  if (transaction.type) return transaction.type as never
-  return viem_getTransactionType(transaction) as never
-}
-
-export function isTempo(transaction: Record<string, unknown>) {
-  try {
-    const type = getType(transaction)
-    return type === 'tempo'
-  } catch {
-    return false
-  }
-}
-
-export function deserialize<
-  const serialized extends TransactionSerializedGeneric,
->(serializedTransaction: serialized): deserialize.ReturnValue<serialized> {
-  const type = Hex.slice(serializedTransaction, 0, 1)
-  if (type === '0x76') {
-    const from =
-      Hex.slice(serializedTransaction, -6) === '0xfeefeefeefee'
-        ? Hex.slice(serializedTransaction, -26, -6)
-        : undefined
-    return {
-      ...deserializeTempo(serializedTransaction as `0x76${string}`),
-      from,
-    } as never
-  }
-  return viem_parseTransaction(serializedTransaction) as never
-}
-
-export declare namespace deserialize {
-  export type ReturnValue<
-    serialized extends
-      TransactionSerializedGeneric = TransactionSerializedGeneric,
-  > = serialized extends TransactionSerializedTempo
-    ? TransactionSerializableTempo
-    : ParseTransactionReturnType<serialized>
-}
-
-export async function serialize(
-  transaction: TransactionSerializable & {
-    feePayer?: Account | true | undefined
-    from?: Address | undefined
-  },
-  signature?:
-    | OneOf<SignatureEnvelope.SignatureEnvelope | viem_Signature>
-    | undefined,
-) {
-  // If the transaction is not a Tempo transaction, route to Viem serializer.
-  if (!isTempo(transaction)) {
-    if (signature && 'type' in signature && signature.type !== 'secp256k1')
-      throw new Error(
-        'Unsupported signature type. Expected `secp256k1` but got `' +
-          signature.type +
-          '`.',
-      )
-    if (signature && 'type' in signature) {
-      const { r, s, yParity } = signature?.signature!
-      return viem_serializeTransaction(transaction as never, {
-        r: Hex.fromNumber(r, { size: 32 }),
-        s: Hex.fromNumber(s, { size: 32 }),
-        yParity,
-      })
-    }
-    return viem_serializeTransaction(transaction as never, signature)
-  }
-
-  const type = getType(transaction)
-  if (type === 'tempo')
-    return serializeTempo(
-      transaction as TransactionSerializableTempo,
-      signature,
-    )
-
-  throw new Error('Unsupported transaction type')
-}
-
-////////////////////////////////////////////////////////////////////////////////////
-// Internal
-
-/** @internal */
-function deserializeTempo(
-  serializedTransaction: TransactionSerializedTempo,
-): TransactionSerializableTempo {
-  const { feePayerSignature, nonce, ...tx } = TxTempo.deserialize(
-    serializedTransaction,
-  )
-  return {
-    ...tx,
-    nonce: Number(nonce ?? 0n),
-    feePayerSignature: feePayerSignature
-      ? {
-          r: Hex.fromNumber(feePayerSignature.r, { size: 32 }),
-          s: Hex.fromNumber(feePayerSignature.s, { size: 32 }),
-          yParity: feePayerSignature.yParity,
-        }
-      : feePayerSignature,
-  } satisfies TransactionSerializableTempo
-}
-
-/** @internal */
-async function serializeTempo(
-  transaction: TransactionSerializableTempo & {
-    feePayer?: Account | true | undefined
-    from?: Address | undefined
-  },
-  sig?: OneOf<SignatureEnvelope.SignatureEnvelope | viem_Signature> | undefined,
-) {
-  const signature = (() => {
-    if (transaction.signature) return transaction.signature
-    if (sig && 'type' in sig) return sig as SignatureEnvelope.SignatureEnvelope
-    if (sig)
-      return SignatureEnvelope.from({
-        r: BigInt(sig.r!),
-        s: BigInt(sig.s!),
-        yParity: Number(sig.yParity!),
-      })
-    return undefined
-  })()
-
-  const { chainId, feePayer, feePayerSignature, nonce, ...rest } = transaction
-
-  const transaction_ox = {
-    ...rest,
-    calls: rest.calls?.length
-      ? rest.calls
-      : [
-          {
-            to:
-              rest.to ||
-              (!rest.data || rest.data === '0x'
-                ? '0x0000000000000000000000000000000000000000'
-                : undefined),
-            value: rest.value,
-            data: rest.data,
-          },
-        ],
-    chainId: Number(chainId),
-    feePayerSignature: feePayerSignature
-      ? {
-          r: BigInt(feePayerSignature.r!),
-          s: BigInt(feePayerSignature.s!),
-          yParity: Number(feePayerSignature.yParity),
-        }
-      : feePayer
-        ? null
-        : undefined,
-    type: 'tempo',
-    ...(nonce ? { nonce: BigInt(nonce) } : {}),
-  } satisfies TxTempo.TxEnvelopeTempo
-
-  if (signature && typeof transaction.feePayer === 'object') {
-    const tx = TxTempo.from(transaction_ox, {
-      signature,
-    })
-
-    const sender = (() => {
-      if (transaction.from) return transaction.from
-      if (signature.type === 'secp256k1')
-        return Secp256k1.recoverAddress({
-          payload: TxTempo.getSignPayload(tx),
-          signature: signature.signature,
-        })
-      throw new Error('Unable to extract sender from transaction or signature.')
-    })()
-
-    const hash = TxTempo.getFeePayerSignPayload(tx, {
-      sender,
-    })
-
-    const feePayerSignature = await transaction.feePayer.sign!({
-      hash,
-    })
-
-    return TxTempo.serialize(tx, {
-      feePayerSignature: Signature.from(feePayerSignature),
-    })
-  }
-
-  if (feePayer === true) {
-    const serialized = TxTempo.serialize(transaction_ox, {
-      feePayerSignature: null,
-      signature,
-    })
-    // if the transaction is ready to be sent off (signed), add the sender
-    // and a fee marker to the serialized transaction, so the fee payer proxy
-    // can infer the sender address.
-    if (transaction.from && signature)
-      return Hex.concat(serialized, transaction.from, '0xfeefeefeefee')
-    return serialized
-  }
-
-  return TxTempo.serialize(
-    // If we have specified a fee payer, the user will not be signing over the fee token.
-    // Defer the fee token signing to the fee payer.
-    { ...transaction_ox, ...(feePayer ? { feeToken: undefined } : {}) },
-    {
-      feePayerSignature: undefined,
-      signature,
-    },
-  )
-}
-
-// Export types required for inference.
-export {
-  /** @deprecated */
-  KeyAuthorization as z_KeyAuthorization,
-  /** @deprecated */
-  SignatureEnvelope as z_SignatureEnvelope,
-  /** @deprecated */
-  TxEnvelopeTempo as z_TxEnvelopeTempo,
-} from 'ox/tempo'