viem 2.57.4 → 2.57.6

package/_esm/tempo/actions/accessKey.js

@@ -1,4 +1,4 @@
-import { KeyAuthorization, MultisigConfig, MultisigOperation, SignatureEnvelope, } from 'ox/tempo';
+import { AccountConfig, AccountOperation, KeyAuthorization, SignatureEnvelope, } from 'ox/tempo';
 import { parseAccount } from '../../accounts/utils/parseAccount.js';
 import { readContract } from '../../actions/public/readContract.js';
 import { watchContractEvent } from '../../actions/public/watchContractEvent.js';
@@ -6,15 +6,19 @@ import { sendTransaction } from '../../actions/wallet/sendTransaction.js';
 import { sendTransactionSync } from '../../actions/wallet/sendTransactionSync.js';
 import { writeContract } from '../../actions/wallet/writeContract.js';
 import { writeContractSync } from '../../actions/wallet/writeContractSync.js';
+import { MethodNotFoundRpcError, MethodNotSupportedRpcError, } from '../../errors/rpc.js';
+import { formatAbiItem } from '../../utils/abi/formatAbiItem.js';
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js';
 import { isAddressEqual } from '../../utils/address/isAddressEqual.js';
 import * as Abis from '../Abis.js';
-import { fromMultisig, getKeyAuthorizationSignPayload, resolveAccessKey, signKeyAuthorization, } from '../Account.js';
+import { fromConfig, getKeyAuthorizationSignPayload, resolveAccessKey, signKeyAuthorization, } from '../Account.js';
 import * as Addresses from '../Addresses.js';
+import { parseApproval } from '../accounts/Signature.js';
+import { TempoExecutionError } from '../errors.js';
 import * as Hardfork from '../Hardfork.js';
+import { formatAmount, formatTime, getFeeToken, isTip20, withExecutionError, } from '../internal/errors.js';
 import { defineCall } from '../internal/utils.js';
