viem 2.57.4 → 2.57.6

package/_esm/tempo/actions/token.js

@@ -11,12 +11,15 @@ 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 { zeroAddress } from '../../constants/address.js';
 import { AccountNotFoundError } from '../../errors/account.js';
 import { encodeFunctionData } from '../../utils/abi/encodeFunctionData.js';
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js';
 import { formatUnits } from '../../utils/unit/formatUnits.js';
 import * as Abis from '../Abis.js';
 import * as Addresses from '../Addresses.js';
+import { TempoExecutionError } from '../errors.js';
+import { formatAmount, isTip20, withExecutionError, } from '../internal/errors.js';
 import { defineCall, findDeclaredToken, pickWriteParameters, resolveCallParameters, resolveToken, resolveTokenWithDecimals, } from '../internal/utils.js';
 /**
  * Approves a spender to transfer TIP20 tokens on behalf of the caller.
@@ -50,7 +53,7 @@ export async function approve(client, parameters) {
 (function (approve) {
     /** @internal */
     async function inner(action, client, parameters) {
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...parameters,
             ...approve.call(client, parameters),
         }));
@@ -208,7 +211,7 @@ export async function burnBlocked(client, parameters) {
     async function inner(action, client, parameters) {
         const { amount, from, token, ...rest } = parameters;
         const call = burnBlocked.call(client, { amount, from, token });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -354,7 +357,7 @@ export async function burn(client, parameters) {
     async function inner(action, client, parameters) {
         const { amount, from, memo, token, ...rest } = parameters;
         const call = burn.call(client, { amount, from, memo, token });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -514,7 +517,7 @@ export async function changeTransferPolicy(client, parameters) {
     async function inner(action, client, parameters) {
         const { policyId, token, ...rest } = parameters;
         const call = changeTransferPolicy.call(client, { policyId, token });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -660,7 +663,7 @@ export async function create(client, parameters) {
         if (!admin)
             throw new Error('admin is required.');
         const call = create.call(client, { ...rest, admin: admin.address });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...parameters,
             account,
             chain,
@@ -824,7 +827,7 @@ export async function createSync(client, parameters) {
 export async function getAllowance(client, parameters) {
     const { account, decimals, spender, token, ...rest } = parameters;
     const [amount, { decimals: resolved }] = await Promise.all([
-        readContract(client, {
+        withExecutionError(readContract)(client, {
             ...rest,
             ...getAllowance.call(client, { account, spender, token }),
         }),
@@ -889,7 +892,7 @@ export async function getBalance(client, parameters) {
         throw new AccountNotFoundError();
     const account = parseAccount(account_).address;
     const [amount, { decimals: resolved }] = await Promise.all([
-        readContract(client, {
+        withExecutionError(readContract)(client, {
             ...rest,
             ...getBalance.call(client, { account, token }),
         }),
@@ -1082,7 +1085,7 @@ async function readMetadataContracts(client, parameters) {
             deployless: true,
         });
     const { contracts, ...rest } = parameters;
-    const results = await Promise.allSettled(contracts.map((contract) => readContract(client, {
+    const results = await Promise.allSettled(contracts.map((contract) => withExecutionError(readContract)(client, {
         ...rest,
         ...contract,
     })));
@@ -1124,7 +1127,7 @@ function unwrapMulticallResult(response, ...fallback) {
 export async function getTotalSupply(client, parameters) {
     const { decimals, token, ...rest } = parameters;
     const [amount, { decimals: resolved }] = await Promise.all([
-        readContract(client, {
+        withExecutionError(readContract)(client, {
             ...rest,
             ...getTotalSupply.call(client, { token }),
         }),
@@ -1182,7 +1185,7 @@ export async function getTotalSupply(client, parameters) {
  * @returns The admin role hash.
  */
 export async function getRoleAdmin(client, parameters) {
-    return readContract(client, {
+    return withExecutionError(readContract)(client, {
         ...parameters,
         ...getRoleAdmin.call(client, parameters),
     });
@@ -1236,7 +1239,7 @@ export async function hasRole(client, parameters) {
     const address = account ? parseAccount(account).address : undefined;
     if (!address)
         throw new Error('account is required.');
-    return readContract(client, {
+    return withExecutionError(readContract)(client, {
         ...parameters,
         ...hasRole.call(client, { ...parameters, account: address }),
     });
@@ -1293,7 +1296,7 @@ export async function grantRoles(client, parameters) {
 (function (grantRoles) {
     /** @internal */
     async function inner(action, client, parameters) {
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...parameters,
             calls: parameters.roles.map((role) => {
                 const call = grantRoles.call(client, { ...parameters, role });
@@ -1445,7 +1448,13 @@ export async function mint(client, parameters) {
     async function inner(action, client, parameters) {
         const { amount, memo, to, token, ...rest } = parameters;
         const call = mint.call(client, { amount, memo, to, token });
-        return (await action(client, {
+        return (await withExecutionError(action, {
+            hints: {
+                Unauthorized: [
+                    'Minting requires the issuer role. Grant it to this account first.',
+                ],
+            },
+        })(client, {
             ...rest,
             ...call,
         }));
@@ -1599,7 +1608,7 @@ export async function pause(client, parameters) {
     async function inner(action, client, parameters) {
         const { token, ...rest } = parameters;
         const call = pause.call(client, { token });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -1736,7 +1745,7 @@ export async function renounceRoles(client, parameters) {
 (function (renounceRoles) {
     /** @internal */
     async function inner(action, client, parameters) {
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...parameters,
             calls: parameters.roles.map((role) => {
                 const call = renounceRoles.call(client, { ...parameters, role });
@@ -1885,7 +1894,7 @@ export async function revokeRoles(client, parameters) {
     /** @internal */
     async function inner(action, client, parameters) {
         const { from: _, ...rest } = parameters;
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             calls: parameters.roles.map((role) => {
                 const call = revokeRoles.call(client, { ...parameters, role });
@@ -2036,7 +2045,7 @@ export async function setSupplyCap(client, parameters) {
     async function inner(action, client, parameters) {
         const { supplyCap, token, ...rest } = parameters;
         const call = setSupplyCap.call(client, { supplyCap, token });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -2178,7 +2187,7 @@ export async function setRoleAdmin(client, parameters) {
     async function inner(action, client, parameters) {
         const { adminRole, role, token, ...rest } = parameters;
         const call = setRoleAdmin.call(client, { adminRole, role, token });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -2321,7 +2330,7 @@ export async function transfer(client, parameters) {
 (function (transfer) {
     /** @internal */
     async function inner(action, client, parameters) {
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...parameters,
             ...transfer.call(client, parameters),
         }));
@@ -2499,7 +2508,7 @@ export async function unpause(client, parameters) {
     async function inner(action, client, parameters) {
         const { token, ...rest } = parameters;
         const call = unpause.call(client, { token });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -2638,7 +2647,7 @@ export async function prepareUpdateQuoteToken(client, parameters) {
     async function inner(action, client, parameters) {
         const { quoteToken, token, ...rest } = parameters;
         const call = prepareUpdateQuoteToken.call(client, { quoteToken, token });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -2774,7 +2783,7 @@ export async function updateQuoteToken(client, parameters) {
     async function inner(action, client, parameters) {
         const { token, ...rest } = parameters;
         const call = updateQuoteToken.call(client, { token });
-        return (await action(client, {
+        return (await withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -3200,4 +3209,434 @@ export function watchUpdateQuoteToken(client, parameters) {
         strict: true,
     });
 }
+/** Thrown when an account's TIP-20 balance is lower than the amount a call needs. */
+export class TokenInsufficientBalanceError extends TempoExecutionError {
+    constructor(parameters) {
+        const { decimals } = parameters;
+        const [available, required, token] = parameters.error.args;
+        super(parameters, {
+            details: {
+                token,
+                available: formatAmount(available, decimals),
+                required: formatAmount(required, decimals),
+                shortfall: formatAmount(required - available, decimals),
+            },
+            name: 'TokenInsufficientBalanceError',
+            shortMessage: `Insufficient balance of token "${token}".`,
+        });
+        /** Balance available. */
+        Object.defineProperty(this, "available", {
+            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
+        });
+        /** Amount required. */
+        Object.defineProperty(this, "required", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token address. */
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.available = available;
+        this.decimals = decimals;
+        this.required = required;
+        this.token = token;
+    }
+}
+/** Thrown when a spender's TIP-20 allowance is lower than the amount it tries to transfer. */
+export class TokenInsufficientAllowanceError extends TempoExecutionError {
+    constructor(parameters) {
+        const { allowance, amount, decimals, owner, spender, token } = parameters;
+        super(parameters, {
+            details: {
+                token,
+                owner,
+                spender,
+                allowance: formatAmount(allowance, decimals),
+                amount: formatAmount(amount, decimals),
+            },
+            name: 'TokenInsufficientAllowanceError',
+            shortMessage: `Spender "${spender}" has an insufficient allowance from "${owner}" for token "${token}".`,
+        });
+        /** Current allowance, when known. */
+        Object.defineProperty(this, "allowance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Amount the spender tried to transfer. */
+        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
+        });
+        /** Token owner. */
+        Object.defineProperty(this, "owner", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Spender. */
+        Object.defineProperty(this, "spender", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token address. */
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.allowance = allowance;
+        this.amount = amount;
+        this.decimals = decimals;
+        this.owner = owner;
+        this.spender = spender;
+        this.token = token;
+    }
+}
+/** Thrown when minting would exceed a TIP-20 token's supply cap. */
+export class TokenSupplyCapExceededError extends TempoExecutionError {
+    constructor(parameters) {
+        const { amount, decimals, supplyCap, token, totalSupply } = parameters;
+        super(parameters, {
+            details: {
+                token,
+                amount: formatAmount(amount, decimals),
+                'total supply': formatAmount(totalSupply, decimals),
+                'supply cap': formatAmount(supplyCap, decimals),
+                'mintable amount': supplyCap !== undefined && totalSupply !== undefined
+                    ? formatAmount(supplyCap - totalSupply, decimals)
+                    : undefined,
+            },
+            name: 'TokenSupplyCapExceededError',
+            shortMessage: `Minting exceeds the supply cap of token "${token}".`,
+        });
+        /** Amount to mint. */
+        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
+        });
+        /** Supply cap, when known. */
+        Object.defineProperty(this, "supplyCap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token address. */
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Current total supply, when known. */
+        Object.defineProperty(this, "totalSupply", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.amount = amount;
+        this.decimals = decimals;
+        this.supplyCap = supplyCap;
+        this.token = token;
+        this.totalSupply = totalSupply;
+    }
+}
+/** Thrown when a TIP-20 token's transfer policy forbids the sender or recipient. */
+export class TokenPolicyForbidsError extends TempoExecutionError {
+    constructor(parameters) {
+        const { from, policyId, recipientAuthorized, senderAuthorized, to, token } = parameters;
+        const party = senderAuthorized === false
+            ? `sender "${from}"`
+            : recipientAuthorized === false
+                ? `recipient "${to}"`
+                : 'this transfer';
+        super(parameters, {
+            details: {
+                token,
+                policy: policyId,
+                from,
+                to,
+                'sender authorized': senderAuthorized?.toString(),
+                'recipient authorized': recipientAuthorized?.toString(),
+            },
+            name: 'TokenPolicyForbidsError',
+            shortMessage: `The transfer policy of token "${token}" forbids ${party}.`,
+        });
+        /** Sender, when known. */
+        Object.defineProperty(this, "from", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Transfer policy ID, when known. */
+        Object.defineProperty(this, "policyId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether the policy authorizes the recipient, when known. */
+        Object.defineProperty(this, "recipientAuthorized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether the policy authorizes the sender, when known. */
+        Object.defineProperty(this, "senderAuthorized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Recipient, when known. */
+        Object.defineProperty(this, "to", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token address. */
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.from = from;
+        this.policyId = policyId;
+        this.recipientAuthorized = recipientAuthorized;
+        this.senderAuthorized = senderAuthorized;
+        this.to = to;
+        this.token = token;
+    }
+}
+/** Thrown when calling a paused TIP-20 token. */
+export class TokenPausedError extends TempoExecutionError {
+    constructor(parameters) {
+        super(parameters, {
+            name: 'TokenPausedError',
+            shortMessage: `Token "${parameters.token}" is paused.`,
+        });
+        /** Token address. */
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.token = parameters.token;
+    }
+}
+/** Thrown when an account lacks the TIP-20 role a call requires. */
+export class TokenUnauthorizedError extends TempoExecutionError {
+    constructor(parameters) {
+        const { account, role, token } = parameters;
+        super(parameters, {
+            details: { token, account, role },
+            name: 'TokenUnauthorizedError',
+            shortMessage: `Account "${account}" does not have the "${role}" role on token "${token}".`,
+        });
+        /** Account that made the call. */
+        Object.defineProperty(this, "account", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Role the call requires. */
+        Object.defineProperty(this, "role", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token address. */
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.account = account;
+        this.role = role;
+        this.token = token;
+    }
+}
+/** Roles required by TIP-20 functions. */
+const requiredRoles = {
+    burn: 'issuer',
+    burnAt: 'burnAt',
+    burnBlocked: 'burnBlocked',
+    burnWithMemo: 'issuer',
+    changeTransferPolicyId: 'defaultAdmin',
+    completeQuoteTokenUpdate: 'defaultAdmin',
+    mint: 'issuer',
+    mintWithMemo: 'issuer',
+    pause: 'pause',
+    setLogoURI: 'defaultAdmin',
+    setNextQuoteToken: 'defaultAdmin',
+    setSupplyCap: 'defaultAdmin',
+    unpause: 'unpause',
+};
+/** @internal */
+export const errorResolvers = {
+    'ContractPaused()': ({ base, call }) => isTip20(call?.address)
+        ? new TokenPausedError({ ...base, token: call.address })
+        : undefined,
+    'InsufficientAllowance()': async (context) => {
+        const { base, call, signer } = context;
+        const owner = call?.arg('from');
+        if (!isTip20(call?.address) || !owner || !signer)
+            return undefined;
+        const token = call.address;
+        const [allowance, decimals] = await context.read([
+            {
+                address: token,
+                abi: Abis.tip20,
+                functionName: 'allowance',
+                args: [owner, signer.address],
+            },
+            { address: token, abi: Abis.tip20, functionName: 'decimals' },
+        ]);
+        return new TokenInsufficientAllowanceError({
+            ...base,
+            allowance: allowance?.result,
+            amount: call.arg('amount'),
+            decimals: decimals?.result,
+            owner,
+            spender: signer.address,
+            token,
+        });
+    },
+    'InsufficientBalance(uint256,uint256,address)': async (context) => {
+        // Selector-only revert data carries no arguments.
+        const token = context.base.error.args?.[2];
+        if (!token)
+            return undefined;
+        const [decimals] = await context.read([
+            { address: token, abi: Abis.tip20, functionName: 'decimals' },
+        ]);
+        return new TokenInsufficientBalanceError({
+            ...context.base,
+            decimals: decimals?.result,
+        });
+    },
+    'PolicyForbids()': async (context) => {
+        const { base, call, signer } = context;
+        if (!isTip20(call?.address))
+            return undefined;
+        const token = call.address;
+        // Mints only check the recipient.
+        const mint = call.functionName.startsWith('mint');
+        const from = mint
+            ? undefined
+            : (call.arg('from') ?? signer?.address);
+        const to = call.arg('to');
+        const [policyId] = await context.read([
+            { address: token, abi: Abis.tip20, functionName: 'transferPolicyId' },
+        ]);
+        const registry = {
+            address: Addresses.tip403Registry,
+            abi: Abis.tip403Registry,
+        };
+        const [sender, recipient] = policyId?.result === undefined
+            ? []
+            : await context.read([
+                {
+                    ...registry,
+                    functionName: 'isAuthorizedSender',
+                    args: [policyId.result, from ?? zeroAddress],
+                },
+                {
+                    ...registry,
+                    functionName: mint
+                        ? 'isAuthorizedMintRecipient'
+                        : 'isAuthorizedRecipient',
+                    args: [policyId.result, to ?? zeroAddress],
+                },
+            ]);
+        return new TokenPolicyForbidsError({
+            ...base,
+            from,
+            policyId: policyId?.result,
+            recipientAuthorized: to ? recipient?.result : undefined,
+            senderAuthorized: from ? sender?.result : undefined,
+            to,
+            token,
+        });
+    },
+    'SupplyCapExceeded()': async (context) => {
+        const { base, call } = context;
+        if (!isTip20(call?.address))
+            return undefined;
+        const token = call.address;
+        const [supplyCap, totalSupply, decimals] = await context.read([
+            { address: token, abi: Abis.tip20, functionName: 'supplyCap' },
+            { address: token, abi: Abis.tip20, functionName: 'totalSupply' },
+            { address: token, abi: Abis.tip20, functionName: 'decimals' },
+        ]);
+        return new TokenSupplyCapExceededError({
+            ...base,
+            amount: call.arg('amount'),
+            decimals: decimals?.result,
+            supplyCap: supplyCap?.result,
+            token,
+            totalSupply: totalSupply?.result,
+        });
+    },
+    'Unauthorized()': ({ base, call, signer }) => {
+        const role = call && requiredRoles[call.functionName];
+        if (!isTip20(call?.address) || !role || !signer)
+            return undefined;
+        return new TokenUnauthorizedError({
+            ...base,
+            account: signer.address,
+            role,
+            token: call.address,
+        });
+    },
+};
 //# sourceMappingURL=token.js.map