@wagmi/core 3.2.2 → 3.3.0

package/src/query/writeContractSync.ts

@@ -0,0 +1,130 @@
+import type { MutateOptions, MutationOptions } from '@tanstack/query-core'
+import type { Abi, ContractFunctionArgs, ContractFunctionName } from 'viem'
+import {
+  type WriteContractSyncErrorType,
+  type WriteContractSyncParameters,
+  type WriteContractSyncReturnType,
+  writeContractSync,
+} from '../actions/writeContractSync.js'
+import type { Config } from '../createConfig.js'
+import type { MutationParameter } from '../types/query.js'
+import type { Compute } from '../types/utils.js'
+
+export type WriteContractSyncOptions<
+  config extends Config,
+  context = unknown,
+> = MutationParameter<
+  WriteContractSyncData,
+  WriteContractSyncErrorType,
+  WriteContractSyncVariables<
+    Abi,
+    string,
+    readonly unknown[],
+    config,
+    config['chains'][number]['id']
+  >,
+  context
+>
+
+export function writeContractSyncMutationOptions<
+  config extends Config,
+  context,
+>(
+  config: config,
+  options: WriteContractSyncOptions<config, context> = {},
+): WriteContractSyncMutationOptions<config> {
+  return {
+    ...(options.mutation as any),
+    mutationFn(variables) {
+      return writeContractSync(config, variables)
+    },
+    mutationKey: ['writeContractSync'],
+  }
+}
+
+export type WriteContractSyncMutationOptions<config extends Config> =
+  MutationOptions<
+    WriteContractSyncData,
+    WriteContractSyncErrorType,
+    WriteContractSyncVariables<
+      Abi,
+      string,
+      readonly unknown[],
+      config,
+      config['chains'][number]['id']
+    >
+  >
+
+export type WriteContractSyncData = Compute<WriteContractSyncReturnType>
+
+export type WriteContractSyncVariables<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = WriteContractSyncParameters<abi, functionName, args, config, chainId>
+
+export type WriteContractSyncMutate<
+  config extends Config,
+  context = unknown,
+> = <
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: WriteContractSyncVariables<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId
+  >,
+  options?:
+    | MutateOptions<
+        WriteContractSyncData,
+        WriteContractSyncErrorType,
+        WriteContractSyncVariables<abi, functionName, args, config, chainId>,
+        context
+      >
+    | undefined,
+) => void
+
+export type WriteContractSyncMutateAsync<
+  config extends Config,
+  context = unknown,
+> = <
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  chainId extends config['chains'][number]['id'],
+>(
+  variables: WriteContractSyncVariables<
+    abi,
+    functionName,
+    args,
+    config,
+    chainId
+  >,
+  options?:
+    | MutateOptions<
+        WriteContractSyncData,
+        WriteContractSyncErrorType,
+        WriteContractSyncVariables<abi, functionName, args, config, chainId>,
+        context
+      >
+    | undefined,
+) => Promise<WriteContractSyncData>

package/src/tempo/Connectors.ts

@@ -91,7 +91,9 @@ export function webAuthn(options: webAuthn.Parameters) {
         'webAuthn.activeCredential',
       )
       if (!credential) return
