tempo.ts 0.0.0 → 0.0.1

package/src/viem/transaction.ts

@@ -0,0 +1,253 @@
+import type * as Calls from 'ox/erc7821/Calls'
+import * as Execute from 'ox/erc7821/Execute'
+import * as Hex from 'ox/Hex'
+import * as Secp256k1 from 'ox/Secp256k1'
+import * as Signature from 'ox/Signature'
+import {
+  type AccessList,
+  type Account,
+  type Address,
+  type AuthorizationList,
+  type FeeValuesEIP1559,
+  type ParseTransactionReturnType,
+  type SignedAuthorizationList,
+  type TransactionBase,
+  type TransactionRequestBase,
+  type TransactionSerializableBase,
+  type TransactionSerializableGeneric,
+  type TransactionSerializedGeneric,
+  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 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 } from '../internal/types.js'
+import * as TxFeeToken from '../ox/TransactionEnvelopeFeeToken.js'
+
+export type Transaction<
+  bigintType = bigint,
+  numberType = number,
+  pending extends boolean = false,
+> = OneOf<
+  | viem_Transaction<bigintType, numberType, pending>
+  | TransactionFeeToken<bigintType, numberType, pending>
+>
+export type TransactionRpc<pending extends boolean = false> = OneOf<
+  | viem_RpcTransaction<pending>
+  | TransactionFeeToken<Hex.Hex, Hex.Hex, pending, '0x77'>
+>
+
+export type TransactionFeeToken<
+  quantity = bigint,
+  index = number,
+  isPending extends boolean = boolean,
+  type = 'feeToken',
+> = TransactionBase<quantity, index, isPending> & {
+  /** EIP-2930 Access List. */
+  accessList: AccessList
+  /** Authorization list for the transaction. */
+  authorizationList: SignedAuthorizationList
+  /** Chain ID that this transaction is valid on. */
+  chainId: index
+  /** Fee token preference. */
+  feeToken?: Address | undefined
+  /** Fee payer address. */
+  feePayer?: Address | undefined
+  /** Fee payer signature. */
+  feePayerSignature?: viem_Signature | undefined
+  type: type
+} & FeeValuesEIP1559<quantity>
+
+export type TransactionRequest<
+  bigintType = bigint,
+  numberType = number,
+> = OneOf<
+  | viem_TransactionRequest<bigintType, numberType>
+  | TransactionRequestFeeToken<bigintType, numberType>
+>
+export type TransactionRequestRpc = OneOf<
+  | viem_RpcTransactionRequest
+  | TransactionRequestFeeToken<Hex.Hex, Hex.Hex, '0x77'>
+>
+
+export type TransactionRequestFeeToken<
+  quantity = bigint,
+  index = number,
+  type = 'feeToken',
+> = TransactionRequestBase<quantity, index, type> &
+  ExactPartial<FeeValuesEIP1559<quantity>> & {
+    accessList?: AccessList | undefined
+    authorizationList?: AuthorizationList<index, boolean> | undefined
+    calls?: readonly Calls.Call[] | undefined
+    feePayer?: Account | true | undefined
+    feeToken?: Address | bigint | undefined
+  }
+
+export type TransactionSerializable = OneOf<
+  viem_TransactionSerializable | TransactionSerializableFeeToken
+>
+
+export type TransactionSerializableFeeToken<
+  quantity = bigint,
+  index = number,
+> = TransactionSerializableBase<quantity, index> &
+  ExactPartial<FeeValuesEIP1559<quantity>> & {
+    accessList?: AccessList | undefined
+    authorizationList: SignedAuthorizationList
+    feeToken?: Address | bigint | undefined
+    feePayerSignature?: viem_Signature | undefined
+    chainId: number
+    type?: 'feeToken' | undefined
+    yParity?: number | undefined
+  }
+
+export type TransactionSerialized<
+  type extends TransactionType = TransactionType,
+> = viem_TransactionSerialized<type> | TransactionSerializedFeeToken
+
+export type TransactionSerializedFeeToken = `0x77${string}`
+
+export type TransactionType = viem_TransactionType | 'feeToken'
+
+export function isTempoTransaction(transaction: Record<string, unknown>) {
+  if (transaction.type === 'feeToken') return true
+  if (typeof transaction.calls !== 'undefined') return true
+  if (typeof transaction.feePayer !== 'undefined') return true
+  if (typeof transaction.feeToken !== 'undefined') return true
+  return false
+}
+
+export function parseTransaction<
+  const serialized extends TransactionSerializedGeneric,
+>(serializedTransaction: serialized): parseTransaction.ReturnValue<serialized> {
+  const type = Hex.slice(serializedTransaction, 0, 1)
+  if (type === '0x77') {
+    const { authorizationList, nonce, r, s, v, ...tx } = TxFeeToken.deserialize(
+      serializedTransaction as `0x77${string}`,
+    )
+    return {
+      ...tx,
+      authorizationList: authorizationList?.map((auth) => ({
+        ...auth,
+        nonce: Number(auth.nonce ?? 0n),
+        r: Hex.fromNumber(auth.r, { size: 32 }),
+        s: Hex.fromNumber(auth.s, { size: 32 }),
+      })),
+      nonce: Number(nonce ?? 0n),
+      ...(r ? { r: Hex.fromNumber(r, { size: 32 }) } : {}),
+      ...(s ? { s: Hex.fromNumber(s, { size: 32 }) } : {}),
+      ...(v ? { v: BigInt(v) } : {}),
+    } satisfies TransactionSerializableGeneric as never
+  }
+  return viem_parseTransaction(serializedTransaction) as never
+}
+
+export declare namespace parseTransaction {
+  export type ReturnValue<
+    serialized extends
+      TransactionSerializedGeneric = TransactionSerializedGeneric,
+  > = serialized extends TransactionSerializedFeeToken
+    ? TransactionSerializableFeeToken
+    : ParseTransactionReturnType<serialized>
+}
+
+export async function serializeTransaction(
+  transaction: TransactionSerializable & {
+    calls?: readonly Calls.Call[] | undefined
+    feePayer?: Account | true | undefined
+    from?: Address | undefined
+  },
+  signature?: viem_Signature | undefined,
+) {
+  if (!isTempoTransaction(transaction))
+    return viem_serializeTransaction(transaction as never, signature)
+
+  const signature_ = transaction.r && transaction.s ? transaction : signature
+
+  const {
+    authorizationList,
+    chainId,
+    calls,
+    feePayer,
+    feePayerSignature,
+    from,
+    nonce,
+    r,
+    s,
+    v,
+    ...rest
+  } = transaction
+
+  // TODO: remove once native transaction type has `calls`.
+  const { data, to, value } = (() => {
+    if (calls && from)
+      return {
+        data: Execute.encodeData(calls),
+        to: from,
+        value: 0n,
+      } as const
+    return {
+      data: transaction.data,
+      to: transaction.to,
+      value: transaction.value,
+    } as const
+  })()
+
+  const transaction_ox = {
+    ...rest,
+    authorizationList: authorizationList?.map((auth) => ({
+      ...auth,
+      nonce: BigInt(auth.nonce),
+      r: BigInt(auth.r!),
+      s: BigInt(auth.s!),
+      yParity: Number(auth.yParity),
+    })),
+    chainId: Number(chainId),
+    data,
+    feePayerSignature: feePayerSignature
+      ? {
+          r: BigInt(feePayerSignature.r!),
+          s: BigInt(feePayerSignature.s!),
+          yParity: Number(feePayerSignature.yParity),
+        }
+      : feePayer
+        ? null
+        : undefined,
+    to,
+    type: 'feeToken',
+    value,
+    ...(nonce ? { nonce: BigInt(nonce) } : {}),
+    ...(r ? { r: BigInt(r) } : {}),
+    ...(s ? { s: BigInt(s) } : {}),
+    ...(v ? { v: Number(v) } : {}),
+  } satisfies TxFeeToken.TransactionEnvelopeFeeToken
+
+  if (signature_ && typeof transaction.feePayer === 'object') {
+    const tx = TxFeeToken.from(transaction_ox, {
+      signature: signature_ as never,
+    })
+    const sender = Secp256k1.recoverAddress({
+      payload: TxFeeToken.getSignPayload(tx),
+      signature: signature_ as never,
+    })
+    const hash = TxFeeToken.getFeePayerSignPayload(tx, {
+      sender,
+    })
+    const feePayerSignature = await transaction.feePayer.sign!({
+      hash,
+    })
+    return TxFeeToken.serialize(tx, {
+      feePayerSignature: Signature.from(feePayerSignature),
+    })
+  }
+  return TxFeeToken.serialize(transaction_ox, {
+    feePayerSignature: feePayer === true ? null : undefined,
+    signature: signature as never,
+  })
+}

