viem 2.57.5 → 2.57.6

package/_esm/tempo/actions/dex.js

@@ -6,8 +6,11 @@ import { watchContractEvent, } from '../../actions/public/watchContractEvent.js'
 import { writeContract, } from '../../actions/wallet/writeContract.js';
 import { writeContractSync } from '../../actions/wallet/writeContractSync.js';
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js';
+import { isAddressEqual } from '../../utils/address/isAddressEqual.js';
 import * as Abis from '../Abis.js';
 import * as Addresses from '../Addresses.js';
+import { TempoExecutionError } from '../errors.js';
+import { withExecutionError, } from '../internal/errors.js';
 import { defineCall } from '../internal/utils.js';
 /**
  * Buys a specific amount of tokens.
@@ -45,7 +48,7 @@ export 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 withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -165,7 +168,7 @@ export 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 withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -306,7 +309,7 @@ export 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 withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -447,7 +450,7 @@ export 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 withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -581,7 +584,7 @@ export async function getBalance(client, parameters) {
     const address = acc ? parseAccount(acc).address : undefined;
     if (!address)
         throw new Error('account is required.');
-    return readContract(client, {
+    return withExecutionError(readContract)(client, {
         ...rest,
         ...getBalance.call({ account: address, token }),
     });
@@ -631,7 +634,7 @@ export async function getBalance(client, parameters) {
  */
 export async function getBuyQuote(client, parameters) {
     const { tokenIn, tokenOut, amountOut, ...rest } = parameters;
-    return readContract(client, {
+    return withExecutionError(readContract)(client, {
         ...rest,
         ...getBuyQuote.call({ tokenIn, tokenOut, amountOut }),
     });
@@ -679,7 +682,7 @@ export async function getBuyQuote(client, parameters) {
  */
 export async function getOrder(client, parameters) {
     const { orderId, ...rest } = parameters;
-    return readContract(client, {
+    return withExecutionError(readContract)(client, {
         ...rest,
         ...getOrder.call({ orderId }),
     });
@@ -728,7 +731,7 @@ export async function getOrder(client, parameters) {
  */
 export async function getOrderbook(client, parameters) {
     const { base, quote, ...rest } = parameters;
-    return readContract(client, {
+    return withExecutionError(readContract)(client, {
         ...rest,
         ...getOrderbook.call({ base, quote }),
     });
@@ -779,7 +782,7 @@ export async function getOrderbook(client, parameters) {
  */
 export async function getTickLevel(client, parameters) {
     const { base, tick, isBid, ...rest } = parameters;
-    const [head, tail, totalLiquidity] = await readContract(client, {
+    const [head, tail, totalLiquidity] = await withExecutionError(readContract)(client, {
         ...rest,
         ...getTickLevel.call({ base, tick, isBid }),
     });
@@ -830,7 +833,7 @@ export async function getTickLevel(client, parameters) {
  */
 export async function getSellQuote(client, parameters) {
     const { tokenIn, tokenOut, amountIn, ...rest } = parameters;
-    return readContract(client, {
+    return withExecutionError(readContract)(client, {
         ...rest,
         ...getSellQuote.call({ tokenIn, tokenOut, amountIn }),
     });
@@ -889,7 +892,7 @@ export 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 withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -996,7 +999,7 @@ export 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 withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -1189,7 +1192,7 @@ export 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 withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -1482,7 +1485,7 @@ export 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 withExecutionError(action)(client, {
             ...rest,
             ...call,
         }));
@@ -1568,4 +1571,524 @@ export async function withdrawSync(client, parameters) {
 function getPairKey(base, quote) {
     return Hash.keccak256(Hex.concat(base, quote));
 }
+/** Thrown when a sell would return less than `minAmountOut`. */
+export class DexInsufficientOutputError extends 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',
+        });
+        /** Amount of `tokenIn` to sell. */
+        Object.defineProperty(this, "amountIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Minimum amount of `tokenOut` to receive. */
+        Object.defineProperty(this, "minAmountOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Current quote for `amountIn`, when available. */
+        Object.defineProperty(this, "quote", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token to sell. */
+        Object.defineProperty(this, "tokenIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token to buy. */
+        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;
+    }
+}
+/** Thrown when a buy would cost more than `maxAmountIn`. */
+export class DexMaxInputExceededError extends 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',
+        });
+        /** Amount of `tokenOut` to buy. */
+        Object.defineProperty(this, "amountOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Maximum amount of `tokenIn` to spend. */
+        Object.defineProperty(this, "maxAmountIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Current cost of `amountOut`, when available. */
+        Object.defineProperty(this, "quote", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token to spend. */
+        Object.defineProperty(this, "tokenIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token to buy. */
+        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;
+    }
+}
+/** Thrown when the order book cannot fill a swap. */
+export class DexInsufficientLiquidityError extends 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',
+        });
+        /** Amount of `tokenIn` to sell, for sells. */
+        Object.defineProperty(this, "amountIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Amount of `tokenOut` to buy, for buys. */
+        Object.defineProperty(this, "amountOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token to spend. */
+        Object.defineProperty(this, "tokenIn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Token to buy. */
+        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;
+    }
+}
+/** Thrown when an order is smaller than the minimum order size. */
+export class DexBelowMinimumOrderSizeError extends 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}`}.`,
+        });
+        /** Order amount. */
+        Object.defineProperty(this, "amount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Minimum order amount, when known. */
+        Object.defineProperty(this, "minimum", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.amount = amount;
+        this.minimum = minimum;
+    }
+}
+/** Thrown when an order's tick or flip tick is outside the allowed range. */
+export class DexTickOutOfBoundsError extends 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',
+        });
+        /** Highest allowed tick, when known. */
+        Object.defineProperty(this, "maxTick", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Lowest allowed tick, when known. */
+        Object.defineProperty(this, "minTick", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Tick that is out of range. */
+        Object.defineProperty(this, "tick", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxTick = maxTick;
+        this.minTick = minTick;
+        this.tick = tick;
+    }
+}
+/** Thrown when a flip order's flip tick is on the wrong side of its tick or off the tick spacing. */
+export class DexInvalidFlipTickError extends 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,
+        });
+        /** Flip tick. */
+        Object.defineProperty(this, "flipTick", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Order side. */
+        Object.defineProperty(this, "side", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Order tick. */
+        Object.defineProperty(this, "tick", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Tick spacing, when known. */
+        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;
+    }
+}
+/** Thrown when an order does not exist or is already filled. */
+export class DexOrderNotFoundError extends TempoExecutionError {
+    constructor(parameters) {
+        super(parameters, {
+            details: { order: parameters.orderId },
+            name: 'DexOrderNotFoundError',
+            shortMessage: `Order ${parameters.orderId} does not exist or is already filled.`,
+        });
+        /** Order ID. */
+        Object.defineProperty(this, "orderId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.orderId = parameters.orderId;
+    }
+}
+/** Thrown when cancelling a stale order whose maker is still authorized by the token's policy. */
+export class DexOrderNotStaleError extends TempoExecutionError {
+    constructor(parameters) {
+        super(parameters, {
+            details: { order: parameters.orderId },
+            name: 'DexOrderNotStaleError',
+            shortMessage: `Order ${parameters.orderId} is not stale: its maker is still authorized.`,
+        });
+        /** Order ID. */
+        Object.defineProperty(this, "orderId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.orderId = parameters.orderId;
+    }
+}
+/** Thrown when no trading pair exists for a token. */
+export class DexPairNotFoundError extends TempoExecutionError {
+    constructor(parameters) {
+        super(parameters, {
+            details: { tokens: parameters.tokens.join(', ') || undefined },
+            name: 'DexPairNotFoundError',
+        });
+        /** Tokens of the call. */
+        Object.defineProperty(this, "tokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tokens = parameters.tokens;
+    }
+}
+/** Thrown when withdrawing more than the account's exchange balance. */
+export class DexInsufficientBalanceError extends TempoExecutionError {
+    constructor(parameters) {
+        const { amount, balance, token } = parameters;
+        super(parameters, {
+            details: { token, amount, balance },
+            name: 'DexInsufficientBalanceError',
+            shortMessage: `Insufficient exchange balance of token "${token}".`,
+        });
+        /** Amount to withdraw. */
+        Object.defineProperty(this, "amount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Exchange balance, when known. */
+        Object.defineProperty(this, "balance", {
+            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.amount = amount;
+        this.balance = balance;
+        this.token = token;
+    }
+}
+const exchange = {
+    address: Addresses.stablecoinDex,
+    abi: Abis.stablecoinDex,
+};
+/** The failed call, when it targets the exchange. */
+function getExchangeCall(context) {
+    const { call } = context;
+    return call && isAddressEqual(call.address, Addresses.stablecoinDex)
+        ? call
+        : undefined;
+}
+/** @internal */
+export const 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