viem 2.57.5 → 2.57.6

package/_cjs/tempo/actions/token.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorResolvers = exports.TokenUnauthorizedError = exports.TokenPausedError = exports.TokenPolicyForbidsError = exports.TokenSupplyCapExceededError = exports.TokenInsufficientAllowanceError = exports.TokenInsufficientBalanceError = void 0;
 exports.approve = approve;
 exports.approveSync = approveSync;
 exports.burnBlocked = burnBlocked;
@@ -59,19 +60,22 @@ const sendTransaction_js_1 = require("../../actions/wallet/sendTransaction.js");
 const sendTransactionSync_js_1 = require("../../actions/wallet/sendTransactionSync.js");
 const writeContract_js_1 = require("../../actions/wallet/writeContract.js");
 const writeContractSync_js_1 = require("../../actions/wallet/writeContractSync.js");
+const address_js_1 = require("../../constants/address.js");
 const account_js_1 = require("../../errors/account.js");
 const encodeFunctionData_js_1 = require("../../utils/abi/encodeFunctionData.js");
 const parseEventLogs_js_1 = require("../../utils/abi/parseEventLogs.js");
 const formatUnits_js_1 = require("../../utils/unit/formatUnits.js");
 const Abis = require("../Abis.js");
 const Addresses = require("../Addresses.js");
+const errors_js_1 = require("../errors.js");
+const errors_js_2 = require("../internal/errors.js");
 const utils_js_1 = require("../internal/utils.js");
 async function approve(client, parameters) {
     return approve.inner(writeContract_js_1.writeContract, client, parameters);
 }
 (function (approve) {
     async function inner(action, client, parameters) {
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...parameters,
             ...approve.call(client, parameters),
         }));
