@shapeshiftoss/swapper 17.7.3 → 18.1.0

package/dist/cjs/utils/evm/stateOverride.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateGasWithStateOverride = exports.getMinimalStateOverride = exports.withTimeout = void 0;
+const contracts_1 = require("@shapeshiftoss/contracts");
+const utils_1 = require("@shapeshiftoss/utils");
+const viem_1 = require("viem");
+const helpers_1 = require("../helpers");
+const storageSlots_1 = require("./storageSlots");
+// Fail fast - rates run inside the UI's 10s bulk budget and anything slower is degraded service
+// where retrying beats waiting (discovered slots are cached, so retries skip discovery)
+const ESTIMATION_TIMEOUT_MS = 3_000;
+// Large native balance for gas (1B is overkill but guarantees success on all chains)
+const NATIVE_BALANCE_OVERRIDE = (0, viem_1.parseEther)('1000000000');
+// Probe sentinel: distinctive enough that a real balance/allowance can't collide with it, and
+// small enough to read back intact through uint96-packed storage (UNI/COMP-style tokens)
+const PROBE_SENTINEL = (1n << 88n) - 0xdecafbadn;
+// Slot numbers seen across known token implementations, swept per layout when access-list
+// discovery isn't available (51/52 covers the L2 storage-gap pattern)
+const CANDIDATE_SLOTS = {
+    solidity: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 51, 52],
+    vyper: [0, 1, 2, 3, 4, 5, 6],
+};
+// Public rpcs on long-tail chains rate limit aggressive fan-out, so sweep probes run in small
+// batches (which also lets a hit in an early batch skip the rest)
+const SWEEP_BATCH_SIZE = 6;
+const discoveredSlots = new Map();
+// Namespaced-storage tokens (ERC-7201 style) have no recoverable slot number - the touched slot
+// itself is cached instead, keyed per owner (and spender) since it embeds them
+const rawDiscoveredSlots = new Map();
+const failedSlotDiscoveries = new Map();
+const FAILED_DISCOVERY_TTL_MS = 60_000;
+const withTimeout = async (promise) => {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error('State override estimation timed out')), ESTIMATION_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+exports.withTimeout = withTimeout;
+// The concrete slot for an owner (and spender) at a candidate slot number/layout
+const getStorageSlotFromLocator = (args) => {
+    const { owner, slotNumber, layout } = args;
+    switch (args.kind) {
+        case 'allowance':
+            return (0, storageSlots_1.getAllowanceStorageSlot)(owner, args.spender, slotNumber, layout);
+        case 'balance':
+            return (0, storageSlots_1.getBalanceStorageSlot)(owner, slotNumber, layout);
+        default:
+            return (0, utils_1.assertUnreachable)(args);
+    }
+};
+// A slot guess only counts if a read through the override reflects the written sentinel
+const probeStorageSlot = async (args) => {
+    const { client, tokenAddress, owner, storageSlot } = args;
+    const stateOverride = [
+        {
+            address: tokenAddress,
+            stateDiff: [{ slot: storageSlot, value: (0, viem_1.pad)((0, viem_1.toHex)(PROBE_SENTINEL)) }],
+        },
+    ];
+    try {
+        const result = await (() => {
+            switch (args.kind) {
+                case 'allowance': {
+                    return client.readContract({
+                        address: tokenAddress,
+                        abi: viem_1.erc20Abi,
+                        functionName: 'allowance',
+                        args: [owner, args.spender],
+                        stateOverride,
+                    });
+                }
+                case 'balance': {
+                    return client.readContract({
+                        address: tokenAddress,
+                        abi: viem_1.erc20Abi,
+                        functionName: 'balanceOf',
+                        args: [owner],
+                        stateOverride,
+                    });
+                }
+                default:
+                    return (0, utils_1.assertUnreachable)(args);
+            }
+        })();
+        return result === PROBE_SENTINEL;
+    }
+    catch {
+        return false;
+    }
+};
+// Caps request gas so nodes that charge the sender up front accept the request. The account is
+// omitted entirely - the node's default (zero address) passes funds checks on gas-charging nodes
+// where an unfunded owner wouldn't, and the sender never affects which slots the read touches
+const ACCESS_LIST_GAS = 400000n;
+// Mapping slots are recovered by hashing candidate slot numbers against the touched set - 256
+// covers storage-gap layouts (slot 51/52 style) with plenty of headroom
+const MAX_MAPPED_SLOT = 256;
+// Raw-slot fallback probes are bounded - balanceOf/allowance reads touch a handful of slots at
+// most (implementation pointer, pause flags, the mapping value)
+const MAX_RAW_SLOT_PROBES = 8;
+// Ask the node which storage slots the read touches (eth_createAccessList) - supported on 23 of
+// our 32 EVM chains, everything else falls through to the candidate sweep
+const findTouchedSlots = async (args) => {
+    const { client, tokenAddress, owner } = args;
+    try {
+        const { accessList } = await client.createAccessList({
+            to: tokenAddress,
+            data: (() => {
+                switch (args.kind) {
+                    case 'allowance':
+                        return (0, viem_1.encodeFunctionData)({
+                            abi: viem_1.erc20Abi,
+                            functionName: 'allowance',
+                            args: [owner, args.spender],
+                        });
+                    case 'balance':
+                        return (0, viem_1.encodeFunctionData)({ abi: viem_1.erc20Abi, functionName: 'balanceOf', args: [owner] });
+                    default:
+                        return (0, utils_1.assertUnreachable)(args);
+                }
+            })(),
+            gas: ACCESS_LIST_GAS,
+        });
+        // Delegatecall storage reads are attributed to the proxy, so the token's own entry holds them
+        return accessList
+            .filter(entry => entry.address.toLowerCase() === tokenAddress.toLowerCase())
+            .flatMap(entry => entry.storageKeys.map(storageKey => storageKey.toLowerCase()));
+    }
+    catch {
+        // Unsupported method or node quirk - the candidate sweep covers it
+        return [];
+    }
+};
+// Recover the mapping slot number by matching the touched slots against locally computed hashes -
+// handles arbitrary slot numbers and both hash orders without any further rpc calls
+const matchTouchedSlot = (args) => {
+    const touched = new Set(args.touchedSlots);
+    for (const layout of ['solidity', 'vyper']) {
+        for (let slotNumber = 0; slotNumber < MAX_MAPPED_SLOT; slotNumber++) {
+            if (touched.has(getStorageSlotFromLocator({ ...args, slotNumber, layout }))) {
+                return { slotNumber, layout };
+            }
+        }
+    }
+    return undefined;
+};
+// Find the concrete storage slot for the owner's balance/allowance: known-table guess first,
+// then access-list assisted discovery (slot-number recovery, raw-slot fallback for namespaced
+// storage), then a batched candidate sweep across both layouts. Results are cached per
+// chain+token (raw slots per owner).
+const discoverStorageSlot = async (args) => {
+    const { chainId, tokenAddress, owner, kind } = args;
+    const cacheKey = `${chainId}:${tokenAddress.toLowerCase()}:${kind}`;
+    const rawCacheKey = `${cacheKey}:${owner.toLowerCase()}${args.kind === 'allowance' ? `:${args.spender.toLowerCase()}` : ''}`;
+    const cached = discoveredSlots.get(cacheKey);
+    if (cached !== undefined)
+        return getStorageSlotFromLocator({ ...args, ...cached });
+    const cachedRaw = rawDiscoveredSlots.get(rawCacheKey);
+    if (cachedRaw !== undefined)
+        return cachedRaw;
+    // Failures re-probe only after the ttl - covers unknown layouts and rpcs without stateOverride
+    // support, which would otherwise pay the full candidate sweep on every rate refresh
+    const failedAt = failedSlotDiscoveries.get(cacheKey);
+    if (failedAt !== undefined && Date.now() - failedAt < FAILED_DISCOVERY_TTL_MS) {
+        throw new Error(`Unable to locate ${kind} storage slot for token ${tokenAddress}`);
+    }
+    const probeLocator = (locator) => probeStorageSlot({ ...args, storageSlot: getStorageSlotFromLocator({ ...args, ...locator }) });
+    const found = await (async () => {
+        const guess = {
+            slotNumber: kind === 'balance'
+                ? (0, storageSlots_1.getTokenBalanceSlot)(tokenAddress)
+                : (0, storageSlots_1.getTokenAllowanceSlot)(tokenAddress),
+            layout: 'solidity',
+        };
+        if (await probeLocator(guess))
+            return guess;
+        const touchedSlots = await findTouchedSlots(args);
+        const matched = matchTouchedSlot({ ...args, touchedSlots });
+        if (matched && (await probeLocator(matched)))
+            return matched;
+        // No recoverable slot number (namespaced storage) - probe the touched slots directly
+        for (const rawSlot of touchedSlots.slice(0, MAX_RAW_SLOT_PROBES)) {
+            if (await probeStorageSlot({ ...args, storageSlot: rawSlot }))
+                return { rawSlot };
+        }
+        const candidates = ['solidity', 'vyper']
+            .flatMap(layout => CANDIDATE_SLOTS[layout].map(slotNumber => ({ slotNumber, layout })))
+            .filter(candidate => !(candidate.layout === guess.layout && candidate.slotNumber === guess.slotNumber));
+        for (let i = 0; i < candidates.length; i += SWEEP_BATCH_SIZE) {
+            const batch = candidates.slice(i, i + SWEEP_BATCH_SIZE);
+            const results = await Promise.all(batch.map(probeLocator));
+            const hit = batch.find((_, j) => results[j]);
+            if (hit)
+                return hit;
+        }
+        return undefined;
+    })();
+    if (found === undefined) {
+        failedSlotDiscoveries.set(cacheKey, Date.now());
+        throw new Error(`Unable to locate ${kind} storage slot for token ${tokenAddress}`);
+    }
+    if ('rawSlot' in found) {
+        rawDiscoveredSlots.set(rawCacheKey, found.rawSlot);
+        return found.rawSlot;
+    }
+    discoveredSlots.set(cacheKey, found);
+    return getStorageSlotFromLocator({ ...args, ...found });
+};
+// Read the seller's actual balance/allowance and override only what's insufficient for the trade,
+// so estimation runs against state as close to execution time as possible
+const getMinimalStateOverride = async ({ sellAsset, sellAmountCryptoBaseUnit, from: _from, spenderAddress, value, }) => {
+    const client = (0, contracts_1.assertGetViemClient)(sellAsset.chainId);
+    const from = (0, viem_1.getAddress)(_from);
+    const valueBigInt = BigInt(value || '0');
+    const sellAmount = BigInt(sellAmountCryptoBaseUnit);
+    const contractAddress = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId)
+        ? undefined
+        : (0, utils_1.contractAddressOrUndefined)(sellAsset.assetId);
+    const stateOverride = [];
+    const needsNativeBalance = async () => {
+        if (valueBigInt <= 0n)
+            return false;
+        const balance = await client.getBalance({ address: from });
+        return balance < valueBigInt;
+    };
+    if (!contractAddress) {
+        if (await needsNativeBalance()) {
+            stateOverride.push({ address: from, balance: NATIVE_BALANCE_OVERRIDE });
+        }
+        return stateOverride.length ? stateOverride : undefined;
+    }
+    const tokenAddress = (0, viem_1.getAddress)(contractAddress);
+    const spender = spenderAddress ? (0, viem_1.getAddress)(spenderAddress) : undefined;
+    const [allowance, balance, nativeBalanceShort] = await Promise.all([
+        spender
+            ? client.readContract({
+                address: tokenAddress,
+                abi: viem_1.erc20Abi,
+                functionName: 'allowance',
+                args: [from, spender],
+            })
+            : Promise.resolve(viem_1.maxUint256),
+        client.readContract({
+            address: tokenAddress,
+            abi: viem_1.erc20Abi,
+            functionName: 'balanceOf',
+            args: [from],
+        }),
+        needsNativeBalance(),
+    ]);
+    if (nativeBalanceShort) {
+        stateOverride.push({ address: from, balance: NATIVE_BALANCE_OVERRIDE });
+    }
+    // Override to the larger of the sell amount and the probe sentinel - covers the trade with
+    // headroom while leaving high bits clear (a full maxUint256 write would set flag bits and
+    // packed-field neighbors, e.g. USDC's slot 9 blacklist bit or UNI's uint96 balances)
+    const overrideValue = (0, viem_1.pad)((0, viem_1.toHex)(sellAmount > PROBE_SENTINEL ? sellAmount : PROBE_SENTINEL));
+    const stateDiff = (await Promise.all([
+        balance < sellAmount
+            ? discoverStorageSlot({
+                client,
+                chainId: sellAsset.chainId,
+                tokenAddress,
+                kind: 'balance',
+                owner: from,
+            }).then(slot => ({ slot, value: overrideValue }))
+            : undefined,
+        spender && allowance < sellAmount
+            ? discoverStorageSlot({
+                client,
+                chainId: sellAsset.chainId,
+                tokenAddress,
+                kind: 'allowance',
+                owner: from,
+                spender,
+            }).then(slot => ({ slot, value: overrideValue }))
+            : undefined,
+    ])).filter((diff) => diff !== undefined);
+    if (stateDiff.length)
+        stateOverride.push({ address: tokenAddress, stateDiff });
+    return stateOverride.length ? stateOverride : undefined;
+};
+exports.getMinimalStateOverride = getMinimalStateOverride;
+// Estimate gas for a transaction the seller can't yet execute (unapproved/unfunded), overriding
+// only the missing state. Estimation runs on our own RPCs - the node applies the same engine over
+// the patched pre-state, so the only systematic delta is the unrealized allowance-decrement refund
+// (a few k gas high, conservative).
+const estimateGasWithStateOverride = ({ to, data, stateOverride: prebuiltStateOverride, ...overrideArgs }) => (0, exports.withTimeout)((async () => {
+    const client = (0, contracts_1.assertGetViemClient)(overrideArgs.sellAsset.chainId);
+    const stateOverride = prebuiltStateOverride ?? (await (0, exports.getMinimalStateOverride)(overrideArgs));
+    const gasLimit = await client.estimateGas({
+        account: (0, viem_1.getAddress)(overrideArgs.from),
+        to: (0, viem_1.getAddress)(to),
+        data: data,
+        value: BigInt(overrideArgs.value || '0'),
+        ...(stateOverride ? { stateOverride } : {}),
+    });
+    return gasLimit.toString();
+})());
+exports.estimateGasWithStateOverride = estimateGasWithStateOverride;

