@rhinestone/sdk 2.5.0 → 2.7.0

package/dist/src/modules/validators/smart-sessions/resolve.js

@@ -9,6 +9,7 @@ import { DEFAULT_POLICY_ADDRESSES, resolvePolicyAddresses, } from './policies/ad
 import { expandCrossChainPermit, resolvePermit2ClaimPolicy, } from './policies/claim.js';
 import { encodeSessionPolicy } from './policies/encode.js';
 import { resolveSessionSigning } from './signing.js';
+import { resolveSwapScope } from './swap/scope.js';
 export const SMART_SESSIONS_FALLBACK_TARGET_FLAG = '0x0000000000000000000000000000000000000001';
 export const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = '0x00000001';
 export const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION = '0x00000002';
@@ -31,16 +32,73 @@ export function resolveSessionData(definition, options = {}) {
         actionTarget: SMART_SESSIONS_FALLBACK_TARGET_FLAG,
         actionPolicies: [{ policy: addresses.sudo, initData: '0x' }],
     };
-    const userActions = definition.permissions?.length
-        ? resolvePermissions(definition.permissions)
-        : [];
+    // `swap` is sugar over permissions + actions: it compiles to one merged
+    // approve plus one scoped swap action per venue, then rides the same
+    // resolution path. Venue routers, selectors and calldata offsets stay inside
+    // swap-venues.ts so they never reach the public surface (RHI-6286).
+    const swapScope = definition.swap
+        ? resolveSwapScope(definition.swap, definition.chain.id, environment)
+        : undefined;
+    // Declaring `swap` IS the restriction — a swap-scoped session that still
+    // carried the wildcard fallback would let the session key call anything the
+    // global intent-execution whitelist allows, which is the opposite of what the
+    // caller asked for. `restrictToActions` stays as the explicit spelling for
+    // sessions scoped by hand.
+    const restricted = definition.restrictToActions === true || swapScope !== undefined;
+    const permissions = [
+        ...(definition.permissions ?? []),
+        ...(swapScope?.permissions ?? []),
+    ];
+    const userActions = permissions.length ? resolvePermissions(permissions) : [];
+    // Raw scoped actions (target + selector + policies) for calls that can't be
+    // addressed by the ABI-name `permissions` sugar — e.g. a fynd swap scoped by
+    // its raw selector with no ABI (RHI-6286).
+    const rawActions = [
+        ...(definition.actions ?? []),
+        ...(swapScope?.actions ?? []),
+    ];
+    // A restricted session drops the fallback action, which is also where a
+    // cross-chain permit's spending-limit / time-frame guardrails live — so a
+    // restricted session combined with a permit would keep claim signing but lose
+    // maxAmount/deadline enforcement. These are different authorization surfaces;
+    // reject the combination rather than silently drop the guardrails.
+    if (restricted &&
+        (definition.crossChainPermits?.length || definition.claimPolicies?.length)) {
+        throw new Error('restrictToActions is incompatible with crossChainPermits/claimPolicies: ' +
+            'dropping the fallback also drops the permit guardrails (spending/time ' +
+            'limits). Use a restricted scoped-action session or a permit session, ' +
+            'not both.');
+    }
+    // Guard raw actions from reintroducing the wildcard: reject one without
+    // target+selector (would map to the fallback flags), or one that targets the
+    // fallback sentinel outright — either would re-add the wildcard action that
+    // restrictToActions drops.
+    for (const a of rawActions) {
+        if (!('target' in a) || !('selector' in a)) {
+            throw new Error('definition.actions entries must be scoped (target + selector); a ' +
+                'fallback-shaped action would map to the wildcard fallback target');
+        }
+        if (a.target.toLowerCase() ===
+            SMART_SESSIONS_FALLBACK_TARGET_FLAG.toLowerCase()) {
+            throw new Error('definition.actions must not target the fallback sentinel ' +
+                `(${SMART_SESSIONS_FALLBACK_TARGET_FLAG}) — it reintroduces the wildcard action`);
+        }
+    }
     const expandedPermits = (definition.crossChainPermits ?? []).map((input) => expandCrossChainPermit(resolveCrossChainPermission(input), environment));
     const permitFallbackPolicies = expandedPermits.flatMap(({ fallbackPolicies }) => fallbackPolicies);