-import { parseApproval } from '../multisig/Signature.js';
-import { getConfig } from './multisig.js';
+import { getConfig } from './accounts.js';
 /** @internal */
 const signatureTypes = {
     0: 'secp256k1',
@@ -69,7 +73,7 @@ export async function authorize(client, parameters) {
             throw new Error('account is required.');
         if (!chainId)
             throw new Error('chainId is required.');
-        const keyAuthorization = await signAuthorization(client, {
+        const keyAuthorization = await signLocal(client, {
             account: account_,
             accessKey,
             chainId,
@@ -79,7 +83,13 @@ export async function authorize(client, parameters) {
             scopes,
             witness,
         });
-        return (await action(client, {
+        return (await withExecutionError(action, {
+            hints: {
+                KeyAlreadyExists: [
+                    'This access key is already authorized. Update its spending limits instead.',
+                ],
+            },
+        })(client, {
             ...rest,
             keyAuthorization,
         }));
@@ -183,7 +193,7 @@ export async function burnWitness(client, parameters) {
     async function inner(action, client, parameters) {
         const { witness, ...rest } = parameters;
         const call = burnWitness.call({ witness });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -309,7 +319,7 @@ export async function getMetadata(client, parameters) {
     if (!account_)
         throw new Error('account is required.');
     const account = parseAccount(account_);
-    const result = await readContract(client, {
+    const result = await withExecutionError(readContract)(client, {
         ...rest,
         account: null,
         ...getMetadata.call({ account: account.address, accessKey }),
@@ -376,13 +386,13 @@ export async function getRemainingLimit(client, parameters) {
     // 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, {
+        const remaining = await withExecutionError(readContract)(client, {
             ...rest,
             ...getRemainingLimit.call({ account: account.address, accessKey, token }),
         });
         return { remaining, periodEnd: undefined };
     }
-    const [remaining, periodEnd] = await readContract(client, {
+    const [remaining, periodEnd] = await withExecutionError(readContract)(client, {
         ...rest,
         ...getRemainingLimit.callWithPeriod({
             account: account.address,
@@ -460,7 +470,7 @@ export async function isAdmin(client, parameters) {
     if (!account_)
         throw new Error('account is required.');
     const account = parseAccount(account_);
-    return readContract(client, {
+    return withExecutionError(readContract)(client, {
         ...rest,
         account: null,
         ...isAdmin.call({ account: account.address, accessKey }),
@@ -513,7 +523,7 @@ export async function isWitnessBurned(client, parameters) {
     if (!account_)
         throw new Error('account is required.');
     const account = parseAccount(account_);
-    return readContract(client, {
+    return withExecutionError(readContract)(client, {
         ...rest,
         account: null,
         ...isWitnessBurned.call({ account: account.address, witness }),
@@ -570,7 +580,7 @@ export async function revoke(client, parameters) {
     async function inner(action, client, parameters) {
         const { accessKey, ...rest } = parameters;
         const call = revoke.call({ accessKey });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -694,14 +704,14 @@ export async function prepareAuthorization(client, parameters) {
     if (!chainId)
         throw new Error('chainId is required.');
     const parsed = parseAccount(account_);
-    const multisigState = await (async () => {
-        if ('multisig' in parameters)
-            return parameters.multisig;
-        if (parsed.source !== 'multisig')
+    const configurableState = await (async () => {
+        if ('configurable' in parameters)
+            return parameters.configurable;
+        if (parsed.source !== 'configurable')
             return undefined;
         const account = parsed;
         if (!account.config)
-            throw new Error('A multisig config is required to prepare a key authorization.');
+            throw new Error('An account config is required to prepare a key authorization.');
         return { config: account.config };
     })();
     const authorizationSignPayload = getKeyAuthorizationSignPayload(parsed, {
@@ -709,10 +719,10 @@ export async function prepareAuthorization(client, parameters) {
         chainId: BigInt(chainId),
         key: parameters.accessKey,
     });
-    const signPayload = parsed.source === 'multisig' && multisigState
-        ? MultisigConfig.getSignPayload({
+    const signPayload = parsed.source === 'configurable' && configurableState
+        ? AccountConfig.getSignPayload({
             account: parsed.address,
-            config: multisigState.config,
+            config: configurableState.config,
             payload: authorizationSignPayload,
         })
         : authorizationSignPayload;
@@ -720,10 +730,46 @@ export async function prepareAuthorization(client, parameters) {
         ...parameters,
         account: parsed,
         chainId,
-        multisig: multisigState,
+        configurable: configurableState,
         signPayload,
     };
 }
+/**
+ * Saves a signed key authorization to a relay with key authorization storage.
+ *
+ * The relay attaches the authorization to the access key's next transaction until
+ * the key is active onchain. Use this for authorizations signed outside
+ * {@link signAuthorization}, such as on another device. Requires a relay running the
+ * `Relay.keyAuthorization` plugin.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions, withRelay } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: withRelay(http(), http('https://relay.example.com'), {
+ *     keyAuthorization: true,
+ *   }),
+ * })
+ *
+ * await Actions.accessKey.saveAuthorization(client, {
+ *   keyAuthorization,
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ */
+export async function saveAuthorization(client, parameters) {
+    const { keyAuthorization } = parameters;
+    await client.request({
+        method: 'relay_saveKeyAuthorization',
+        params: [KeyAuthorization.toRpc(keyAuthorization)],
+    });
+}
 export async function signAuthorization(client, parameters) {
     const coordinated = ('hash' in parameters && parameters.hash) ||
         ('owner' in parameters && parameters.owner);
@@ -731,11 +777,11 @@ export async function signAuthorization(client, parameters) {
         const parameters_ = parameters;
         const owner_ = parameters_.owner;
         if (!owner_ || typeof owner_ === 'string')
-            throw new Error('A local owner account is required to approve a multisig key authorization.');
+            throw new Error('A local owner account is required to approve a configurable account key authorization.');
         const owner = parseAccount(owner_);
         const sign = owner.sign;
         if (!sign)
-            throw new Error('A local owner account is required to approve a multisig key authorization.');
+            throw new Error('A local owner account is required to approve a configurable account key authorization.');
         const request = await (async () => {
             if ('hash' in parameters_ && parameters_.hash) {
                 const signature = SignatureEnvelope.serialize(SignatureEnvelope.from(await sign({ hash: parameters_.hash })));
@@ -749,16 +795,16 @@ export async function signAuthorization(client, parameters) {
                 const config = await getConfig(client, { address });
                 if (config)
                     return config;
-                throw new Error(`No current multisig config is cached for account ${address}. Provide the current config.`);
+                throw new Error(`No current account config is cached for account ${address}. Provide the current config.`);
             })();
             const account = (() => {
                 if (config.version !== 0n)
-                    return fromMultisig({ address, ...config });
+                    return fromConfig({ address, ...config });
                 const { version: _, ...initialConfig } = config;
-                return fromMultisig({ address: 'infer', ...initialConfig });
+                return fromConfig({ address: 'infer', ...initialConfig });
             })();
             if (!isAddressEqual(account.address, address))
-                throw new Error('Initial multisig config does not match the account.');
+                throw new Error('Initial account config does not match the account.');
             const prepared = await prepareAuthorization(client, {
                 ...authorization,
                 account,
@@ -782,44 +828,62 @@ export async function signAuthorization(client, parameters) {
             return { keyAuthorization: KeyAuthorization.toRpc(keyAuthorization) };
         })();
         const operation = await client.request({
-            method: 'multisig_approveKeyAuthorization',
+            method: 'account_approveKeyAuthorization',
             params: [request],
         });
-        const multisig = MultisigOperation.fromRpc(operation);
+        const operation_ = AccountOperation.fromRpc(operation);
         const keyAuthorization = KeyAuthorization.deserialize(await (async () => {
-            if (multisig.status === 'success')
-                return multisig.keyAuthorization;
-            const approvals = await MultisigOperation.selectApprovals({
-                account: multisig.account,
-                approvals: multisig.approvals,
-                config: multisig.config,
-                hash: multisig.hash,
+            if (operation_.status === 'success')
+                return operation_.keyAuthorization;
+            const approvals = await AccountOperation.selectApprovals({
+                account: operation_.account,
+                approvals: operation_.approvals,
+                config: operation_.config,
+                hash: operation_.hash,
             });
-            return MultisigOperation.serializeKeyAuthorization(multisig.keyAuthorization, {
-                account: multisig.account,
+            return AccountOperation.serializeKeyAuthorization(operation_.keyAuthorization, {
+                account: operation_.account,
                 approvals: approvals.selectedApprovals.length > 0
                     ? approvals.selectedApprovals
                     : approvals.approvals.slice(0, 1),
-                config: multisig.config,
+                config: operation_.config,
             });
         })());
         if (!keyAuthorization.signature)
-            throw new Error('Expected a signed multisig key authorization.');
+            throw new Error('Expected a signed configurable account key authorization.');
         return {
             ...keyAuthorization,
-            hash: multisig.hash,
-            multisig,
-            status: multisig.status,
+            hash: operation_.hash,
+            operation: operation_,
+            status: operation_.status,
         };
     }
+    const keyAuthorization = await signLocal(client, parameters);
+    const signer = parameters.account ?? client.account;
+    // Relays with key authorization storage attach it to the access key's next
+    // transaction. Admin-signed authorizations can only be submitted by the admin key.
+    if (client.transport.keyAuthorization &&
+        signer &&
+        parseAccount(signer).source !== 'accessKey')
+        await saveAuthorization(client, { keyAuthorization }).catch((error) => {
+            // Remote relays without key authorization storage do not expose this method.
+            if (error instanceof MethodNotFoundRpcError ||
+                error instanceof MethodNotSupportedRpcError)
+                return;
+            throw error;
+        });
+    return keyAuthorization;
+}
+/** Signs a key authorization locally without saving it to a relay. */
+async function signLocal(client, parameters) {
     const prepared = ('signPayload' in parameters
         ? parameters
         : await prepareAuthorization(client, parameters));
-    const { accessKey, account: account_, chainId, multisig: multisigState, signPayload: _, ...rest } = prepared;
+    const { accessKey, account: account_, chainId, configurable: configurableState, signPayload: _, ...rest } = prepared;
     return signKeyAuthorization(account_, {
         chainId: BigInt(chainId),
         key: accessKey,
-        multisig: multisigState,
+        configurable: configurableState,
         ...rest,
     });
 }
@@ -858,7 +922,7 @@ export async function updateLimit(client, parameters) {
     async function inner(action, client, parameters) {
         const { accessKey, token, limit, ...rest } = parameters;
         const call = updateLimit.call({ accessKey, token, limit });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -1125,7 +1189,7 @@ export function watchWitnessBurned(client, parameters) {
  */
 export async function verifyHash(client, parameters) {
     const { account, admin, hash, signature, ...rest } = parameters;
-    return readContract(client, {
+    return withExecutionError(readContract)(client, {
         ...rest,
         ...verifyHash.call({ account, admin, hash, signature }),
     });
@@ -1155,4 +1219,391 @@ function resolveAccessKeyAddress(accessKey) {
         return accessKey;
     return accessKey.accessKeyAddress;
 }
+/** Thrown when an access key fails an `AccountKeychain` check. */
+export class AccessKeyError extends TempoExecutionError {
+    constructor(parameters, options = {}) {
+        const { account, accessKey } = parameters;
+        super(parameters, {
+            shortMessage: `Access key "${accessKey}" failed: ${parameters.error.message}`,
+            ...options,
+            details: { account, 'access key': accessKey, ...options.details },
+            docsPath: '/tempo/guides/access-keys/manage',
+            name: options.name ?? 'AccessKeyError',
+        });
+        /** Root account that owns the access key. */
+        Object.defineProperty(this, "account", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Access key address. */
+        Object.defineProperty(this, "accessKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.account = account;
+        this.accessKey = accessKey;
+    }
+}
+/** Thrown when a transfer, approval, or fee payment exceeds an access key's spending limit. */
+export class AccessKeySpendingLimitExceededError extends AccessKeyError {
+    constructor(parameters) {
+        const { amount, decimals, fee, periodEnd, remaining, token } = parameters;
+        super(parameters, {
+            details: {
+                token,
+                amount: formatAmount(amount, decimals),
+                remaining: formatAmount(remaining, decimals),
+                'exceeded by': amount !== undefined && remaining !== undefined
+                    ? formatAmount(amount - remaining, decimals)
+                    : undefined,
+                'resets at': formatTime(periodEnd),
+            },
+            name: 'AccessKeySpendingLimitExceededError',
+            shortMessage: `Access key "${parameters.accessKey}" exceeded its spending limit${token ? ` for token "${token}"` : ''}${fee ? ' while paying fees' : ''}.`,
+        });
+        /** Amount the call tried to spend, when known. */
+        Object.defineProperty(this, "amount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token decimals, when known. */
+        Object.defineProperty(this, "decimals", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether the fee payment, rather than the call, exceeded the limit. */
+        Object.defineProperty(this, "fee", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** End of the current period (Unix seconds) for periodic limits, when known. */
+        Object.defineProperty(this, "periodEnd", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Remaining limit for `token`, when known. */
+        Object.defineProperty(this, "remaining", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token the limit applies to, when known. */
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.amount = amount;
+        this.decimals = decimals;
+        this.fee = fee;
+        this.periodEnd = periodEnd;
+        this.remaining = remaining;
+        this.token = token;
+    }
+}
+/** Thrown when a transaction is signed with an expired access key. */
+export class AccessKeyExpiredError extends AccessKeyError {
+    constructor(parameters) {
+        super(parameters, {
+            details: { 'expired at': formatTime(parameters.expiry) },
+            name: 'AccessKeyExpiredError',
+            shortMessage: `Access key "${parameters.accessKey}" has expired.`,
+        });
+        /** Expiry (Unix seconds), when known. */
+        Object.defineProperty(this, "expiry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.expiry = parameters.expiry;
+    }
+}
+/** Thrown when an access key's scopes do not allow a call. */
+export class AccessKeyCallNotAllowedError extends AccessKeyError {
+    constructor(parameters) {
+        const { selector, target } = parameters;
+        super(parameters, {
+            details: { target, selector },
+            name: 'AccessKeyCallNotAllowedError',
+            shortMessage: `Access key "${parameters.accessKey}" is not allowed to make this call.`,
+        });
+        /** Function selector of the rejected call, when known. */
+        Object.defineProperty(this, "selector", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Target of the rejected call, when known. */
+        Object.defineProperty(this, "target", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.selector = selector;
+        this.target = target;
+    }
+}
+/** Thrown when authorizing an access key that is already authorized. */
+export class AccessKeyAlreadyExistsError extends AccessKeyError {
+    constructor(parameters) {
+        const { expiry, limited } = parameters;
+        super(parameters, {
+            details: {
+                expires: formatTime(expiry),
+                'spending limits': limited === undefined ? undefined : limited ? 'enforced' : 'none',
+            },
+            name: 'AccessKeyAlreadyExistsError',
+            shortMessage: `Access key "${parameters.accessKey}" is already authorized on account "${parameters.account}".`,
+        });
+        /** Expiry (Unix seconds) of the existing key, when known. */
+        Object.defineProperty(this, "expiry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether the existing key enforces spending limits, when known. */
+        Object.defineProperty(this, "limited", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.expiry = expiry;
+        this.limited = limited;
+    }
+}
+/** Thrown when an access key signs with a different key type than it was authorized with. */
+export class AccessKeySignatureTypeMismatchError extends AccessKeyError {
+    constructor(parameters) {
+        const [expected, actual] = (parameters.error.args ?? []).map((type) => signatureTypes[Number(type)]);
+        super(parameters, {
+            details: { expected, actual },
+            name: 'AccessKeySignatureTypeMismatchError',
+            shortMessage: `Access key "${parameters.accessKey}" signed with a ${actual ?? 'different'} key, but was authorized as a ${expected ?? 'different'} key.`,
+        });
+        /** Key type the access key was authorized with. */
+        Object.defineProperty(this, "expected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Key type of the signature. */
+        Object.defineProperty(this, "actual", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.expected = expected;
+        this.actual = actual;
+    }
+}
+/** Thrown when authorizing an access key with an expiry that has passed or is too soon. */
+export class AccessKeyExpiryInPastError extends AccessKeyError {
+    constructor(parameters) {
+        const { expiry, minimum } = parameters;
+        super(parameters, {
+            details: { expiry: formatTime(expiry), minimum: formatTime(minimum) },
+            name: 'AccessKeyExpiryInPastError',
+            shortMessage: `Access key "${parameters.accessKey}" expiry must be later${minimum ? ` than ${formatTime(minimum)}` : ''}.`,
+        });
+        /** Requested expiry (Unix seconds), when known. */
+        Object.defineProperty(this, "expiry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Earliest allowed expiry (Unix seconds), when known. */
+        Object.defineProperty(this, "minimum", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.expiry = expiry;
+        this.minimum = minimum;
+    }
+}
+const keychain = {
+    address: Addresses.accountKeychain,
+    abi: Abis.accountKeychain,
+};
+/** Signer and key for errors raised while validating the signing access key. */
+function getSigner(context) {
+    const { call, parameters, signer } = context;
+    if (!signer?.accessKey)
+        return undefined;
+    // Key management calls and authorizations of another key fail about that key, not the signer.
+    if (call && isAddressEqual(call.address, Addresses.accountKeychain))
+        return undefined;
+    const authorized = parameters.keyAuthorization?.address;
+    if (authorized && !isAddressEqual(authorized, signer.accessKey))
+        return undefined;
+    return {
+        ...context.base,
+        account: signer.address,
+        accessKey: signer.accessKey,
+    };
+}
+/** Fee payer and key for fee payment errors. External fee payers cannot be resolved. */
+function getFeePayer(context) {
+    const { feePayer } = context.parameters;
+    if (typeof feePayer !== 'object')
+        return undefined;
+    const account = parseAccount(feePayer);
+    if (account.source !== 'accessKey' || !('accessKeyAddress' in account))
+        return undefined;
+    return {
+        ...context.base,
+        account: account.address,
+        accessKey: account.accessKeyAddress,
+    };
+}
+/** Account and key for errors raised while authorizing a key. */
+function getAuthorization(context) {
+    const { call, parameters, signer } = context;
+    const accessKey = parameters.keyAuthorization?.address ??
+        call?.arg('keyId');
+    if (!signer || !accessKey)
+        return undefined;
+    return { ...context.base, account: signer.address, accessKey };
+}
+/** @internal */
+export const errorResolvers = {
+    // Fallback for `AccountKeychain` errors without a specific resolver below.
+    ...Object.fromEntries(Abis.accountKeychain.flatMap((item) => item.type === 'error'
+        ? [
+            [
+                formatAbiItem(item),
+                (context) => {
+                    const parameters = getSigner(context);
+                    return parameters && new AccessKeyError(parameters);
+                },
+            ],
+        ]
+        : [])),
+    'CallNotAllowed()': (context) => {
+        const parameters = getSigner(context);
+        if (!parameters)
+            return undefined;
+        return new AccessKeyCallNotAllowedError({
+            ...parameters,
+            selector: context.parameters.data?.slice(0, 10),
+            target: context.call?.address ?? context.parameters.to,
+        });
+    },
+    'ExpiryInPast()': (context) => {
+        const parameters = getAuthorization(context);
+        if (!parameters)
+            return undefined;
+        const [, expiry, minimum] = /expiry (\d+) <= min allowed (\d+)/.exec(context.details) ?? [];
+        const requested = context.parameters.keyAuthorization?.expiry ??
+            context.call?.arg('expiry') ??
+            context.call?.arg('config')?.expiry;
+        return new AccessKeyExpiryInPastError({
+            ...parameters,
+            expiry: expiry
+                ? BigInt(expiry)
+                : requested === undefined || requested === null
+                    ? undefined
+                    : BigInt(requested),
+            minimum: minimum ? BigInt(minimum) : undefined,
+        });
+    },
+    'KeyAlreadyExists()': async (context) => {
+        const parameters = getAuthorization(context);
+        if (!parameters)
+            return undefined;
+        const [key] = await context.read([
+            {
+                ...keychain,
+                functionName: 'getKey',
+                args: [parameters.account, parameters.accessKey],
+            },
+        ]);
+        return new AccessKeyAlreadyExistsError({
+            ...parameters,
+            expiry: key?.result?.expiry,
+            limited: key?.result?.enforceLimits,
+        });
+    },
+    'KeyExpired()': async (context) => {
+        const parameters = getSigner(context);
+        if (!parameters)
+            return undefined;
+        const [key] = await context.read([
+            {
+                ...keychain,
+                functionName: 'getKey',
+                args: [parameters.account, parameters.accessKey],
+            },
+        ]);
+        return new AccessKeyExpiredError({
+            ...parameters,
+            expiry: key?.result?.expiry,
+        });
+    },
+    'SignatureTypeMismatch(uint8,uint8)': (context) => {
+        const parameters = getSigner(context) ?? getAuthorization(context);
+        return parameters && new AccessKeySignatureTypeMismatchError(parameters);
+    },
+    'SpendingLimitExceeded()': async (context) => {
+        // Without revert data, the fee payment exceeded the limit.
+        const fee = context.validation;
+        const parameters = fee && context.parameters.feePayer
+            ? getFeePayer(context)
+            : getSigner(context);
+        if (!parameters)
+            return undefined;
+        const token = fee
+            ? getFeeToken(context)
+            : isTip20(context.call?.address)
+                ? context.call.address
+                : undefined;
+        if (!token)
+            return new AccessKeySpendingLimitExceededError({
+                ...parameters,
+                fee,
+                hints: fee
+                    ? [...parameters.hints, 'Pay fees with another token.']
+                    : parameters.hints,
+            });
+        const args = [parameters.account, parameters.accessKey, token];
+        const [withPeriod, legacy, decimals] = await context.read([
+            // `getRemainingLimitWithPeriod` is T3+; `getRemainingLimit` covers earlier hardforks.
+            { ...keychain, functionName: 'getRemainingLimitWithPeriod', args },
+            { ...keychain, functionName: 'getRemainingLimit', args },
+            { address: token, abi: Abis.tip20, functionName: 'decimals' },
+        ]);
+        return new AccessKeySpendingLimitExceededError({
+            ...parameters,
+            amount: fee ? undefined : context.call?.arg('amount'),
+            decimals: decimals?.result,
+            fee,
+            periodEnd: withPeriod?.result?.[1] || undefined,
+            remaining: withPeriod?.result?.[0] ?? legacy?.result,
+            token,
+        });
+    },
+};
 //# sourceMappingURL=accessKey.js.map