@@ -141,7 +145,7 @@ 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 (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -192,7 +196,7 @@ 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 (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -259,7 +263,7 @@ 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 (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -312,7 +316,7 @@ 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 (0, errors_js_2.withExecutionError)(action)(client, {
             ...parameters,
             account,
             chain,
@@ -380,7 +384,7 @@ async function createSync(client, parameters) {
 async function getAllowance(client, parameters) {
     const { account, decimals, spender, token, ...rest } = parameters;
     const [amount, { decimals: resolved }] = await Promise.all([
-        (0, readContract_js_1.readContract)(client, {
+        (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
             ...rest,
             ...getAllowance.call(client, { account, spender, token }),
         }),
@@ -409,7 +413,7 @@ async function getBalance(client, parameters) {
         throw new account_js_1.AccountNotFoundError();
     const account = (0, parseAccount_js_1.parseAccount)(account_).address;
     const [amount, { decimals: resolved }] = await Promise.all([
-        (0, readContract_js_1.readContract)(client, {
+        (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
             ...rest,
             ...getBalance.call(client, { account, token }),
         }),
@@ -566,7 +570,7 @@ async function readMetadataContracts(client, parameters) {
             deployless: true,
         });
     const { contracts, ...rest } = parameters;
-    const results = await Promise.allSettled(contracts.map((contract) => (0, readContract_js_1.readContract)(client, {
+    const results = await Promise.allSettled(contracts.map((contract) => (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
         ...rest,
         ...contract,
     })));
@@ -585,7 +589,7 @@ function unwrapMulticallResult(response, ...fallback) {
 async function getTotalSupply(client, parameters) {
     const { decimals, token, ...rest } = parameters;
     const [amount, { decimals: resolved }] = await Promise.all([
-        (0, readContract_js_1.readContract)(client, {
+        (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
             ...rest,
             ...getTotalSupply.call(client, { token }),
         }),
@@ -609,7 +613,7 @@ async function getTotalSupply(client, parameters) {
     getTotalSupply.call = call;
 })(getTotalSupply || (exports.getTotalSupply = getTotalSupply = {}));
 async function getRoleAdmin(client, parameters) {
-    return (0, readContract_js_1.readContract)(client, {
+    return (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
         ...parameters,
         ...getRoleAdmin.call(client, parameters),
     });
@@ -632,7 +636,7 @@ async function hasRole(client, parameters) {
     const address = account ? (0, parseAccount_js_1.parseAccount)(account).address : undefined;
     if (!address)
         throw new Error('account is required.');
-    return (0, readContract_js_1.readContract)(client, {
+    return (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
         ...parameters,
         ...hasRole.call(client, { ...parameters, account: address }),
     });
@@ -655,7 +659,7 @@ async function grantRoles(client, parameters) {
 }
 (function (grantRoles) {
     async function inner(action, client, parameters) {
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...parameters,
             calls: parameters.roles.map((role) => {
                 const call = grantRoles.call(client, { ...parameters, role });
@@ -713,7 +717,13 @@ 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 (0, errors_js_2.withExecutionError)(action, {
+            hints: {
+                Unauthorized: [
+                    'Minting requires the issuer role. Grant it to this account first.',
+                ],
+            },
+        })(client, {
             ...rest,
             ...call,
         }));
@@ -773,7 +783,7 @@ 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 (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -821,7 +831,7 @@ async function renounceRoles(client, parameters) {
 }
 (function (renounceRoles) {
     async function inner(action, client, parameters) {
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...parameters,
             calls: parameters.roles.map((role) => {
                 const call = renounceRoles.call(client, { ...parameters, role });
@@ -878,7 +888,7 @@ async function revokeRoles(client, parameters) {
 (function (revokeRoles) {
     async function inner(action, client, parameters) {
         const { from: _, ...rest } = parameters;
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             calls: parameters.roles.map((role) => {
                 const call = revokeRoles.call(client, { ...parameters, role });
@@ -936,7 +946,7 @@ 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 (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -986,7 +996,7 @@ 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 (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -1036,7 +1046,7 @@ async function transfer(client, parameters) {
 }
 (function (transfer) {
     async function inner(action, client, parameters) {
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...parameters,
             ...transfer.call(client, parameters),
         }));
@@ -1127,7 +1137,7 @@ 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 (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -1177,7 +1187,7 @@ 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 (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -1223,7 +1233,7 @@ 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 (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -1383,4 +1393,405 @@ function watchUpdateQuoteToken(client, parameters) {
         strict: true,
     });
 }
+class TokenInsufficientBalanceError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        const { decimals } = parameters;
+        const [available, required, token] = parameters.error.args;
+        super(parameters, {
+            details: {
+                token,
+                available: (0, errors_js_2.formatAmount)(available, decimals),
+                required: (0, errors_js_2.formatAmount)(required, decimals),
+                shortfall: (0, errors_js_2.formatAmount)(required - available, decimals),
+            },
+            name: 'TokenInsufficientBalanceError',
+            shortMessage: `Insufficient balance of token "${token}".`,
+        });
+        Object.defineProperty(this, "available", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "decimals", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "required", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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;
+    }
+}
+exports.TokenInsufficientBalanceError = TokenInsufficientBalanceError;
+class TokenInsufficientAllowanceError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        const { allowance, amount, decimals, owner, spender, token } = parameters;
+        super(parameters, {
+            details: {
+                token,
+                owner,
+                spender,
+                allowance: (0, errors_js_2.formatAmount)(allowance, decimals),
+                amount: (0, errors_js_2.formatAmount)(amount, decimals),
+            },
+            name: 'TokenInsufficientAllowanceError',
+            shortMessage: `Spender "${spender}" has an insufficient allowance from "${owner}" for token "${token}".`,
+        });
+        Object.defineProperty(this, "allowance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "amount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "decimals", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "owner", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "spender", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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;
+    }
+}
+exports.TokenInsufficientAllowanceError = TokenInsufficientAllowanceError;
+class TokenSupplyCapExceededError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        const { amount, decimals, supplyCap, token, totalSupply } = parameters;
+        super(parameters, {
+            details: {
+                token,
+                amount: (0, errors_js_2.formatAmount)(amount, decimals),
+                'total supply': (0, errors_js_2.formatAmount)(totalSupply, decimals),
+                'supply cap': (0, errors_js_2.formatAmount)(supplyCap, decimals),
+                'mintable amount': supplyCap !== undefined && totalSupply !== undefined
+                    ? (0, errors_js_2.formatAmount)(supplyCap - totalSupply, decimals)
+                    : undefined,
+            },
+            name: 'TokenSupplyCapExceededError',
+            shortMessage: `Minting exceeds the supply cap of token "${token}".`,
+        });
+        Object.defineProperty(this, "amount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "decimals", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "supplyCap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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;
+    }
+}
+exports.TokenSupplyCapExceededError = TokenSupplyCapExceededError;
+class TokenPolicyForbidsError extends errors_js_1.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}.`,
+        });
+        Object.defineProperty(this, "from", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "policyId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "recipientAuthorized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "senderAuthorized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "to", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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;
+    }
+}
+exports.TokenPolicyForbidsError = TokenPolicyForbidsError;
+class TokenPausedError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        super(parameters, {
+            name: 'TokenPausedError',
+            shortMessage: `Token "${parameters.token}" is paused.`,
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.token = parameters.token;
+    }
+}
+exports.TokenPausedError = TokenPausedError;
+class TokenUnauthorizedError extends errors_js_1.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}".`,
+        });
+        Object.defineProperty(this, "account", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "role", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.account = account;
+        this.role = role;
+        this.token = token;
+    }
+}
+exports.TokenUnauthorizedError = TokenUnauthorizedError;
+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',
+};
+exports.errorResolvers = {
+    'ContractPaused()': ({ base, call }) => (0, errors_js_2.isTip20)(call?.address)
+        ? new TokenPausedError({ ...base, token: call.address })
+        : undefined,
+    'InsufficientAllowance()': async (context) => {
+        const { base, call, signer } = context;
+        const owner = call?.arg('from');
+        if (!(0, errors_js_2.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) => {
+        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 (!(0, errors_js_2.isTip20)(call?.address))
+            return undefined;
+        const token = call.address;
+        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 ?? address_js_1.zeroAddress],
+                },
+                {
+                    ...registry,
+                    functionName: mint
+                        ? 'isAuthorizedMintRecipient'
+                        : 'isAuthorizedRecipient',
+                    args: [policyId.result, to ?? address_js_1.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 (!(0, errors_js_2.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 (!(0, errors_js_2.isTip20)(call?.address) || !role || !signer)
+            return undefined;
+        return new TokenUnauthorizedError({
+            ...base,
+            account: signer.address,
+            role,
+            token: call.address,
+        });
+    },
+};
 //# sourceMappingURL=token.js.map