tempo.ts 0.11.1 → 0.12.0

package/src/viem/Transport.ts

@@ -1,191 +0,0 @@
-import * as Address from 'ox/Address'
-import * as Hash from 'ox/Hash'
-import * as Hex from 'ox/Hex'
-import * as Provider from 'ox/Provider'
-import * as RpcRequest from 'ox/RpcRequest'
-import { createClient, createTransport, type Transport } from 'viem'
-import {
-  getTransactionReceipt,
-  sendTransaction,
-  sendTransactionSync,
-} from 'viem/actions'
-import type * as tempo_Chain from './Chain.js'
-import * as Transaction from './Transaction.js'
-
-export type FeePayer = Transport<typeof withFeePayer.type>
-
-/**
- * Creates a fee payer transport that routes requests between
- * the default transport or the fee payer transport.
- *
- * The policy parameter controls how the fee payer handles transactions:
- * - `'sign-only'`: Fee payer co-signs the transaction and returns it to the client transport, which then broadcasts it via the default transport
- * - `'sign-and-broadcast'`: Fee payer co-signs and broadcasts the transaction directly
- *
- * @param defaultTransport - The default transport to use.
- * @param feePayerTransport - The fee payer transport to use.
- * @param parameters - Configuration parameters.
- * @returns A relay transport.
- */
-export function withFeePayer(
-  defaultTransport: Transport,
-  relayTransport: Transport,
-  parameters?: withFeePayer.Parameters,
-): withFeePayer.ReturnValue {
-  const { policy = 'sign-only' } = parameters ?? {}
-
-  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 `0x76${string}`
-          const transaction = Transaction.deserialize(serialized)
-
-          // If the transaction is intended to be sponsored, forward it to the relay.
-          if (transaction.feePayerSignature === null) {
-            // For 'sign-and-broadcast', relay signs and broadcasts
-            if (policy === 'sign-and-broadcast')
-              return transport_relay.request(
-                { method, params },
-                options,
-              ) as never
-
-            // For 'sign-only', request signature from relay using eth_signRawTransaction
-            {
-              // Request signature from relay using eth_signRawTransaction
-              const signedTransaction = await transport_relay.request(
-                {
-                  method: 'eth_signRawTransaction',
-                  params: [serialized],
-                },
-                options,
-              )
-
-              // Broadcast the signed transaction via the default transport
-              return transport_default.request(
-                { method, params: [signedTransaction] },
-                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 Parameters = {
-    /** Policy for how the fee payer should handle transactions. Defaults to `'sign-only'`. */
-    policy?: 'sign-only' | 'sign-and-broadcast' | undefined
-  }
-
-  export type ReturnValue = FeePayer
-}
-
-/**
- * Creates a transport that instruments a compatibility layer for
- * `wallet_` RPC actions (`sendCalls`, `getCallsStatus`, etc).
- *
- * @param transport - Transport to wrap.
- * @returns Transport.
- */
-export function walletNamespaceCompat(transport: Transport): Transport {
-  const sendCallsMagic = Hash.keccak256(Hex.fromString('TEMPO_5792'))
-
-  return (options) => {
-    const t = transport(options)
-
-    const account = options.account
-
-    type Chain = ReturnType<ReturnType<typeof tempo_Chain.define>>
-    const chain = options.chain as Chain
-
-    return {
-      ...t,
-      async request(args: never) {
-        const request = RpcRequest.from(args)
-
-        const client = createClient({
-          account,
-          chain,
-          transport,
-        })
-
-        if (request.method === 'wallet_sendCalls') {
-          const params = request.params[0] ?? {}
-          const { capabilities, chainId, from } = params
-          const { sync } = capabilities ?? {}
-
-          if (!account) throw new Provider.DisconnectedError()
-          if (!chainId) throw new Provider.UnsupportedChainIdError()
-          if (Number(chainId) !== client.chain.id)
-            throw new Provider.UnsupportedChainIdError()
-          if (from && !Address.isEqual(from, account.address))
-            throw new Provider.DisconnectedError()
-
-          const calls = (params.calls ?? []).map((call) => ({
-            to: call.to,
-            value: call.value ? BigInt(call.value) : undefined,
-            data: call.data,
-          }))
-
-          const hash = await (async () => {
-            if (!sync)
-              return sendTransaction(client, {
-                account,
-                calls,
-              })
-
-            const { transactionHash } = await sendTransactionSync(client, {
-              account,
-              calls,
-            })
-            return transactionHash
-          })()
-
-          const id = Hex.concat(hash, Hex.padLeft(chainId, 32), sendCallsMagic)
-
-          return {
-            capabilities: { sync },
-            id,
-          }
-        }
-
-        if (request.method === 'wallet_getCallsStatus') {
-          const [id] = request.params ?? []
-          if (!id) throw new Error('`id` not found')
-          if (!id.endsWith(sendCallsMagic.slice(2)))
-            throw new Error('`id` not supported')
-          Hex.assert(id)
-
-          const hash = Hex.slice(id, 0, 32)
-          const chainId = Hex.slice(id, 32, 64)
-
-          const receipt = await getTransactionReceipt(client, { hash })
-          return {
-            atomic: true,
-            chainId: Number(chainId),
-            receipts: [receipt],
-            status: receipt.status === 'success' ? 200 : 500,
-            version: '2.0.0',
-          }
-        }
-
-        return t.request(args)
-      },
-    } as never
-  }
-}

package/src/viem/WebAuthnP256.ts

@@ -1,146 +0,0 @@
-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 { metadata, raw, signature } = await WebAuthnP256.sign({
-    ...parameters,
-    challenge: parameters.hash ?? '0x',
-  })
-  const publicKey = await parameters.getPublicKey(raw)
-  return {
-    id: raw.id,
-    metadata,
-    publicKey,
-    raw,
-    signature,
-  }
-}
-
-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 = WebAuthnP256.sign.ReturnType & {
-    id: string
-    publicKey: Hex.Hex
-  }
-}

package/src/viem/WebCryptoP256.ts

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