package/dist/{esm/utils/tenderly → cjs/utils/evm}/storageSlots.d.ts

@@ -1,8 +1,8 @@
 import type { Address, Hex } from 'viem';
-export declare const getBalanceStorageSlot: (userAddress: Address, balanceSlotNumber?: number) => Hex;
-export declare const getAllowanceStorageSlot: (ownerAddress: Address, spenderAddress: Address, allowanceSlotNumber?: number) => Hex;
+export type StorageLayout = 'solidity' | 'vyper';
+export declare const getBalanceStorageSlot: (userAddress: Address, balanceSlotNumber: number, layout?: StorageLayout) => Hex;
+export declare const getAllowanceStorageSlot: (ownerAddress: Address, spenderAddress: Address, allowanceSlotNumber: number, layout?: StorageLayout) => Hex;
 export declare const KNOWN_BALANCE_SLOTS: Record<string, number>;
 export declare const KNOWN_ALLOWANCE_SLOTS: Record<string, number>;
 export declare const getTokenBalanceSlot: (tokenAddress: Address) => number;
 export declare const getTokenAllowanceSlot: (tokenAddress: Address) => number;
-export declare const getMaxBalanceValue: (tokenAddress: Address) => Hex;

package/dist/cjs/utils/{tenderly → evm}/storageSlots.js

