viem 2.57.5 → 2.57.6

package/_cjs/tempo/actions/dex.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorResolvers = exports.DexInsufficientBalanceError = exports.DexPairNotFoundError = exports.DexOrderNotStaleError = exports.DexOrderNotFoundError = exports.DexInvalidFlipTickError = exports.DexTickOutOfBoundsError = exports.DexBelowMinimumOrderSizeError = exports.DexInsufficientLiquidityError = exports.DexMaxInputExceededError = exports.DexInsufficientOutputError = void 0;
 exports.buy = buy;
 exports.buySync = buySync;
 exports.cancel = cancel;
@@ -34,8 +35,11 @@ const watchContractEvent_js_1 = require("../../actions/public/watchContractEvent
 const writeContract_js_1 = require("../../actions/wallet/writeContract.js");
 const writeContractSync_js_1 = require("../../actions/wallet/writeContractSync.js");
 const parseEventLogs_js_1 = require("../../utils/abi/parseEventLogs.js");
+const isAddressEqual_js_1 = require("../../utils/address/isAddressEqual.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 buy(client, parameters) {
     return buy.inner(writeContract_js_1.writeContract, client, parameters);
@@ -44,7 +48,7 @@ async function buy(client, parameters) {
     async function inner(action, client, parameters) {
         const { tokenIn, tokenOut, amountOut, maxAmountIn, ...rest } = parameters;
         const call = buy.call({ tokenIn, tokenOut, amountOut, maxAmountIn });
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -76,7 +80,7 @@ async function cancel(client, parameters) {
     async function inner(action, client, parameters) {
         const { orderId, ...rest } = parameters;
         const call = cancel.call({ orderId });
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -126,7 +130,7 @@ async function cancelStale(client, parameters) {
     async function inner(action, client, parameters) {
         const { orderId, ...rest } = parameters;
         const call = cancelStale.call({ orderId });
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -176,7 +180,7 @@ async function createPair(client, parameters) {
     async function inner(action, client, parameters) {
         const { base, ...rest } = parameters;
         const call = createPair.call({ base });
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -224,7 +228,7 @@ async function getBalance(client, parameters) {
     const address = acc ? (0, parseAccount_js_1.parseAccount)(acc).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, {
         ...rest,
         ...getBalance.call({ account: address, token }),
     });
@@ -243,7 +247,7 @@ async function getBalance(client, parameters) {
 })(getBalance || (exports.getBalance = getBalance = {}));
 async function getBuyQuote(client, parameters) {
     const { tokenIn, tokenOut, amountOut, ...rest } = parameters;
-    return (0, readContract_js_1.readContract)(client, {
+    return (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
         ...rest,
         ...getBuyQuote.call({ tokenIn, tokenOut, amountOut }),
     });
@@ -262,7 +266,7 @@ async function getBuyQuote(client, parameters) {
 })(getBuyQuote || (exports.getBuyQuote = getBuyQuote = {}));
 async function getOrder(client, parameters) {
     const { orderId, ...rest } = parameters;
-    return (0, readContract_js_1.readContract)(client, {
+    return (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
         ...rest,
         ...getOrder.call({ orderId }),
     });
@@ -281,7 +285,7 @@ async function getOrder(client, parameters) {
 })(getOrder || (exports.getOrder = getOrder = {}));
 async function getOrderbook(client, parameters) {
     const { base, quote, ...rest } = parameters;
-    return (0, readContract_js_1.readContract)(client, {
+    return (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
         ...rest,
         ...getOrderbook.call({ base, quote }),
     });
@@ -301,7 +305,7 @@ async function getOrderbook(client, parameters) {
 })(getOrderbook || (exports.getOrderbook = getOrderbook = {}));
 async function getTickLevel(client, parameters) {
     const { base, tick, isBid, ...rest } = parameters;
-    const [head, tail, totalLiquidity] = await (0, readContract_js_1.readContract)(client, {
+    const [head, tail, totalLiquidity] = await (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
         ...rest,
         ...getTickLevel.call({ base, tick, isBid }),
     });
@@ -321,7 +325,7 @@ async function getTickLevel(client, parameters) {
 })(getTickLevel || (exports.getTickLevel = getTickLevel = {}));
 async function getSellQuote(client, parameters) {
     const { tokenIn, tokenOut, amountIn, ...rest } = parameters;
-    return (0, readContract_js_1.readContract)(client, {
+    return (0, errors_js_2.withExecutionError)(readContract_js_1.readContract)(client, {
         ...rest,
         ...getSellQuote.call({ tokenIn, tokenOut, amountIn }),
     });
@@ -345,7 +349,7 @@ async function place(client, parameters) {
     async function inner(action, client, parameters) {
         const { amount, token, type, tick, ...rest } = parameters;
         const call = place.call({ amount, token, type, tick });
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -382,7 +386,7 @@ async function placeFlip(client, parameters) {
     async function inner(action, client, parameters) {
         const { amount, flipTick, tick, token, type, ...rest } = parameters;
         const call = placeFlip.call({ amount, flipTick, tick, token, type });
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -448,7 +452,7 @@ async function sell(client, parameters) {
     async function inner(action, client, parameters) {
         const { tokenIn, tokenOut, amountIn, minAmountOut, ...rest } = parameters;
         const call = sell.call({ tokenIn, tokenOut, amountIn, minAmountOut });
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -552,7 +556,7 @@ async function withdraw(client, parameters) {
     async function inner(action, client, parameters) {
         const { token, amount, ...rest } = parameters;
         const call = withdraw.call({ token, amount });
-        return (await action(client, {
+        return (await (0, errors_js_2.withExecutionError)(action)(client, {
             ...rest,
             ...call,
         }));
@@ -580,4 +584,493 @@ async function withdrawSync(client, parameters) {
 function getPairKey(base, quote) {
     return Hash.keccak256(Hex.concat(base, quote));
 }
+class DexInsufficientOutputError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        const { amountIn, minAmountOut, quote, tokenIn, tokenOut } = parameters;
+        super(parameters, {
+            details: {
+                'token in': tokenIn,
+                'token out': tokenOut,
+                'amount in': amountIn,
+                'min amount out': minAmountOut,
+                quote,
+            },
+            name: 'DexInsufficientOutputError',
+        });
+        Object.defineProperty(this, "amountIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "minAmountOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "quote", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.amountIn = amountIn;
+        this.minAmountOut = minAmountOut;
+        this.quote = quote;
+        this.tokenIn = tokenIn;
+        this.tokenOut = tokenOut;
+    }
+}
+exports.DexInsufficientOutputError = DexInsufficientOutputError;
+class DexMaxInputExceededError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        const { amountOut, maxAmountIn, quote, tokenIn, tokenOut } = parameters;
+        super(parameters, {
+            details: {
+                'token in': tokenIn,
+                'token out': tokenOut,
+                'amount out': amountOut,
+                'max amount in': maxAmountIn,
+                quote,
+            },
+            name: 'DexMaxInputExceededError',
+        });
+        Object.defineProperty(this, "amountOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxAmountIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "quote", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.amountOut = amountOut;
+        this.maxAmountIn = maxAmountIn;
+        this.quote = quote;
+        this.tokenIn = tokenIn;
+        this.tokenOut = tokenOut;
+    }
+}
+exports.DexMaxInputExceededError = DexMaxInputExceededError;
+class DexInsufficientLiquidityError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        const { amountIn, amountOut, tokenIn, tokenOut } = parameters;
+        super(parameters, {
+            details: {
+                'token in': tokenIn,
+                'token out': tokenOut,
+                'amount in': amountIn,
+                'amount out': amountOut,
+            },
+            name: 'DexInsufficientLiquidityError',
+        });
+        Object.defineProperty(this, "amountIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "amountOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tokenOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.amountIn = amountIn;
+        this.amountOut = amountOut;
+        this.tokenIn = tokenIn;
+        this.tokenOut = tokenOut;
+    }
+}
+exports.DexInsufficientLiquidityError = DexInsufficientLiquidityError;
+class DexBelowMinimumOrderSizeError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        const [amount] = parameters.error.args;
+        const { minimum } = parameters;
+        super(parameters, {
+            details: { amount, minimum },
+            name: 'DexBelowMinimumOrderSizeError',
+            shortMessage: `Order amount ${amount} is below the minimum${minimum === undefined ? '' : ` of ${minimum}`}.`,
+        });
+        Object.defineProperty(this, "amount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "minimum", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.amount = amount;
+        this.minimum = minimum;
+    }
+}
+exports.DexBelowMinimumOrderSizeError = DexBelowMinimumOrderSizeError;
+class DexTickOutOfBoundsError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        const [tick] = parameters.error.args;
+        const { maxTick, minTick } = parameters;
+        super(parameters, {
+            details: {
+                tick,
+                range: minTick === undefined || maxTick === undefined
+                    ? undefined
+                    : `${minTick} to ${maxTick}`,
+            },
+            name: 'DexTickOutOfBoundsError',
+        });
+        Object.defineProperty(this, "maxTick", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "minTick", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tick", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxTick = maxTick;
+        this.minTick = minTick;
+        this.tick = tick;
+    }
+}
+exports.DexTickOutOfBoundsError = DexTickOutOfBoundsError;
+class DexInvalidFlipTickError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        const { flipTick, side, tick, tickSpacing } = parameters;
+        super(parameters, {
+            details: {
+                side,
+                tick,
+                'flip tick': flipTick,
+                'tick spacing': tickSpacing,
+            },
+            name: 'DexInvalidFlipTickError',
+            shortMessage: side === 'buy'
+                ? 'The flip tick of a buy order must be at or above its tick, and a multiple of the tick spacing.'
+                : side === 'sell'
+                    ? 'The flip tick of a sell order must be at or below its tick, and a multiple of the tick spacing.'
+                    : undefined,
+        });
+        Object.defineProperty(this, "flipTick", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "side", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tick", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tickSpacing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.flipTick = flipTick;
+        this.side = side;
+        this.tick = tick;
+        this.tickSpacing = tickSpacing;
+    }
+}
+exports.DexInvalidFlipTickError = DexInvalidFlipTickError;
+class DexOrderNotFoundError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        super(parameters, {
+            details: { order: parameters.orderId },
+            name: 'DexOrderNotFoundError',
+            shortMessage: `Order ${parameters.orderId} does not exist or is already filled.`,
+        });
+        Object.defineProperty(this, "orderId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.orderId = parameters.orderId;
+    }
+}
+exports.DexOrderNotFoundError = DexOrderNotFoundError;
+class DexOrderNotStaleError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        super(parameters, {
+            details: { order: parameters.orderId },
+            name: 'DexOrderNotStaleError',
+            shortMessage: `Order ${parameters.orderId} is not stale: its maker is still authorized.`,
+        });
+        Object.defineProperty(this, "orderId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.orderId = parameters.orderId;
+    }
+}
+exports.DexOrderNotStaleError = DexOrderNotStaleError;
+class DexPairNotFoundError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        super(parameters, {
+            details: { tokens: parameters.tokens.join(', ') || undefined },
+            name: 'DexPairNotFoundError',
+        });
+        Object.defineProperty(this, "tokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tokens = parameters.tokens;
+    }
+}
+exports.DexPairNotFoundError = DexPairNotFoundError;
+class DexInsufficientBalanceError extends errors_js_1.TempoExecutionError {
+    constructor(parameters) {
+        const { amount, balance, token } = parameters;
+        super(parameters, {
+            details: { token, amount, balance },
+            name: 'DexInsufficientBalanceError',
+            shortMessage: `Insufficient exchange balance of token "${token}".`,
+        });
+        Object.defineProperty(this, "amount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "balance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.amount = amount;
+        this.balance = balance;
+        this.token = token;
+    }
+}
+exports.DexInsufficientBalanceError = DexInsufficientBalanceError;
+const exchange = {
+    address: Addresses.stablecoinDex,
+    abi: Abis.stablecoinDex,
+};
+function getExchangeCall(context) {
+    const { call } = context;
+    return call && (0, isAddressEqual_js_1.isAddressEqual)(call.address, Addresses.stablecoinDex)
+        ? call
+        : undefined;
+}
+exports.errorResolvers = {
+    'BelowMinimumOrderSize(uint128)': async (context) => {
+        if (!getExchangeCall(context) || !context.base.error.args)
+            return undefined;
+        const [minimum] = await context.read([
+            { ...exchange, functionName: 'MIN_ORDER_AMOUNT' },
+        ]);
+        return new DexBelowMinimumOrderSizeError({
+            ...context.base,
+            minimum: minimum?.result,
+        });
+    },
+    'InsufficientBalance()': async (context) => {
+        const call = getExchangeCall(context);
+        const token = call?.arg('token');
+        if (call?.functionName !== 'withdraw' || !token || !context.signer)
+            return undefined;
+        const [balance] = await context.read([
+            {
+                ...exchange,
+                functionName: 'balanceOf',
+                args: [context.signer.address, token],
+            },
+        ]);
+        return new DexInsufficientBalanceError({
+            ...context.base,
+            amount: call.arg('amount'),
+            balance: balance?.result,
+            token,
+        });
+    },
+    'InsufficientLiquidity()': (context) => {
+        const call = getExchangeCall(context);
+        if (!call)
+            return undefined;
+        return new DexInsufficientLiquidityError({
+            ...context.base,
+            amountIn: call.arg('amountIn'),
+            amountOut: call.arg('amountOut'),
+            tokenIn: call.arg('tokenIn'),
+            tokenOut: call.arg('tokenOut'),
+        });
+    },
+    'InsufficientOutput()': async (context) => {
+        const call = getExchangeCall(context);
+        if (!call)
+            return undefined;
+        const tokenIn = call.arg('tokenIn');
+        const tokenOut = call.arg('tokenOut');
+        const amountIn = call.arg('amountIn');
+        const [quote] = await context.read([
+            {
+                ...exchange,
+                functionName: 'quoteSwapExactAmountIn',
+                args: [tokenIn, tokenOut, amountIn],
+            },
+        ]);
+        return new DexInsufficientOutputError({
+            ...context.base,
+            amountIn,
+            minAmountOut: call.arg('minAmountOut'),
+            quote: quote?.result,
+            tokenIn,
+            tokenOut,
+        });
+    },
+    'InvalidFlipTick()': async (context) => {
+        const call = getExchangeCall(context);
+        if (!call)
+            return undefined;
+        const [tickSpacing] = await context.read([
+            { ...exchange, functionName: 'TICK_SPACING' },
+        ]);
+        const isBid = call.arg('isBid');
+        return new DexInvalidFlipTickError({
+            ...context.base,
+            flipTick: call.arg('flipTick'),
+            side: isBid === undefined ? undefined : isBid ? 'buy' : 'sell',
+            tick: call.arg('tick'),
+            tickSpacing: tickSpacing?.result,
+        });
+    },
+    'MaxInputExceeded()': async (context) => {
+        const call = getExchangeCall(context);
+        if (!call)
+            return undefined;
+        const tokenIn = call.arg('tokenIn');
+        const tokenOut = call.arg('tokenOut');
+        const amountOut = call.arg('amountOut');
+        const [quote] = await context.read([
+            {
+                ...exchange,
+                functionName: 'quoteSwapExactAmountOut',
+                args: [tokenIn, tokenOut, amountOut],
+            },
+        ]);
+        return new DexMaxInputExceededError({
+            ...context.base,
+            amountOut,
+            maxAmountIn: call.arg('maxAmountIn'),
+            quote: quote?.result,
+            tokenIn,
+            tokenOut,
+        });
+    },
+    'OrderDoesNotExist()': (context) => {
+        const orderId = getExchangeCall(context)?.arg('orderId');
+        if (orderId === undefined)
+            return undefined;
+        return new DexOrderNotFoundError({ ...context.base, orderId });
+    },
+    'OrderNotStale()': (context) => {
+        const orderId = getExchangeCall(context)?.arg('orderId');
+        if (orderId === undefined)
+            return undefined;
+        return new DexOrderNotStaleError({ ...context.base, orderId });
+    },
+    'PairDoesNotExist()': (context) => {
+        const call = getExchangeCall(context);
+        if (!call)
+            return undefined;
+        const tokens = ['token', 'tokenIn', 'tokenOut', 'base'].flatMap((name) => {
+            const token = call.arg(name);
+            return token ? [token] : [];
+        });
+        return new DexPairNotFoundError({ ...context.base, tokens });
+    },
+    'TickOutOfBounds(int16)': async (context) => {
+        if (!getExchangeCall(context) || !context.base.error.args)
+            return undefined;
+        const [minTick, maxTick] = await context.read([
+            { ...exchange, functionName: 'MIN_TICK' },
+            { ...exchange, functionName: 'MAX_TICK' },
+        ]);
+        return new DexTickOutOfBoundsError({
+            ...context.base,
+            maxTick: maxTick?.result,
+            minTick: minTick?.result,
+        });
+    },
+};
 //# sourceMappingURL=dex.js.map