-      account = Account.fromWebAuthnP256(credential)
+      account = Account.fromWebAuthnP256(credential, {
+        rpId: options.getOptions?.rpId ?? options.rpId,
+      })
     },
     async connect(parameters = {}) {
       const capabilities =
@@ -243,7 +245,9 @@ export function webAuthn(options: webAuthn.Parameters) {
         normalizeValue(credential),
       )
 
-      account = Account.fromWebAuthnP256(credential)
+      account = Account.fromWebAuthnP256(credential, {
+        rpId: options.getOptions?.rpId ?? options.rpId,
+      })
 
       if (keyPair) {
         accessKey = Account.fromWebCryptoP256(keyPair, {
@@ -360,17 +364,16 @@ export function webAuthn(options: webAuthn.Parameters) {
 
       const targetAccount = await (async () => {
         if (!accessKey) return account
+        if (!account) throw new Error('account not found.')
 
-        const item = await idb.get(
-          `accessKey:${accessKey.address.toLowerCase()}`,
-        )
+        const item = await idb.get(`accessKey:${account.address.toLowerCase()}`)
         if (
           item?.keyAuthorization.expiry &&
           item.keyAuthorization.expiry < Date.now() / 1000
         ) {
           // remove any pending key authorizations from storage.
           await config?.storage?.removeItem(
-            `pendingKeyAuthorization:${accessKey.address.toLowerCase()}`,
+            `pendingKeyAuthorization:${account.address.toLowerCase()}`,
           )
 
           const message = `Access key expired (on ${new Date(item.keyAuthorization.expiry * 1000).toLocaleString()}).`

package/src/tempo/KeyManager.ts

@@ -1,4 +1,5 @@
 import type { WebAuthnP256 } from 'ox'
+import * as Base64 from 'ox/Base64'
 import type * as Hex from 'ox/Hex'
 import * as Json from 'ox/Json'
 import {
@@ -158,7 +159,10 @@ export function http(
           headers: {
             'Content-Type': 'application/json',
           },
-          body: Json.stringify(parameters),
+          body: Json.stringify({
+            ...parameters,
+            credential: serializeCredential(parameters.credential),
+          }),
         },
       )
 
@@ -174,3 +178,62 @@ export namespace http {
     fetch?: typeof fetch | undefined
   }
 }
+
+/**
+ * Serializes a WebAuthn credential for JSON transmission.
+ * @internal
+ */
+function serializeCredential(
+  credential: WebAuthnP256.P256Credential['raw'],
+): Record<string, unknown> {
+  const response = credential.response
+  return {
+    ...credential,
+    rawId: Base64.fromBytes(new Uint8Array(credential.rawId)),
+    response: {
+      clientDataJSON: Base64.fromBytes(new Uint8Array(response.clientDataJSON)),
+      ...('attestationObject' in response && {
+        attestationObject: Base64.fromBytes(
+          new Uint8Array(response.attestationObject as ArrayBuffer),
+        ),
+      }),
+      ...('getAuthenticatorData' in response &&
+        typeof response.getAuthenticatorData === 'function' && {
+          authenticatorData: Base64.fromBytes(
+            new Uint8Array(response.getAuthenticatorData() as ArrayBuffer),
+          ),
+        }),
+      ...('getPublicKey' in response &&
+        typeof response.getPublicKey === 'function' && {
+          publicKey: Base64.fromBytes(
+            new Uint8Array(response.getPublicKey() as ArrayBuffer),
+          ),
+        }),
+      ...('getPublicKeyAlgorithm' in response &&
+        typeof response.getPublicKeyAlgorithm === 'function' && {
+          publicKeyAlgorithm: response.getPublicKeyAlgorithm(),
+        }),
+      ...('getTransports' in response &&
+        typeof response.getTransports === 'function' && {
+          transports: response.getTransports(),
+        }),
+      ...('authenticatorData' in response && {
+        authenticatorData: Base64.fromBytes(
+          new Uint8Array(response.authenticatorData as ArrayBuffer),
+        ),
+      }),
+      ...('signature' in response && {
+        signature: Base64.fromBytes(
+          new Uint8Array(response.signature as ArrayBuffer),
+        ),
+      }),
+      ...('userHandle' in response && response.userHandle
+        ? {
+            userHandle: Base64.fromBytes(
+              new Uint8Array(response.userHandle as ArrayBuffer),
+            ),
+          }
+        : {}),
+    },
+  }
+}

package/src/types/query.ts

@@ -1,5 +1,19 @@
 import type * as Query from '@tanstack/query-core'
-import type { RequiredBy, UnionLooseOmit } from './utils.js'
+import type { Compute, LooseOmit, RequiredBy, UnionLooseOmit } from './utils.js'
+
+export type MutationParameter<
+  data = unknown,
+  error = Error,
+  variables = void,
+  context = unknown,
+> = {
+  mutation?:
+    | LooseOmit<
+        Query.MutationOptions<data, error, Compute<variables>, context>,
+        'mutationFn' | 'mutationKey' | 'throwOnError'
+      >
+    | undefined
+}
 
 export type QueryParameter<
   queryFnData = unknown,

package/src/version.ts

@@ -1 +1 @@
-export const version = '3.2.2'
+export const version = '3.3.0'