tempo.ts 0.1.5 → 0.2.0

package/src/viem/Formatters.ts

@@ -1,16 +1,21 @@
+// TODO: Find opportunities to make this file less duplicated + more simplified with Viem v3.
+
 import * as Hex from 'ox/Hex'
 import {
+  type Chain,
+  type Account as viem_Account,
   formatTransaction as viem_formatTransaction,
   formatTransactionRequest as viem_formatTransactionRequest,
 } from 'viem'
 import { parseAccount } from 'viem/accounts'
+import type { UnionOmit } from '../internal/types.js'
 import * as ox_Transaction from '../ox/Transaction.js'
 import * as ox_TransactionRequest from '../ox/TransactionRequest.js'
+import type { GetFeeTokenParameter } from './internal/types.js'
 import {
   isTempo,
   type Transaction,
   type TransactionRequest,
-  type TransactionRequestAA,
   type TransactionRequestRpc,
   type TransactionRpc,
 } from './Transaction.js'
@@ -53,12 +58,21 @@ export const formatTransaction = (
   }
 }
 
-export const formatTransactionRequest = (
-  r: TransactionRequest,
+type Request<chain extends Chain | undefined> = UnionOmit<
+  TransactionRequest,
+  'feeToken'
+> &
+  GetFeeTokenParameter<chain> & { account?: viem_Account | undefined }
+export const formatTransactionRequest = <chain extends Chain | undefined>(
+  r: Request<chain>,
   action?: string | undefined,
 ): TransactionRequestRpc => {
-  const request = r as TransactionRequestAA
+  const request = r as Request<chain>
+
+  // Convert EIP-1559 transactions to AA transactions.
+  if (request.type === 'eip1559') (request as any).type = 'aa'
 
+  // If the request is not a Tempo transaction, route to Viem formatter.
   if (!isTempo(request))
     return viem_formatTransactionRequest(
       r as never,
@@ -85,7 +99,7 @@ export const formatTransactionRequest = (
     })),
     nonce: request.nonce ? BigInt(request.nonce) : undefined,
     type: 'aa',
-  })
+  } as never)
 
   if (action === 'estimateGas') {
     rpc.maxFeePerGas = undefined
@@ -97,8 +111,20 @@ export const formatTransactionRequest = (
   rpc.data = undefined
   rpc.value = undefined
 
+  const [keyType, keyData] = (() => {
+    if (!r.account?.source) return [undefined, undefined]
+    if (r.account.source === 'webAuthn')
+      // TODO: derive correct bytes size of key data based on webauthn create metadata.
+      return ['webAuthn', `0x${'ff'.repeat(1400)}`]
+    if (['p256', 'secp256k1'].includes(r.account.source))
+      return [r.account.source, undefined]
+    return [undefined, undefined]
+  })()
+
   return {
     ...rpc,
+    ...(keyType ? { keyType } : {}),
+    ...(keyData ? { keyData } : {}),
     ...(request.feePayer
       ? {
           feePayer:

package/src/viem/P256.ts

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

package/src/viem/Secp256k1.ts

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

package/src/viem/TokenIds.ts

@@ -1,2 +1 @@
-export const defaultFeeToken = 1n
-export const defaultQuoteToken = 0n
+export const linkingUsd = 0n

package/src/viem/Transaction.ts

@@ -1,3 +1,5 @@
+// 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'
@@ -150,8 +152,16 @@ export function deserialize<
   const serialized extends TransactionSerializedGeneric,
 >(serializedTransaction: serialized): deserialize.ReturnValue<serialized> {
   const type = Hex.slice(serializedTransaction, 0, 1)
-  if (type === '0x76')
-    return deserializeAA(serializedTransaction as `0x76${string}`) as never
+  if (type === '0x76') {
+    const from =
+      Hex.slice(serializedTransaction, -6) === '0xfeefeefeefee'
+        ? Hex.slice(serializedTransaction, -26, -6)
+        : undefined
+    return {
+      ...deserializeAA(serializedTransaction as `0x76${string}`),
+      from,
+    } as never
+  }
   return viem_parseTransaction(serializedTransaction) as never
 }
 
@@ -169,10 +179,31 @@ export async function serialize(
     feePayer?: Account | true | undefined
     from?: Address | undefined
   },
-  signature?: viem_Signature | undefined,
+  signature?:
+    | OneOf<SignatureEnvelope.SignatureEnvelope | viem_Signature>
+    | undefined,
 ) {
-  if (!isTempo(transaction))
+  // Convert EIP-1559 transactions to AA transactions.
+  if (transaction.type === 'eip1559') (transaction as any).type = 'aa'
+
+  // 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 === 'aa')
@@ -215,10 +246,11 @@ async function serializeAA(
     feePayer?: Account | true | undefined
     from?: Address | undefined
   },
-  sig?: viem_Signature | 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!),
@@ -275,12 +307,13 @@ async function serializeAA(
     })
 
     const sender = (() => {
+      if (transaction.from) return transaction.from
       if (signature.type === 'secp256k1')
         return Secp256k1.recoverAddress({
           payload: TxAA.getSignPayload(tx),
           signature: signature.signature,
         })
-      throw new Error('Unsupported signature type')
+      throw new Error('Unable to extract sender from transaction or signature.')
     })()
 
     const hash = TxAA.getFeePayerSignPayload(tx, {
@@ -296,8 +329,21 @@ async function serializeAA(
     })
   }
 
+  if (feePayer === true) {
+    const serialized = TxAA.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 TxAA.serialize(transaction_ox, {
-    feePayerSignature: feePayer === true ? null : undefined,
+    feePayerSignature: undefined,
     signature,
   })
 }

package/src/viem/WebAuthnP256.ts

@@ -0,0 +1,140 @@
+import * as Bytes from 'ox/Bytes'
+import type * as Hex from 'ox/Hex'
+import * as PublicKey from 'ox/PublicKey'
+import * as WebAuthnP256 from 'ox/WebAuthnP256'
+
+export type P256Credential = {
+  id: WebAuthnP256.P256Credential['id']
+  publicKey: Hex.Hex
+  raw: WebAuthnP256.P256Credential['raw']
+}
+
+/**
+ * Creates a WebAuthn credential (ie. a passkey).
+ *
+ * This function returns the credential object, which includes the public key.
+ * It is recommended to store the public key against the credential in an external store
+ * as it is not possible to extract a public key from a credential after it has been created.
+ *
+ * @example
+ * ```ts
+ * import { WebAuthnP256 } from 'tempo.ts/viem'
+ *
+ * const credential = await WebAuthnP256.createCredential({ name: 'Example' })
+ * // {
+ * //   id: 'oZ48...',
+ * //   publicKey: '0x...',
+ * // }
+ * ```
+ *
+ * @param parameters WebAuthnP256 createCredential options.
+ * @returns WebAuthn credential.
+ */
+export async function createCredential(
+  parameters: createCredential.Parameters,
+): Promise<createCredential.ReturnValue> {
+  const { createFn, label, rpId, userId } = parameters
+  const credential = await WebAuthnP256.createCredential({
+    ...parameters,
+    authenticatorSelection: {
+      ...parameters.authenticatorSelection,
+      requireResidentKey: true,
+      residentKey: 'required',
+      userVerification: 'required',
+    },
+    createFn,
+    extensions: {
+      ...parameters.extensions,
+      credProps: true,
+    },
+    rp: rpId
+      ? {
+          id: rpId,
+          name: rpId,
+        }
+      : undefined,
+    name: undefined as never,
+    user: {
+      displayName: label,
+      id: new Uint8Array(userId ?? Bytes.fromString(label)),
+      name: label,
+    },
+  })
+  return {
+    id: credential.id,
+    publicKey: PublicKey.toHex(credential.publicKey, {
+      includePrefix: false,
+    }),
+    raw: credential.raw,
+  }
+}
+
+export declare namespace createCredential {
+  export type Parameters = Omit<
+    WebAuthnP256.createCredential.Options,
+    'rp' | 'user'
+  > & {
+    /**
+     * Credential creation function. Useful for environments that do not support
+     * the WebAuthn API natively (i.e. React Native or testing environments).
+     *
+     * @default window.navigator.credentials.create
+     */
+    createFn?: WebAuthnP256.createCredential.Options['createFn'] | undefined
+    /** Label. */
+    label: string
+    /** Relying Party ID. */
+    rpId?: string | undefined
+    /** User ID. */
+    userId?: Bytes.Bytes | undefined
+  }
+
+  export type ReturnValue = P256Credential
+}
+
+/**
+ * Gets a WebAuthn credential (ie. a passkey), and optionally signs over a digest/hash.
+ *
+ * A `getPublicKey` function is required to fetch the public key paired with the credential
+ * from an external store. It is not possible to extract a public key from a credential after
+ * the credential has been created with `WebAuthnP256.createCredential`.
+ *
+ * @example
+ * ```ts
+ * import { WebAuthnP256 } from 'tempo.ts/viem'
+ *
+ * const credential = await WebAuthnP256.getCredential({
+ *   async getPublicKey(credential) {
+ *     // Get public key from store
+ *     return store.getPublicKey(credential.id)
+ *   }
+ * })
+ * ```
+ *
+ * @param parameters WebAuthnP256 getCredential options.
+ * @returns WebAuthn credential.
+ */
+export async function getCredential(
+  parameters: getCredential.Parameters,
+): Promise<getCredential.ReturnValue> {
+  const { raw } = await WebAuthnP256.sign({
+    ...parameters,
+    challenge: parameters.hash ?? '0x',
+  })
+  const publicKey = await parameters.getPublicKey(raw)
+  return {
+    id: raw.id,
+    publicKey,
+    raw,
+  }
+}
+
+export declare namespace getCredential {
+  export type Parameters = Omit<WebAuthnP256.sign.Options, 'challenge'> & {
+    hash?: Hex.Hex | undefined
+    getPublicKey: (
+      credential: WebAuthnP256.P256Credential['raw'],
+    ) => Promise<Hex.Hex>
+  }
+  export type ReturnValue = P256Credential
+}

package/src/viem/WebCryptoP256.ts

@@ -0,0 +1 @@
+export { createKeyPair } from 'ox/WebCryptoP256'