viem 2.51.3 → 2.52.0

package/_esm/tempo/actions/accessKey.js

@@ -1,5 +1,6 @@
 import { parseAccount } from '../../accounts/utils/parseAccount.js';
 import { readContract } from '../../actions/public/readContract.js';
+import { watchContractEvent } from '../../actions/public/watchContractEvent.js';
 import { sendTransaction } from '../../actions/wallet/sendTransaction.js';
 import { sendTransactionSync } from '../../actions/wallet/sendTransactionSync.js';
 import { writeContract } from '../../actions/wallet/writeContract.js';
@@ -58,7 +59,7 @@ export async function authorize(client, parameters) {
 (function (authorize) {
     /** @internal */
     async function inner(action, client, parameters) {
-        const { accessKey, chainId = client.chain?.id, expiry, limits, scopes, ...rest } = parameters;
+        const { accessKey, admin, chainId = client.chain?.id, expiry, limits, scopes, witness, ...rest } = parameters;
         const account_ = rest.account ?? client.account;
         if (!account_)
             throw new Error('account is required.');
@@ -68,9 +69,11 @@ export async function authorize(client, parameters) {
         const keyAuthorization = await signKeyAuthorization(parsed, {
             chainId: BigInt(chainId),
             key: accessKey,
+            admin,
             expiry,
             limits,
             scopes,
+            witness,
         });
         return (await action(client, {
             ...rest,
@@ -134,6 +137,398 @@ export async function authorizeSync(client, parameters) {
         receipt,
     };
 }
+/**
+ * Burns a key-authorization witness, invalidating any authorization bound to
+ * it before it is submitted onchain.
+ *
+ * Once burned, an `authorizeKey` call carrying the same `witness` will revert.
+ * This lets applications issue a signed authorization offchain (see
+ * {@link authorize}) while retaining the ability to revoke it.
+ *
+ * [TIP-1053](https://tips.sh/1053)
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' }),
+ *   transport: http(),
+ * })
+ *
+ * const hash = await Actions.accessKey.burnWitness(client, {
+ *   witness: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction hash.
+ */
+export async function burnWitness(client, parameters) {
+    return burnWitness.inner(writeContract, client, parameters);
+}
+(function (burnWitness) {
+    /** @internal */
+    async function inner(action, client, parameters) {
+        const { witness, ...rest } = parameters;
+        const call = burnWitness.call({ witness });
+        return (await action(client, {
+            ...rest,
+            ...call,
+        }));
+    }
+    burnWitness.inner = inner;
+    /**
+     * Defines a call to the `burnKeyAuthorizationWitness` function.
+     *
+     * Can be passed as a parameter to:
+     * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
+     * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
+     * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
+     *
+     * @example
+     * ```ts
+     * import { createClient, http, walletActions } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { Actions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' }),
+     *   transport: http(),
+     * }).extend(walletActions)
+     *
+     * const hash = await client.sendTransaction({
+     *   calls: [
+     *     Actions.accessKey.burnWitness.call({ witness: '0x...' }),
+     *   ],
+     * })
+     * ```
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { witness } = args;
+        return defineCall({
+            address: Addresses.accountKeychain,
+            abi: Abis.accountKeychain,
+            functionName: 'burnKeyAuthorizationWitness',
+            args: [witness],
+        });
+    }
+    burnWitness.call = call;
+    function extractEvent(logs) {
+        const [log] = parseEventLogs({
+            abi: Abis.accountKeychain,
+            logs,
+            eventName: 'KeyAuthorizationWitnessBurned',
+            strict: true,
+        });
+        if (!log)
+            throw new Error('`KeyAuthorizationWitnessBurned` event not found.');
+        return log;
+    }
+    burnWitness.extractEvent = extractEvent;
+})(burnWitness || (burnWitness = {}));
+/**
+ * Burns a key-authorization witness and waits for the transaction receipt.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' }),
+ *   transport: http(),
+ * })
+ *
+ * const { receipt, ...result } = await Actions.accessKey.burnWitnessSync(client, {
+ *   witness: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction receipt and event data.
+ */
+export async function burnWitnessSync(client, parameters) {
+    const { throwOnReceiptRevert = true, ...rest } = parameters;
+    const receipt = await burnWitness.inner(writeContractSync, client, {
+        ...rest,
+        throwOnReceiptRevert,
+    });
+    const { args } = burnWitness.extractEvent(receipt.logs);
+    return {
+        ...args,
+        receipt,
+    };
+}
+/**
+ * Gets access key information.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' }),
+ *   transport: http(),
+ * })
+ *
+ * const key = await Actions.accessKey.getMetadata(client, {
+ *   account: '0x...',
+ *   accessKey: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The key information.
+ */
+export async function getMetadata(client, parameters) {
+    const { account: account_ = client.account, accessKey, ...rest } = parameters;
+    if (!account_)
+        throw new Error('account is required.');
+    const account = parseAccount(account_);
+    const result = await readContract(client, {
+        ...rest,
+        account: null,
+        ...getMetadata.call({ account: account.address, accessKey }),
+    });
+    return {
+        address: result.keyId,
+        keyType: signatureTypes[result.signatureType] ??
+            'secp256k1',
+        expiry: result.expiry,
+        spendPolicy: spendPolicies[`${result.enforceLimits}`],
+        isRevoked: result.isRevoked,
+    };
+}
+(function (getMetadata) {
+    /**
+     * Defines a call to the `getKey` function.
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { account, accessKey } = args;
+        return defineCall({
+            address: Addresses.accountKeychain,
+            abi: Abis.accountKeychain,
+            functionName: 'getKey',
+            args: [account, resolveAccessKeyAddress(accessKey)],
+        });
+    }
+    getMetadata.call = call;
+})(getMetadata || (getMetadata = {}));
+/**
+ * Gets the remaining spending limit for a key-token pair.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' }),
+ *   transport: http(),
+ * })
+ *
+ * const { remaining, periodEnd } = await Actions.accessKey.getRemainingLimit(client, {
+ *   account: '0x...',
+ *   accessKey: '0x...',
+ *   token: '0x...',
+ * })
+ *
+ * console.log(remaining, periodEnd)
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The remaining spending amount and period end timestamp.
+ */
+export async function getRemainingLimit(client, parameters) {
+    const { account: account_ = client.account, accessKey, token, ...rest } = parameters;
+    if (!account_)
+        throw new Error('account is required.');
+    const account = parseAccount(account_);
+    // TODO: remove pre-t3 branch once mainnet is on t3.
+    const hardfork = client.chain?.hardfork;
+    if (hardfork && Hardfork.lt(hardfork, 't3')) {
+        const remaining = await readContract(client, {
+            ...rest,
+            ...getRemainingLimit.call({ account: account.address, accessKey, token }),
+        });
+        return { remaining, periodEnd: undefined };
+    }
+    const [remaining, periodEnd] = await readContract(client, {
+        ...rest,
+        ...getRemainingLimit.callWithPeriod({
+            account: account.address,
+            accessKey,
+            token,
+        }),
+    });
+    return { remaining, periodEnd };
+}
+(function (getRemainingLimit) {
+    /**
+     * Defines a call to the `getRemainingLimit` function (pre-T3).
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { account, accessKey, token } = args;
+        return defineCall({
+            address: Addresses.accountKeychain,
+            abi: Abis.accountKeychain,
+            functionName: 'getRemainingLimit',
+            args: [account, resolveAccessKeyAddress(accessKey), token],
+        });
+    }
+    getRemainingLimit.call = call;
+    /**
+     * Defines a call to the `getRemainingLimitWithPeriod` function (T3+).
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function callWithPeriod(args) {
+        const { account, accessKey, token } = args;
+        return defineCall({
+            address: Addresses.accountKeychain,
+            abi: Abis.accountKeychain,
+            functionName: 'getRemainingLimitWithPeriod',
+            args: [account, resolveAccessKeyAddress(accessKey), token],
+        });
+    }
+    getRemainingLimit.callWithPeriod = callWithPeriod;
+})(getRemainingLimit || (getRemainingLimit = {}));
+/**
+ * Checks whether an access key is an admin key for an account.
+ *
+ * Returns `true` for the account's root key or for an active admin access key
+ * (see {@link authorize} with `admin: true`).
+ *
+ * [TIP-1049](https://tips.sh/1049)
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' }),
+ *   transport: http(),
+ * })
+ *
+ * const isAdmin = await Actions.accessKey.isAdmin(client, {
+ *   account: '0x...',
+ *   accessKey: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Whether the access key is an admin key.
+ */
+export async function isAdmin(client, parameters) {
+    const { account: account_ = client.account, accessKey, ...rest } = parameters;
+    if (!account_)
+        throw new Error('account is required.');
+    const account = parseAccount(account_);
+    return readContract(client, {
+        ...rest,
+        account: null,
+        ...isAdmin.call({ account: account.address, accessKey }),
+    });
+}
+(function (isAdmin) {
+    /**
+     * Defines a call to the `isAdminKey` function.
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { account, accessKey } = args;
+        return defineCall({
+            address: Addresses.accountKeychain,
+            abi: Abis.accountKeychain,
+            functionName: 'isAdminKey',
+            args: [account, resolveAccessKeyAddress(accessKey)],
+        });
+    }
+    isAdmin.call = call;
+})(isAdmin || (isAdmin = {}));
+/**
+ * Checks whether a key-authorization witness has been burned for an account.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' }),
+ *   transport: http(),
+ * })
+ *
+ * const isBurned = await Actions.accessKey.isWitnessBurned(client, {
+ *   account: '0x...',
+ *   witness: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Whether the witness has been burned.
+ */
+export async function isWitnessBurned(client, parameters) {
+    const { account: account_ = client.account, witness, ...rest } = parameters;
+    if (!account_)
+        throw new Error('account is required.');
+    const account = parseAccount(account_);
+    return readContract(client, {
+        ...rest,
+        account: null,
+        ...isWitnessBurned.call({ account: account.address, witness }),
+    });
+}
+(function (isWitnessBurned) {
+    /**
+     * Defines a call to the `isKeyAuthorizationWitnessBurned` function.
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { account, witness } = args;
+        return defineCall({
+            address: Addresses.accountKeychain,
+            abi: Abis.accountKeychain,
+            functionName: 'isKeyAuthorizationWitnessBurned',
+            args: [account, witness],
+        });
+    }
+    isWitnessBurned.call = call;
+})(isWitnessBurned || (isWitnessBurned = {}));
 /**
  * Revokes an authorized access key.
  *
@@ -262,6 +657,47 @@ export async function revokeSync(client, parameters) {
         receipt,
     };
 }
+/**
+ * Signs a key authorization for an access key.
+ *
+ * @example
+ * ```ts
+ * import { generatePrivateKey } from 'viem/accounts'
+ * import { Account, Actions } from 'viem/tempo'
+ *
+ * const account = Account.from({ privateKey: '0x...' })
+ * const accessKey = Account.fromP256(generatePrivateKey(), {
+ *   access: account,
+ * })
+ *
+ * const keyAuthorization = await Actions.accessKey.signAuthorization(
+ *   client,
+ *   {
+ *     account,
+ *     accessKey,
+ *     expiry: Math.floor((Date.now() + 30_000) / 1000),
+ *   },
+ * )
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The signed key authorization.
+ */
+export async function signAuthorization(client, parameters) {
+    const { accessKey, chainId = client.chain?.id, ...rest } = parameters;
+    const account_ = rest.account ?? client.account;
+    if (!account_)
+        throw new Error('account is required.');
+    if (!chainId)
+        throw new Error('chainId is required.');
+    const parsed = parseAccount(account_);
+    return signKeyAuthorization(parsed, {
+        chainId: BigInt(chainId),
+        key: accessKey,
+        ...rest,
+    });
+}
 /**
  * Updates the spending limit for a specific token on an authorized access key.
  *
@@ -402,7 +838,12 @@ export async function updateLimitSync(client, parameters) {
     };
 }
 /**
- * Gets access key information.
+ * Watches for admin key authorization events.
+ *
+ * Emitted when an admin key is authorized (see {@link authorize} with
+ * `admin: true`).
+ *
+ * [TIP-1049](https://tips.sh/1049)
  *
  * @example
  * ```ts
@@ -415,55 +856,35 @@ export async function updateLimitSync(client, parameters) {
  *   transport: http(),
  * })
  *
- * const key = await Actions.accessKey.getMetadata(client, {
- *   account: '0x...',
- *   accessKey: '0x...',
+ * const unwatch = Actions.accessKey.watchAdminAuthorized(client, {
+ *   onAuthorized: (args, log) => {
+ *     console.log('Admin key authorized:', args)
+ *   },
  * })
  * ```
  *
  * @param client - Client.
  * @param parameters - Parameters.
- * @returns The key information.
+ * @returns A function to unsubscribe from the event.
  */
-export async function getMetadata(client, parameters) {
-    const { account: account_ = client.account, accessKey, ...rest } = parameters;
-    if (!account_)
-        throw new Error('account is required.');
-    const account = parseAccount(account_);
-    const result = await readContract(client, {
+export function watchAdminAuthorized(client, parameters) {
+    const { onAuthorized, ...rest } = parameters;
+    return watchContractEvent(client, {
         ...rest,
-        account: null,
-        ...getMetadata.call({ account: account.address, accessKey }),
+        address: Addresses.accountKeychain,
+        abi: Abis.accountKeychain,
+        eventName: 'AdminKeyAuthorized',
+        onLogs: (logs) => {
+            for (const log of logs)
+                onAuthorized(log.args, log);
+        },
+        strict: true,
     });
-    return {
-        address: result.keyId,
-        keyType: signatureTypes[result.signatureType] ??
-            'secp256k1',
-        expiry: result.expiry,
-        spendPolicy: spendPolicies[`${result.enforceLimits}`],
-        isRevoked: result.isRevoked,
-    };
 }
-(function (getMetadata) {
-    /**
-     * Defines a call to the `getKey` function.
-     *
-     * @param args - Arguments.
-     * @returns The call.
-     */
-    function call(args) {
-        const { account, accessKey } = args;
-        return defineCall({
-            address: Addresses.accountKeychain,
-            abi: Abis.accountKeychain,
-            functionName: 'getKey',
-            args: [account, resolveAccessKeyAddress(accessKey)],
-        });
-    }
-    getMetadata.call = call;
-})(getMetadata || (getMetadata = {}));
 /**
- * Gets the remaining spending limit for a key-token pair.
+ * Watches for key-authorization witness events.
+ *
+ * Emitted when a key is authorized with a `witness` (see {@link authorize}).
  *
  * @example
  * ```ts
@@ -476,118 +897,131 @@ export async function getMetadata(client, parameters) {
  *   transport: http(),
  * })
  *
- * const { remaining, periodEnd } = await Actions.accessKey.getRemainingLimit(client, {
- *   account: '0x...',
- *   accessKey: '0x...',
- *   token: '0x...',
+ * const unwatch = Actions.accessKey.watchWitness(client, {
+ *   onWitness: (args, log) => {
+ *     console.log('Witness used:', args)
+ *   },
  * })
- *
- * console.log(remaining, periodEnd)
  * ```
  *
  * @param client - Client.
  * @param parameters - Parameters.
- * @returns The remaining spending amount and period end timestamp.
+ * @returns A function to unsubscribe from the event.
  */
-export async function getRemainingLimit(client, parameters) {
-    const { account: account_ = client.account, accessKey, token, ...rest } = parameters;
-    if (!account_)
-        throw new Error('account is required.');
-    const account = parseAccount(account_);
-    // TODO: remove pre-t3 branch once mainnet is on t3.
-    const hardfork = client.chain?.hardfork;
-    if (hardfork && Hardfork.lt(hardfork, 't3')) {
-        const remaining = await readContract(client, {
-            ...rest,
-            ...getRemainingLimit.call({ account: account.address, accessKey, token }),
-        });
-        return { remaining, periodEnd: undefined };
-    }
-    const [remaining, periodEnd] = await readContract(client, {
+export function watchWitness(client, parameters) {
+    const { onWitness, ...rest } = parameters;
+    return watchContractEvent(client, {
         ...rest,
-        ...getRemainingLimit.callWithPeriod({
-            account: account.address,
-            accessKey,
-            token,
-        }),
+        address: Addresses.accountKeychain,
+        abi: Abis.accountKeychain,
+        eventName: 'KeyAuthorizationWitness',
+        onLogs: (logs) => {
+            for (const log of logs)
+                onWitness(log.args, log);
+        },
+        strict: true,
     });
-    return { remaining, periodEnd };
 }
-(function (getRemainingLimit) {
-    /**
-     * Defines a call to the `getRemainingLimit` function (pre-T3).
-     *
-     * @param args - Arguments.
-     * @returns The call.
-     */
-    function call(args) {
-        const { account, accessKey, token } = args;
-        return defineCall({
-            address: Addresses.accountKeychain,
-            abi: Abis.accountKeychain,
-            functionName: 'getRemainingLimit',
-            args: [account, resolveAccessKeyAddress(accessKey), token],
-        });
-    }
-    getRemainingLimit.call = call;
-    /**
-     * Defines a call to the `getRemainingLimitWithPeriod` function (T3+).
-     *
-     * @param args - Arguments.
-     * @returns The call.
-     */
-    function callWithPeriod(args) {
-        const { account, accessKey, token } = args;
-        return defineCall({
-            address: Addresses.accountKeychain,
-            abi: Abis.accountKeychain,
-            functionName: 'getRemainingLimitWithPeriod',
-            args: [account, resolveAccessKeyAddress(accessKey), token],
-        });
-    }
-    getRemainingLimit.callWithPeriod = callWithPeriod;
-})(getRemainingLimit || (getRemainingLimit = {}));
 /**
- * Signs a key authorization for an access key.
+ * Watches for key-authorization witness burned events.
+ *
+ * Emitted when a witness is burned (see {@link burnWitness}).
  *
  * @example
  * ```ts
- * import { generatePrivateKey } from 'viem/accounts'
- * import { Account, Actions } from 'viem/tempo'
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
  *
- * const account = Account.from({ privateKey: '0x...' })
- * const accessKey = Account.fromP256(generatePrivateKey(), {
- *   access: account,
+ * const client = createClient({
+ *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' }),
+ *   transport: http(),
  * })
  *
- * const keyAuthorization = await Actions.accessKey.signAuthorization(
- *   client,
- *   {
- *     account,
- *     accessKey,
- *     expiry: Math.floor((Date.now() + 30_000) / 1000),
+ * const unwatch = Actions.accessKey.watchWitnessBurned(client, {
+ *   onBurned: (args, log) => {
+ *     console.log('Witness burned:', args)
  *   },
- * )
+ * })
  * ```
  *
  * @param client - Client.
  * @param parameters - Parameters.
- * @returns The signed key authorization.
+ * @returns A function to unsubscribe from the event.
  */
-export async function signAuthorization(client, parameters) {
-    const { accessKey, chainId = client.chain?.id, ...rest } = parameters;
-    const account_ = rest.account ?? client.account;
-    if (!account_)
-        throw new Error('account is required.');
-    if (!chainId)
-        throw new Error('chainId is required.');
-    const parsed = parseAccount(account_);
-    return signKeyAuthorization(parsed, {
-        chainId: BigInt(chainId),
-        key: accessKey,
+export function watchWitnessBurned(client, parameters) {
+    const { onBurned, ...rest } = parameters;
+    return watchContractEvent(client, {
+        ...rest,
+        address: Addresses.accountKeychain,
+        abi: Abis.accountKeychain,
+        eventName: 'KeyAuthorizationWitnessBurned',
+        onLogs: (logs) => {
+            for (const log of logs)
+                onBurned(log.args, log);
+        },
+        strict: true,
+    });
+}
+/**
+ * Verifies that a keychain signature was produced by an active access key
+ * for the expected account.
+ *
+ * By default (`admin: true`), returns `true` only if the signature was
+ * produced by the account's root key or an active admin access key. Set
+ * `admin: false` to accept any active access key.
+ *
+ * Returns `false` for account mismatches, unknown, revoked, or expired
+ * access keys. [TIP-1049](https://tips.sh/1049)
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo.extend({ feeToken: '0x20c0000000000000000000000000000000000001' }),
+ *   transport: http(),
+ * })
+ *
+ * const valid = await Actions.accessKey.verifyHash(client, {
+ *   account: '0x...',
+ *   hash: '0x...',
+ *   signature: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Whether the keychain signature is valid for the account.
+ */
+export async function verifyHash(client, parameters) {
+    const { account, admin, hash, signature, ...rest } = parameters;
+    return readContract(client, {
         ...rest,
+        ...verifyHash.call({ account, admin, hash, signature }),
     });
 }
+(function (verifyHash) {
+    /**
+     * Defines a call to `verifyKeychain` or `verifyKeychainAdmin` on the
+     * Signature Verifier precompile (controlled by `admin`).
+     *
+     * @param args - Arguments.
+     * @returns The call.
+     */
+    function call(args) {
+        const { account, admin = true, hash, signature } = args;
+        return defineCall({
+            address: Addresses.signatureVerifier,
+            abi: Abis.signatureVerifier,
+            functionName: admin ? 'verifyKeychainAdmin' : 'verifyKeychain',
+            args: [account, hash, signature],
+        });
+    }
+    verifyHash.call = call;
+})(verifyHash || (verifyHash = {}));
 /** @internal */
 function resolveAccessKeyAddress(accessKey) {
     if (typeof accessKey === 'string')