@@ -1,22 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMaxBalanceValue = exports.getTokenAllowanceSlot = exports.getTokenBalanceSlot = exports.KNOWN_ALLOWANCE_SLOTS = exports.KNOWN_BALANCE_SLOTS = exports.getAllowanceStorageSlot = exports.getBalanceStorageSlot = void 0;
+exports.getTokenAllowanceSlot = exports.getTokenBalanceSlot = exports.KNOWN_ALLOWANCE_SLOTS = exports.KNOWN_BALANCE_SLOTS = exports.getAllowanceStorageSlot = exports.getBalanceStorageSlot = void 0;
 const viem_1 = require("viem");
-// keccak256(concat(pad(address), pad(slot)))
-const getBalanceStorageSlot = (userAddress, balanceSlotNumber = 0) => {
-    const paddedAddress = (0, viem_1.pad)(userAddress.toLowerCase(), { size: 32 });
-    const paddedSlot = (0, viem_1.pad)((0, viem_1.toHex)(balanceSlotNumber), { size: 32 });
-    return (0, viem_1.keccak256)((0, viem_1.concat)([paddedAddress, paddedSlot]));
+const getMappingStorageSlot = (key, slot, layout) => {
+    const paddedKey = (0, viem_1.pad)(key.toLowerCase(), { size: 32 });
+    const paddedSlot = (0, viem_1.pad)(typeof slot === 'number' ? (0, viem_1.toHex)(slot) : slot, { size: 32 });
+    return (0, viem_1.keccak256)((0, viem_1.concat)(layout === 'vyper' ? [paddedSlot, paddedKey] : [paddedKey, paddedSlot]));
 };
+const getBalanceStorageSlot = (userAddress, balanceSlotNumber, layout = 'solidity') => getMappingStorageSlot(userAddress, balanceSlotNumber, layout);
 exports.getBalanceStorageSlot = getBalanceStorageSlot;
-// keccak256(spender, keccak256(owner, slot))
-const getAllowanceStorageSlot = (ownerAddress, spenderAddress, allowanceSlotNumber = 1) => {
-    const paddedOwner = (0, viem_1.pad)(ownerAddress.toLowerCase(), { size: 32 });
-    const paddedAllowanceSlot = (0, viem_1.pad)((0, viem_1.toHex)(allowanceSlotNumber), { size: 32 });
-    const innerSlot = (0, viem_1.keccak256)((0, viem_1.concat)([paddedOwner, paddedAllowanceSlot]));
-    const paddedSpender = (0, viem_1.pad)(spenderAddress.toLowerCase(), { size: 32 });
-    return (0, viem_1.keccak256)((0, viem_1.concat)([paddedSpender, innerSlot]));
-};
+// Nested mapping - the outer (spender) hash chains onto the inner (owner) hash
+const getAllowanceStorageSlot = (ownerAddress, spenderAddress, allowanceSlotNumber, layout = 'solidity') => getMappingStorageSlot(spenderAddress, getMappingStorageSlot(ownerAddress, allowanceSlotNumber, layout), layout);
 exports.getAllowanceStorageSlot = getAllowanceStorageSlot;
 // Most ERC20s: balance at slot 0, allowance at slot 1
 // Slot 51/52 pattern (StandardArbERC20, some L2 implementations)
@@ -86,9 +80,3 @@ const getTokenAllowanceSlot = (tokenAddress) => {
     return 1;
 };
 exports.getTokenAllowanceSlot = getTokenAllowanceSlot;
-// USDC slot 9: bit 255 is blacklist flag, must keep cleared
-const getMaxBalanceValue = (tokenAddress) => {
-    const slot = (0, exports.getTokenBalanceSlot)(tokenAddress);
-    return slot === 9 ? (0, viem_1.toHex)(viem_1.maxUint256 >> 1n) : (0, viem_1.toHex)(viem_1.maxUint256);
-};
-exports.getMaxBalanceValue = getMaxBalanceValue;

package/dist/cjs/{swappers/utils/helpers → utils}/helpers.js

@@ -49,6 +49,7 @@ const DAO_TREASURY_BY_CHAIN_ID = {
     [types_1.KnownChainIds.TonMainnet]: utils_1.DAO_TREASURY_TON,
     [types_1.KnownChainIds.MonadMainnet]: utils_1.DAO_TREASURY_MONAD,
     [types_1.KnownChainIds.HyperEvmMainnet]: utils_1.DAO_TREASURY_HYPEREVM,
+    [types_1.KnownChainIds.BobMainnet]: utils_1.DAO_TREASURY_BOB,
 };
 const getTreasuryAddressFromChainId = (chainId) => {
     const maybeTreasuryChainId = (0, utils_1.isTreasuryChainId)(chainId) ? chainId : undefined;

package/dist/cjs/utils/helpers.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("@shapeshiftoss/types");
+const utils_1 = require("@shapeshiftoss/utils");
+const vitest_1 = require("vitest");
+const helpers_1 = require("./helpers");
+(0, vitest_1.describe)('getTreasuryAddressFromChainId', () => {
+    // Affiliate and fee recipient addresses for every swapper flow through here, so pin the values
+    // rather than the wiring - a chain pointing at another chain's treasury misroutes revenue silently
+    const expectedTreasuryAddressByChainId = {
+        [types_1.KnownChainIds.EthereumMainnet]: '0x90a48d5cf7343b08da12e067680b4c6dbfe551be',
+        [types_1.KnownChainIds.OptimismMainnet]: '0x6268d07327f4fb7380732dc6d63d95F88c0E083b',
+        [types_1.KnownChainIds.AvalancheMainnet]: '0x74d63F31C2335b5b3BA7ad2812357672b2624cEd',
+        [types_1.KnownChainIds.PolygonMainnet]: '0xB5F944600785724e31Edb90F9DFa16dBF01Af000',
+        [types_1.KnownChainIds.GnosisMainnet]: '0xb0E3175341794D1dc8E5F02a02F9D26989EbedB3',
+        [types_1.KnownChainIds.BnbSmartChainMainnet]: '0x8b92b1698b57bEDF2142297e9397875ADBb2297E',
+        [types_1.KnownChainIds.ArbitrumMainnet]: '0x38276553F8fbf2A027D901F8be45f00373d8Dd48',
+        [types_1.KnownChainIds.BaseMainnet]: '0x9c9aA90363630d4ab1D9dbF416cc3BBC8d3Ed502',
+        [types_1.KnownChainIds.MonadMainnet]: '0xF5AA59151bE6515C4Ca68A0282CF68B3eA4846fC',
+        [types_1.KnownChainIds.HyperEvmMainnet]: '0xF5AA59151bE6515C4Ca68A0282CF68B3eA4846fC',
+        [types_1.KnownChainIds.BobMainnet]: '0xF5AA59151bE6515C4Ca68A0282CF68B3eA4846fC',
+        [types_1.KnownChainIds.BitcoinMainnet]: 'bc1q9xrjfet2a05r3jvsxx66rru7pysevk5dvqasdw9eeea3rfqlk33qr4hghh',
+        [types_1.KnownChainIds.SolanaMainnet]: 'FxXyPB5RH4uHLPPJR5H89zGwZp19juBetmRwrxfsLj2j',
+        [types_1.KnownChainIds.StarknetMainnet]: '0x07ac2252f2da7cbf085e7a5ddc1318243aa818607cdd430dd2e17dd5d487606a',
+        [types_1.KnownChainIds.TonMainnet]: 'UQAHHeOhXst-zSGGigQ8KgDzz89nACBR4TxXwXNjU4DsriLb',
+    };
+    vitest_1.it.each(utils_1.treasuryChainIds)('returns the treasury address for %s', chainId => {
+        (0, vitest_1.expect)((0, helpers_1.getTreasuryAddressFromChainId)(chainId)).toBe(expectedTreasuryAddressByChainId[chainId]);
+    });
+    (0, vitest_1.it)('throws for unsupported chains', () => {
+        (0, vitest_1.expect)(() => (0, helpers_1.getTreasuryAddressFromChainId)(caip_1.thorchainChainId)).toThrow('[getTreasuryAddressFromChainId] - Unsupported chainId');
+    });
+});

package/dist/cjs/{utils.d.ts → utils/index.d.ts}

@@ -6,26 +6,36 @@ import type { Asset, EvmChainId } from '@shapeshiftoss/types';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import type { Result } from '@sniptt/monads';
 import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
-import type { EvmTransactionExecutionProps, ExecutableTradeStep, NearTransactionExecutionProps, SolanaTransactionExecutionProps, StarknetTransactionExecutionProps, SuiTransactionExecutionProps, SupportedTradeQuoteStepIndex, SwapErrorRight, TonTransactionExecutionProps, TradeQuote, TradeQuoteStep, TradeRate, TradeStatus, TronTransactionExecutionProps } from './types';
-import { TradeQuoteError } from './types';
+import type { TypedData } from 'eip-712';
+import type { CommonSwapMetadata, EvmTransactionExecutionProps, NearTransactionExecutionProps, SolanaTransactionExecutionProps, StarknetTransactionExecutionProps, SuiTransactionExecutionProps, SupportedTradeQuoteStepIndex, SwapErrorRight, SwapMetadata, SwapperMetadata, TonTransactionExecutionProps, TradeQuote, TradeQuoteStep, TradeRate, TradeRateStep, TradeStatus, TronTransactionExecutionProps } from '../types';
+import { TradeQuoteError } from '../types';
+export declare const getPermit2Eip712: (step: TradeQuoteStep | TradeRateStep | undefined) => TypedData | undefined;
 export declare const makeSwapErrorRight: ({ details, cause, code, message, }: {
     message: string;
     details?: unknown;
     cause?: unknown;
     code?: TradeQuoteError | undefined;
 }) => SwapErrorRight;
+export declare const assertQuoteAddresses: ({ sendAddress, receiveAddress, }: {
+    sendAddress?: string | undefined;
+    receiveAddress?: string | undefined;
+}) => Result<{
+    sendAddress: string;
+    receiveAddress: string;
+}, SwapErrorRight>;
 export declare const createTradeAmountTooSmallErr: (details?: {
     minAmountCryptoBaseUnit: string;
     assetId: AssetId;
 }) => SwapErrorRight;
+export declare const makeNetworkFeeEstimationFailedErr: (context: string, cause?: unknown) => SwapErrorRight;
+export declare const makeTradeStepBuildFailedErr: (context: string, cause?: unknown) => SwapErrorRight;
 export declare const createCache: (maxAge: number, cachedUrls: string[], axiosConfig: AxiosRequestConfig) => AxiosInstance;
-export declare const AsyncResultOf: <T>(promise: Promise<T>) => Promise<Result<T, Error>>;
 export declare const makeSwapperAxiosServiceMonadic: (service: AxiosInstance) => {
     get: <T = any>(url: string, config?: AxiosRequestConfig<any>) => Promise<Result<AxiosResponse<T, any, {}>, SwapErrorRight>>;
     post: <T_1 = any>(url: string, data: any, config?: AxiosRequestConfig<any>) => Promise<Result<AxiosResponse<T_1, any, {}>, SwapErrorRight>>;
     delete: <T_2 = any>(url: string, data: any, config?: AxiosRequestConfig<any>) => Promise<Result<AxiosResponse<T_2, any, {}>, SwapErrorRight>>;
 };
-export declare const getHopByIndex: (quote: TradeQuote | TradeRate | undefined, index: SupportedTradeQuoteStepIndex) => TradeQuoteStep | undefined;
+export declare const getHopByIndex: (quote: TradeQuote | TradeRate | undefined, index: SupportedTradeQuoteStepIndex) => TradeQuoteStep | TradeRateStep | undefined;
 export declare const executeEvmTransaction: (txToSign: SignTx<EvmChainId>, callbacks: EvmTransactionExecutionProps) => Promise<string>;
 export declare const executeSolanaTransaction: (txToSign: SolanaSignTx, callbacks: SolanaTransactionExecutionProps) => Promise<string>;
 export declare const executeTronTransaction: (txToSign: TronSignTx, callbacks: TronTransactionExecutionProps) => Promise<string>;
@@ -59,8 +69,7 @@ export declare const getInputOutputRate: ({ sellAmountCryptoBaseUnit, buyAmountC
     buyAsset: Asset;
 }) => string;
 export declare const isExecutableTradeQuote: (quote: TradeQuote | TradeRate) => quote is TradeQuote;
-export declare const isExecutableTradeStep: (step: TradeQuoteStep) => step is ExecutableTradeStep;
-export declare const getExecutableTradeStep: (tradeQuote: TradeQuote, stepIndex: SupportedTradeQuoteStepIndex) => ExecutableTradeStep;
+export declare const getExecutableTradeStep: (tradeQuote: TradeQuote, stepIndex: SupportedTradeQuoteStepIndex) => TradeQuoteStep;
 export declare const checkSolanaSwapStatus: ({ txHash, address, assertGetSolanaChainAdapter, }: {
     txHash: string;
     address: string | undefined;
@@ -78,3 +87,25 @@ export declare const checkStarknetSwapStatus: ({ txHash, assertGetStarknetChainA
 export declare class SolanaLogsError extends Error {
     constructor(name: string);
 }
+export declare const buildSwapMetadata: (step: TradeQuoteStep | TradeRateStep, common: CommonSwapMetadata) => SwapMetadata;
+export declare const getSwapMetadata: <S extends "avnu" | "bebop" | "bob" | "chainflip" | "debridge" | "nearIntents" | "relay" | "stonfi" | "thorchain" | "mayachain">(metadata: SwapperMetadata | undefined, name: S) => Extract<import("../swappers/AvnuSwapper/types").AvnuMetadata, {
+    name: S;
+}> | Extract<import("../swappers/BebopSwapper/types").BebopMetadata, {
+    name: S;
+}> | Extract<import("../swappers/BobGatewaySwapper/types").BobGatewayMetadata, {
+    name: S;
+}> | Extract<import("..").ChainflipMetadata, {
+    name: S;
+}> | Extract<import("../swappers/DebridgeSwapper/utils/types").DebridgeMetadata, {
+    name: S;
+}> | Extract<import("../swappers/NearIntentsSwapper").NearIntentsMetadata, {
+    name: S;
+}> | Extract<import("../swappers/RelaySwapper/utils/types").RelayMetadata, {
+    name: S;
+}> | Extract<import("../swappers/StonfiSwapper").StonfiMetadata, {
+    name: S;
+}> | Extract<import("./thorchain").ThorchainMetadata, {
+    name: S;
+}> | Extract<import("./thorchain").MayachainMetadata, {
+    name: S;
+}>;

package/dist/cjs/{utils.js → utils/index.js}

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaLogsError = exports.checkStarknetSwapStatus = exports.checkSuiSwapStatus = exports.checkSolanaSwapStatus = exports.getExecutableTradeStep = exports.isExecutableTradeStep = exports.isExecutableTradeQuote = exports.getInputOutputRate = exports.checkEvmSwapStatus = exports.checkSafeTransactionStatus = exports.createDefaultStatusResponse = exports.executeTonTransaction = exports.executeStarknetTransaction = exports.executeNearTransaction = exports.executeSuiTransaction = exports.executeTronTransaction = exports.executeSolanaTransaction = exports.executeEvmTransaction = exports.getHopByIndex = exports.makeSwapperAxiosServiceMonadic = exports.AsyncResultOf = exports.createCache = exports.createTradeAmountTooSmallErr = exports.makeSwapErrorRight = void 0;
+exports.getSwapMetadata = exports.buildSwapMetadata = exports.SolanaLogsError = exports.checkStarknetSwapStatus = exports.checkSuiSwapStatus = exports.checkSolanaSwapStatus = exports.getExecutableTradeStep = exports.isExecutableTradeQuote = exports.getInputOutputRate = exports.checkEvmSwapStatus = exports.checkSafeTransactionStatus = exports.createDefaultStatusResponse = exports.executeTonTransaction = exports.executeStarknetTransaction = exports.executeNearTransaction = exports.executeSuiTransaction = exports.executeTronTransaction = exports.executeSolanaTransaction = exports.executeEvmTransaction = exports.getHopByIndex = exports.makeSwapperAxiosServiceMonadic = exports.createCache = exports.makeTradeStepBuildFailedErr = exports.makeNetworkFeeEstimationFailedErr = exports.createTradeAmountTooSmallErr = exports.assertQuoteAddresses = exports.makeSwapErrorRight = exports.getPermit2Eip712 = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const unchained_client_1 = require("@shapeshiftoss/unchained-client");
@@ -11,8 +11,14 @@ const utils_1 = require("@shapeshiftoss/utils");
 const monads_1 = require("@sniptt/monads");
 const axios_1 = __importDefault(require("axios"));
 const axios_cache_interceptor_1 = require("axios-cache-interceptor");
-const safe_utils_1 = require("./safe-utils");
-const types_1 = require("./types");
+const types_1 = require("../types");
+const safe_1 = require("./safe");
+const getPermit2Eip712 = (step) => {
+    return step?.transactionData?.type === 'evm'
+        ? step.transactionData.signatureRequired?.eip712
+        : undefined;
+};
+exports.getPermit2Eip712 = getPermit2Eip712;
 const makeSwapErrorRight = ({ details, cause, code, message, }) => ({
     name: 'SwapError',
     message,
@@ -21,12 +27,40 @@ const makeSwapErrorRight = ({ details, cause, code, message, }) => ({
     code,
 });
 exports.makeSwapErrorRight = makeSwapErrorRight;
+const assertQuoteAddresses = ({ sendAddress, receiveAddress, }) => {
+    if (!sendAddress) {
+        return (0, monads_1.Err)((0, exports.makeSwapErrorRight)({
+            message: 'sendAddress is required',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    if (!receiveAddress) {
+        return (0, monads_1.Err)((0, exports.makeSwapErrorRight)({
+            message: 'receiveAddress is required',
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    return (0, monads_1.Ok)({ sendAddress, receiveAddress });
+};
+exports.assertQuoteAddresses = assertQuoteAddresses;
 const createTradeAmountTooSmallErr = (details) => (0, exports.makeSwapErrorRight)({
     code: types_1.TradeQuoteError.SellAmountBelowMinimum,
     message: 'Sell amount is too small',
     details,
 });
 exports.createTradeAmountTooSmallErr = createTradeAmountTooSmallErr;
+const makeNetworkFeeEstimationFailedErr = (context, cause) => (0, exports.makeSwapErrorRight)({
+    code: types_1.TradeQuoteError.NetworkFeeEstimationFailed,
+    message: `[${context}] Error estimating network fee`,
+    cause,
+});
+exports.makeNetworkFeeEstimationFailedErr = makeNetworkFeeEstimationFailedErr;
+const makeTradeStepBuildFailedErr = (context, cause) => (0, exports.makeSwapErrorRight)({
+    code: types_1.TradeQuoteError.InvalidResponse,
+    message: `[${context}] Error building trade step`,
+    cause,
+});
+exports.makeTradeStepBuildFailedErr = makeTradeStepBuildFailedErr;
 const getRequestFilter = (cachedUrls) => (request) => !cachedUrls.some(url => request.url?.includes(url));
 const createCache = (maxAge, cachedUrls, axiosConfig) => {
     const filter = getRequestFilter(cachedUrls);
@@ -50,7 +84,6 @@ const AsyncResultOf = async (promise) => {
         return (0, monads_1.Err)(err);
     }
 };
-exports.AsyncResultOf = AsyncResultOf;
 const makeSwapperAxiosServiceMonadic = (service) => new Proxy(service, {
     get: (trappedAxios, method) => {
         const originalMethodPromise = trappedAxios[method];
@@ -60,7 +93,7 @@ const makeSwapperAxiosServiceMonadic = (service) => new Proxy(service, {
             //   url: args[0],
             //   method,
             // })
-            const result = await (0, exports.AsyncResultOf)(originalMethodPromise(...args));
+            const result = await AsyncResultOf(originalMethodPromise(...args));
             return result
                 .mapErr(e => (0, exports.makeSwapErrorRight)({
                 message: 'makeSwapperAxiosServiceMonadic',
@@ -125,7 +158,7 @@ const createDefaultStatusResponse = (buyTxHash) => ({
 });
 exports.createDefaultStatusResponse = createDefaultStatusResponse;
 const checkSafeTransactionStatus = async ({ address, txHash, chainId, assertGetEvmChainAdapter, fetchIsSmartContractAddressQuery, }) => {
-    const { isExecutedSafeTx, isQueuedSafeTx, transaction } = await (0, safe_utils_1.fetchSafeTransactionInfo)({
+    const { isExecutedSafeTx, isQueuedSafeTx, transaction } = await (0, safe_1.fetchSafeTransactionInfo)({
         address,
         chainId,
         fetchIsSmartContractAddressQuery,
@@ -209,14 +242,11 @@ const getInputOutputRate = ({ sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit,
 exports.getInputOutputRate = getInputOutputRate;
 const isExecutableTradeQuote = (quote) => quote.quoteOrRate === 'quote';
 exports.isExecutableTradeQuote = isExecutableTradeQuote;
-const isExecutableTradeStep = (step) => step.accountNumber !== undefined;
-exports.isExecutableTradeStep = isExecutableTradeStep;
 const getExecutableTradeStep = (tradeQuote, stepIndex) => {
-    const step = (0, exports.getHopByIndex)(tradeQuote, stepIndex);
+    // A TradeQuote is executable by construction, so its steps are TradeQuoteStep (accountNumber set)
+    const step = tradeQuote.steps[stepIndex];
     if (!step)
         throw new Error(`No hop found for stepIndex ${stepIndex}`);
-    if (!(0, exports.isExecutableTradeStep)(step))
-        throw Error('Unable to execute a trade rate step');
     return step;
 };
 exports.getExecutableTradeStep = getExecutableTradeStep;
@@ -322,3 +352,14 @@ class SolanaLogsError extends Error {
     }
 }
 exports.SolanaLogsError = SolanaLogsError;
+const buildSwapMetadata = (step, common) => ({
+    ...common,
+    swapperMetadata: step.swapperMetadata,
+});
+exports.buildSwapMetadata = buildSwapMetadata;
+const getSwapMetadata = (metadata, name) => {
+    if (metadata?.name !== name)
+        throw new Error(`Expected ${name} swap metadata`);
+    return metadata;
+};
+exports.getSwapMetadata = getSwapMetadata;

package/dist/cjs/utils/safe/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/solana/calculateAccountCreationCosts.d.ts

@@ -0,0 +1,3 @@
+import type { TransactionInstruction } from '@solana/web3.js';
+export declare const ATA_RENT_LAMPORTS = 2040000;
+export declare const calculateAccountCreationCosts: (instructions: TransactionInstruction[]) => string;

package/dist/cjs/utils/solana/calculateAccountCreationCosts.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAccountCreationCosts = exports.ATA_RENT_LAMPORTS = void 0;
+const token_1 = require("@coral-xyz/anchor/dist/cjs/utils/token");
+const utils_1 = require("@shapeshiftoss/utils");
+exports.ATA_RENT_LAMPORTS = 2040000;
+// Rent paid to create any associated token accounts the transaction opens (e.g. a first-time
+// transfer of an SPL token to a recipient that doesn't yet hold it). Included in reported
+// network fees so the displayed cost matches what the payer actually spends.
+const calculateAccountCreationCosts = (instructions) => {
+    const ataCreationCount = instructions.filter(instruction => instruction.programId.toString() === token_1.ASSOCIATED_PROGRAM_ID.toString()).length;
+    return (0, utils_1.bnOrZero)(exports.ATA_RENT_LAMPORTS).times(ataCreationCount).toString();
+};
+exports.calculateAccountCreationCosts = calculateAccountCreationCosts;

package/dist/cjs/utils/solana/computeBudgetInstructions.d.ts

@@ -0,0 +1,13 @@
+import type { TransactionInstruction } from '@solana/web3.js';
+export type SolanaComputeBudgetOptions = {
+    marginMultiplier?: number;
+    minComputeUnits?: number;
+};
+export declare const isComputeBudgetInstruction: (instruction: TransactionInstruction) => boolean;
+export declare const omitComputeBudgetInstructions: (instructions: TransactionInstruction[]) => TransactionInstruction[];
+export declare const withComputeUnitLimit: ({ instructions, computeUnits, includeComputeBudget, computeBudget, }: {
+    instructions: TransactionInstruction[];
+    computeUnits: string;
+    includeComputeBudget: boolean;
+    computeBudget?: SolanaComputeBudgetOptions | undefined;
+}) => TransactionInstruction[];