+    // The wildcard intent-execution fallback. Dropped for a restricted session so
+    // the explicit permissions are the ONLY authorized ops — a non-listed selector
+    // then reverts instead of escaping via the global intent-execution target
+    // whitelist (RHI-6286).
+    const fallbackAction = {
+        policies: [{ type: 'intent-execution' }, ...permitFallbackPolicies],
+    };
     const injectedActions = [
         // Native-wrap `deposit()` is only permitted when the caller supplies the
         // chain's wrapped-native token (e.g. via `RhinestoneSDK.createSession`,
-        // which resolves it from `/chains`).
-        ...(options.wrappedNativeToken
+        // which resolves it from `/chains`). Dropped for a restricted session so it
+        // can't add an unrequested sudo action beyond the caller's permissions.
+        ...(options.wrappedNativeToken && !restricted
             ? [
                 {
                     target: options.wrappedNativeToken,
@@ -54,17 +112,45 @@ export function resolveSessionData(definition, options = {}) {
                 },
             ]
             : []),
-        {
-            policies: [{ type: 'intent-execution' }, ...permitFallbackPolicies],
-        },
+        ...(restricted ? [] : [fallbackAction]),
         {
             target: DUMMY_PRECLAIMOP_TARGET,
             selector: DUMMY_PRECLAIMOP_SELECTOR,
-            policies: [{ type: 'sudo' }],
+            // The real pre-claim op carries no value, so cap it for a restricted
+            // session rather than granting sudo, which would let this injected action
+            // send native value to the dummy target.
+            //
+            // 1 wei, NOT 0: `ValueLimitPolicy.initializeWithMultiplexer` does
+            // `require(valueLimit != 0)`, so a zero limit reverts while the policy is
+            // being installed. That made every restricted session impossible to
+            // enable — the revert surfaces as `InvalidSignature()` from the emissary,
+            // which reads as a signature problem rather than a policy-init one.
+            // 1 wei is the smallest limit that installs, and the op carries no value.
+            policies: restricted
+                ? [{ type: 'value-limit', limit: 1n }]
+                : [{ type: 'sudo' }],
         },
     ];
-    const actions = userActions.length || permitFallbackPolicies.length
-        ? [...userActions, ...injectedActions].map((action) => ({
+    if (restricted && !userActions.length && !rawActions.length) {
+        throw new Error('restrictToActions drops the fallback, so the session must supply at ' +
+            'least one permission or action — none were given');
+    }
+    // Raw actions bypass resolvePermissions' duplicate guard, so a raw action that
+    // collides with an ABI permission (or another raw action) on the same
+    // (target, selector) would map to the same on-chain action id and silently
+    // overwrite policy config — reject it instead.
+    const scoped = [...userActions, ...rawActions].filter((a) => 'target' in a && 'selector' in a);
+    const seen = new Set();
+    for (const a of scoped) {
+        const key = `${a.target.toLowerCase()}:${a.selector.toLowerCase()}`;
+        if (seen.has(key)) {
+            throw new Error(`Duplicate scoped action for (${a.target}, ${a.selector}) — permissions ` +
+                'and actions share one on-chain action id; merge them into a single entry');
+        }
+        seen.add(key);
+    }
+    const actions = userActions.length || rawActions.length || permitFallbackPolicies.length
+        ? [...userActions, ...rawActions, ...injectedActions].map((action) => ({
             actionTargetSelector: 'selector' in action
                 ? action.selector
                 : SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
@@ -81,8 +167,12 @@ export function resolveSessionData(definition, options = {}) {
         policy: PERMIT2_CLAIM_POLICY_ADDRESS,
         initData: encodePermit2ClaimPolicyInitData(resolvePermit2ClaimPolicy(policy)),
     }));
+    // A restricted session must not leave an open ERC-1271 signing surface: with
+    // signing defaulting to unrestricted, a session key limited to swap/approve
+    // could still sign e.g. a Permit2 approval off-chain and move funds. Default it
+    // to `disabled` when restricting; the caller can still opt into a signing policy.
     const erc7739Policies = resolveSessionSigning({
-        signing: definition.signing,
+        signing: definition.signing ?? (restricted ? { mode: 'disabled' } : undefined),
         environment,
         addresses,
     });
@@ -108,7 +198,15 @@ export function toSession(definition, options = {}) {
     return {
         chain: definition.chain,
         owners: definition.owners,
-        hasExplicitPermissions: Boolean(definition.permissions?.length),
+        // Drives `verifyExecutions`, which selects the signature mode: false lets an
+        // already-enabled session sign in pure ERC-1271 mode, and that mode never
+        // reaches the emissary's `verifyExecution` — so the action policies are
+        // never consulted. `swap` compiles to actions, so it MUST count here, or a
+        // swap-only session would silently stop being action-checked the moment it
+        // is enabled.
+        hasExplicitPermissions: Boolean(definition.permissions?.length ||
+            definition.actions?.length ||
+            definition.swap),
         permissionId: getPermissionIdFromData(data),
         sessionValidator: data.sessionValidator,
         sessionValidatorInitData: data.sessionValidatorInitData,
@@ -116,6 +214,7 @@ export function toSession(definition, options = {}) {
         erc7739Policies: data.erc7739Policies,
         actions: data.actions,
         claimPolicies: [...(definition.claimPolicies ?? []), ...expandedClaims],
+        ...(definition.swap ? { swap: definition.swap } : {}),
     };
 }
 export { DEFAULT_POLICY_ADDRESSES };

package/dist/src/modules/validators/smart-sessions/swap/fynd.d.ts

@@ -0,0 +1,92 @@
+import { type Address } from 'viem';
+import type { FyndVenue } from '../types.js';
+import type { VenueContext, VenueScoping } from './rules.js';
+/**
+ * fynd — Rhinestone's self-hosted Tycho aggregator.
+ *
+ * Unlike 0x there is no allowance-holder indirection: the TychoRouter is both
+ * the swap target and the ERC-20 approval spender, and every field we care about
+ * is a named static argument in the calldata head. That means nothing here is a
+ * magic offset — the rules are addressed by ABI parameter name.
+ */
+/** Chains with a deployed, whitelisted TychoRouter. */
+export declare const FYND_CHAIN_IDS: readonly [1, 56, 130, 137, 8453, 9745, 42161];
+export type FyndChainId = (typeof FYND_CHAIN_IDS)[number];
+/**
+ * TychoRouter per chain — the contract fynd's encoded fills target.
+ *
+ * Mirrors `fynd.routers` in the orchestrator's quoters.jsonnet. A chain is
+ * listed only when the router is whitelisted in `IntentExecutionPolicy`, since a
+ * quoter enabled without a whitelisted target produces quotes that revert.
+ */
+export declare const FYND_ROUTERS: Record<FyndChainId, Address>;
+/**
+ * TychoRouter `singleSwap`, the entrypoint fynd's encoded quotes call.
+ *
+ * Only the argument TYPES determine the selector and the head layout, and those
+ * are pinned by {@link FYND_SWAP_SELECTOR}'s assertion in the test suite. The
+ * NAMES of the first five are corroborated by observed fynd calldata; the
+ * trailing tuple's component names are our own labels and carry no guarantee —
+ * we never address them, since a tuple containing `bytes` is dynamic and sits
+ * behind a pointer.
+ */
+export declare const tychoRouterAbi: readonly [{
+    readonly type: "function";
+    readonly name: "singleSwap";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }, {
+        readonly name: "tokenIn";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenOut";
+        readonly type: "address";
+    }, {
+        readonly name: "minAmountOut";
+        readonly type: "uint256";
+    }, {
+        readonly name: "receiver";
+        readonly type: "address";
+    }, {
+        readonly name: "permit";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "nonce";
+            readonly type: "uint16";
+        }, {
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }, {
+            readonly name: "signature";
+            readonly type: "bytes";
+        }];
+    }, {
+        readonly name: "swap";
+        readonly type: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "amountOut";
+        readonly type: "uint256";
+    }];
+}];
+export declare const FYND_SWAP_SELECTOR: `0x${string}`;
+/**
+ * Scope a session to fynd swaps.
+ *
+ * Needs no addresses: the router is a per-chain deployment the SDK knows, and
+ * because it is also the approval spender there is no separate allowance target
+ * to reason about.
+ */
+export declare function fynd(options?: {
+    maxSpend?: bigint;
+}): FyndVenue;
+export declare function scopeFynd(ctx: VenueContext): VenueScoping;
+//# sourceMappingURL=fynd.d.ts.map

package/dist/src/modules/validators/smart-sessions/swap/fynd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fynd.d.ts","sourceRoot":"","sources":["../../../../../../modules/validators/smart-sessions/swap/fynd.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,OAAO,EAAsB,MAAM,MAAM,CAAA;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAkC,MAAM,UAAU,CAAA;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAGzD;;;;;;;GAOG;AAEH,uDAAuD;AACvD,eAAO,MAAM,cAAc,+CAAgD,CAAA;AAE3E,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAQrD,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BH,CAAA;AAExB,eAAO,MAAM,kBAAkB,eAAwC,CAAA;AAQvE;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,SAAS,CAKnE;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,YAAY,GAAG,YAAY,CAoBzD"}

package/dist/src/modules/validators/smart-sessions/swap/fynd.js

@@ -0,0 +1,101 @@
+import { toFunctionSelector } from 'viem';
+import { namedParamOffsets } from '../../permissions.js';
+import { cumulativeCap, pin, swapAction } from './rules.js';
+/**
+ * fynd — Rhinestone's self-hosted Tycho aggregator.
+ *
+ * Unlike 0x there is no allowance-holder indirection: the TychoRouter is both
+ * the swap target and the ERC-20 approval spender, and every field we care about
+ * is a named static argument in the calldata head. That means nothing here is a
+ * magic offset — the rules are addressed by ABI parameter name.
+ */
+/** Chains with a deployed, whitelisted TychoRouter. */
+export const FYND_CHAIN_IDS = [1, 56, 130, 137, 8453, 9745, 42161];
+/**
+ * TychoRouter per chain — the contract fynd's encoded fills target.
+ *
+ * Mirrors `fynd.routers` in the orchestrator's quoters.jsonnet. A chain is
+ * listed only when the router is whitelisted in `IntentExecutionPolicy`, since a
+ * quoter enabled without a whitelisted target produces quotes that revert.
+ */
+export const FYND_ROUTERS = {
+    1: '0xda892c989d07a18b5dd3f392d949f00df15c5736',
+    56: '0x99748cbd931cb367dad265c5b2b4bd306d448e99',
+    130: '0x764bc67b1036b00bc91221e988261f971a1c7ce4',
+    137: '0x7cb3e87095f6cf95982dc6f57445171a6d3b511c',
+    8453: '0x2d3524b9b5dae34b646614eebb1e038d403e4cac',
+    9745: '0x8f9b3b0451efff0ae8100428aee35fa3cbc0b769',
+    42161: '0xc1f838a5382bbb5729a0801c8ba73dfc861c4d34',
+};
+/**
+ * TychoRouter `singleSwap`, the entrypoint fynd's encoded quotes call.
+ *
+ * Only the argument TYPES determine the selector and the head layout, and those
+ * are pinned by {@link FYND_SWAP_SELECTOR}'s assertion in the test suite. The
+ * NAMES of the first five are corroborated by observed fynd calldata; the
+ * trailing tuple's component names are our own labels and carry no guarantee —
+ * we never address them, since a tuple containing `bytes` is dynamic and sits
+ * behind a pointer.
+ */
+export const tychoRouterAbi = [
+    {
+        type: 'function',
+        name: 'singleSwap',
+        stateMutability: 'payable',
+        inputs: [
+            { name: 'amountIn', type: 'uint256' },
+            { name: 'tokenIn', type: 'address' },
+            { name: 'tokenOut', type: 'address' },
+            { name: 'minAmountOut', type: 'uint256' },
+            { name: 'receiver', type: 'address' },
+            {
+                name: 'permit',
+                type: 'tuple',
+                components: [
+                    { name: 'nonce', type: 'uint16' },
+                    { name: 'token', type: 'address' },
+                    { name: 'amount', type: 'uint256' },
+                    { name: 'deadline', type: 'uint256' },
+                    { name: 'signature', type: 'bytes' },
+                ],
+            },
+            { name: 'swap', type: 'bytes' },
+        ],
+        outputs: [{ name: 'amountOut', type: 'uint256' }],
+    },
+];
+export const FYND_SWAP_SELECTOR = toFunctionSelector(tychoRouterAbi[0]);
+/** Head offsets derived from the ABI — never hardcoded. */
+const OFFSETS = namedParamOffsets(tychoRouterAbi, 'singleSwap');
+/**
+ * Scope a session to fynd swaps.
+ *
+ * Needs no addresses: the router is a per-chain deployment the SDK knows, and
+ * because it is also the approval spender there is no separate allowance target
+ * to reason about.
+ */
+export function fynd(options = {}) {
+    return {
+        id: 'fynd',
+        ...(options.maxSpend !== undefined ? { maxSpend: options.maxSpend } : {}),
+    };
+}
+export function scopeFynd(ctx) {
+    const router = FYND_ROUTERS[ctx.chainId];
+    if (router === undefined) {
+        throw new Error(`fynd is not available on chain ${ctx.chainId}. ` +
+            `Supported: ${FYND_CHAIN_IDS.join(', ')}.`);
+    }
+    const rules = [
+        pin(OFFSETS.tokenIn, ctx.sellToken),
+        pin(OFFSETS.tokenOut, ctx.buyToken),
+        pin(OFFSETS.receiver, ctx.recipient),
+    ];
+    if (ctx.cap !== undefined) {
+        rules.push(cumulativeCap(OFFSETS.amountIn, ctx.cap));
+    }
+    return {
+        approveSpenders: [router],
+        actions: [swapAction(router, FYND_SWAP_SELECTOR, rules)],
+    };
+}

package/dist/src/modules/validators/smart-sessions/swap/rhinestone.d.ts

@@ -0,0 +1,147 @@
+import { type Address } from 'viem';
+import type { RhinestoneSwapVenue, RoutedRhinestoneSwapVenue } from '../types.js';
+import type { VenueContext, VenueScoping } from './rules.js';
+/**
+ * The Rhinestone Swapper — the route the orchestrator actually uses for
+ * same-chain smart-account swaps, and the right layer to scope a session at.
+ *
+ * Scoping an aggregator directly (see `zero-ex.ts`, `fynd.ts`) describes a call
+ * the account does not make on this route: the orchestrator wraps whichever
+ * quoter wins behind its own Swapper, so a session scoped to 0x's
+ * AllowanceHolder rejects its own intended swap with `InvalidSignature()`.
+ * Verified live on Plasma — the account's sell token moves to the Swapper, and
+ * the aggregator never appears in the account's ops.
+ *
+ * Scoping here is also strictly better:
+ *   - aggregator-agnostic, so whichever quoter wins is irrelevant
+ *   - no 0x Settler rotation problem, because this contract is ours
+ *   - one approve target per chain (the proxy) instead of one per venue
+ *   - the fields we care about are typed head args on a contract we control,
+ *     with the aggregator route demoted to an opaque `calls[]` tail
+ *
+ * What the Swapper guarantees (verified in compact-utils/src/swapper):
+ * at most `amountIn` of `tokenIn` is pulled, once, from `msg.sender`; the
+ * recipient's measured balance delta must be >= `minAmountOut` or it reverts;
+ * every refund and sweep goes to `msg.sender`. The account cannot be drained
+ * beyond the pulled amount: the tail runs as the Swapper, which holds no
+ * allowance from the account, and `SwapperLib.runRoute` forbids the tail from
+ * calling the proxy that does.
+ *
+ * Be precise about what that bounds, though. A capped `amountIn` bounds how
+ * much can LEAVE; it does not ensure anything comes back. `minAmountOut` is a
+ * caller-supplied argument this scoping does not pin, and the contract accepts
+ * zero — so with an unconstrained route a compromised key can spend up to the
+ * cap and receive nothing. Naming a venue closes that by pinning the
+ * route, leaving the pulled input nowhere to go but a real aggregator.
+ */
+/**
+ * Both entrypoints share a head layout, which is what lets one venue cover
+ * both: `tokenIn`@0, sell amount@32, `tokenOut`@64, `recipient`@160. The sell
+ * amount is `amountIn` for exact-in and `amountInMax` for exact-out — in both
+ * cases the ceiling on what leaves the account, which is exactly what to cap.
+ */
+export declare const swapperAbi: readonly [{
+    readonly type: "function";
+    readonly name: "swapExactIn";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "tokenIn";
+        readonly type: "address";
+    }, {
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }, {
+        readonly name: "tokenOut";
+        readonly type: "address";
+    }, {
+        readonly name: "minAmountOut";
+        readonly type: "uint256";
+    }, {
+        readonly name: "quotedAmountOut";
+        readonly type: "uint256";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "orderRef";
+        readonly type: "uint256";
+    }, {
+        readonly name: "calls";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly name: "amountOut";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "swapExactOut";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "tokenIn";
+        readonly type: "address";
+    }, {
+        readonly name: "amountInMax";
+        readonly type: "uint256";
+    }, {
+        readonly name: "tokenOut";
+        readonly type: "address";
+    }, {
+        readonly name: "amountOut";
+        readonly type: "uint256";
+    }, {
+        readonly name: "quotedAmountIn";
+        readonly type: "uint256";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "orderRef";
+        readonly type: "uint256";
+    }, {
+        readonly name: "calls";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly name: "amountSpent";
+        readonly type: "uint256";
+    }];
+}];
+export declare const SWAP_EXACT_IN_SELECTOR: `0x${string}`;
+export declare const SWAP_EXACT_OUT_SELECTOR: `0x${string}`;
+export declare function swapperAddresses(environment: 'production' | 'development'): {
+    swapper: Address;
+    proxy: Address;
+};
+/**
+ * Route swaps through the Rhinestone Swapper — the default, and the only venue
+ * that matches what the orchestrator emits for same-chain smart-account swaps.
+ *
+ * Takes no addresses and no aggregator: which quoter fills the swap is the
+ * orchestrator's decision, and this scoping holds whichever one wins.
+ */
+export declare function rhinestoneSwap(options?: {
+    maxSpend?: bigint;
+}): RhinestoneSwapVenue;
+export declare function scopeRhinestone(venue: RoutedRhinestoneSwapVenue, ctx: VenueContext): VenueScoping;
+//# sourceMappingURL=rhinestone.d.ts.map

package/dist/src/modules/validators/smart-sessions/swap/rhinestone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rhinestone.d.ts","sourceRoot":"","sources":["../../../../../../modules/validators/smart-sessions/swap/rhinestone.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,OAAO,EAAgC,MAAM,MAAM,CAAA;AAE3E,OAAO,KAAK,EACV,mBAAmB,EACnB,yBAAyB,EAE1B,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAIzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDC,CAAA;AAExB,eAAO,MAAM,sBAAsB,eAAoC,CAAA;AACvE,eAAO,MAAM,uBAAuB,eAAoC,CAAA;AAqBxE,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,GAAG;IAC3E,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf,CAIA;AAkJD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,mBAAmB,CAKrB;AACD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,yBAAyB,EAChC,GAAG,EAAE,YAAY,GAChB,YAAY,CAgFd"}