package/src/viem/transport.ts

@@ -0,0 +1,47 @@
+import { createTransport, type Transport } from 'viem'
+import { parseTransaction } from './transaction.js'
+
+export type Relay = Transport<typeof withFeePayer.type>
+
+/**
+ * Creates a fee payer transport that routes requests between
+ * the default transport or the fee payer transport.
+ *
+ * @param defaultTransport - The default transport to use.
+ * @param feePayerTransport - The fee payer transport to use.
+ * @returns A relay transport.
+ */
+export function withFeePayer(
+  defaultTransport: Transport,
+  relayTransport: Transport,
+): withFeePayer.ReturnValue {
+  return (config) => {
+    const transport_default = defaultTransport(config)
+    const transport_relay = relayTransport(config)
+
+    return createTransport({
+      key: withFeePayer.type,
+      name: 'Relay Proxy',
+      async request({ method, params }, options) {
+        if (
+          method === 'eth_sendRawTransactionSync' ||
+          method === 'eth_sendRawTransaction'
+        ) {
+          const serialized = (params as any)[0] as `0x77${string}`
+          const transaction = parseTransaction(serialized)
+          // If the transaction is intended to be sponsored, forward it to the relay.
+          if (transaction.feePayerSignature === null)
+            return transport_relay.request({ method, params }, options) as never
+        }
+        return transport_default.request({ method, params }, options) as never
+      },
+      type: withFeePayer.type,
+    })
+  }
+}
+
+export declare namespace withFeePayer {
+  export const type = 'feePayer'
+
+  export type ReturnValue = Relay
+}

package/src/viem/types.ts

@@ -0,0 +1,55 @@
+import type {
+  Account,
+  Address,
+  Chain,
+  ReadContractParameters as viem_ReadContractParameters,
+  WriteContractParameters as viem_WriteContractParameters,
+} from 'viem'
+import type {
+  IsUndefined,
+  MaybeRequired,
+  UnionPick,
+} from '../internal/types.js'
+import type { TransactionRequestFeeToken } from './transaction.js'
+
+export type GetAccountParameter<
+  account extends Account | undefined = Account | undefined,
+  accountOverride extends Account | Address | undefined = Account | Address,
+  required extends boolean = true,
+  nullish extends boolean = false,
+> = MaybeRequired<
+  {
+    account?:
+      | accountOverride
+      | Account
+      | Address
+      | (nullish extends true ? null : never)
+      | undefined
+  },
+  IsUndefined<account> extends true
+    ? required extends true
+      ? true
+      : false
+    : false
+>
+
+export type ReadParameters = Pick<
+  viem_ReadContractParameters<never, never, never>,
+  'account' | 'blockNumber' | 'blockOverrides' | 'blockTag' | 'stateOverride'
+>
+
+export type TokenIdOrAddress = bigint | Address
+
+export type WriteParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+> = UnionPick<
+  viem_WriteContractParameters<never, never, never, chain, account>,
+  | 'account'
+  | 'chain'
+  | 'gas'
+  | 'maxFeePerGas'
+  | 'maxPriorityFeePerGas'
+  | 'nonce'
+> &
+  UnionPick<TransactionRequestFeeToken, 'feePayer' | 'feeToken'>

package/src/viem/utils.ts

@@ -0,0 +1,37 @@
+import {
+  type Abi,
+  type AbiStateMutability,
+  type Address,
+  type ContractFunctionName,
+  type ContractFunctionParameters,
+  type ExtractAbiItem,
+  encodeFunctionData,
+  type Hex,
+} from 'viem'
+
+export function defineCall<
+  const abi extends Abi,
+  const functionName extends ContractFunctionName<abi, AbiStateMutability>,
+  call extends ContractFunctionParameters<
+    abi,
+    AbiStateMutability,
+    functionName
+  >,
+>(
+  call:
+    | call
+    | ContractFunctionParameters<abi, AbiStateMutability, functionName>,
+): ContractFunctionParameters<
+  [ExtractAbiItem<abi, functionName>],
+  AbiStateMutability,
+  functionName
+> & {
+  data: Hex
+  to: Address
+} {
+  return {
+    ...(call as any),
+    data: encodeFunctionData(call as never),
+    to: call.address,
+  } as const
+}