@rhinestone/sdk 1.13.4 → 1.15.0

package/dist/src/modules/validators/quorum.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQuorumMerkleTree = buildQuorumMerkleTree;
+exports.encodeQuorumErc1271Signature = encodeQuorumErc1271Signature;
+exports.encodeQuorumMerkleSignature = encodeQuorumMerkleSignature;
+exports.encodeQuorumOwnerSignatures = encodeQuorumOwnerSignatures;
+exports.getQuorumConfigOwners = getQuorumConfigOwners;
+exports.getQuorumMerkleRootSignableHash = getQuorumMerkleRootSignableHash;
+exports.getQuorumMockSignature = getQuorumMockSignature;
+exports.getQuorumSignableHash = getQuorumSignableHash;
+exports.getQuorumValidator = getQuorumValidator;
+const viem_1 = require("viem");
+const common_1 = require("../common");
+const ordering_1 = require("./ordering");
+const MAX_QUORUM_OWNERS = 32;
+const MAX_UINT96 = (1n << 96n) - 1n;
+const MAX_SIGNATURE_LENGTH = 65_535;
+const QUORUM_MOCK_SIGNATURE = `0x${'00'.repeat(64)}1b`;
+const QUORUM_MESSAGE_TYPEHASH = (0, viem_1.keccak256)((0, viem_1.toHex)('WeightedOwnableValidatorMessage(address validator,uint256 chainId,address account,bytes32 hash)'));
+function getQuorumSignableHash(input) {
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { type: 'bytes32' },
+        { type: 'address' },
+        { type: 'uint256' },
+        { type: 'address' },
+        { type: 'bytes32' },
+    ], [
+        QUORUM_MESSAGE_TYPEHASH,
+        input.validator,
+        BigInt(input.chainId),
+        input.account,
+        input.hash,
+    ]));
+}
+function buildQuorumMerkleTree(operations) {
+    if (operations.length < 2) {
+        throw new Error('Quorum Merkle signing requires at least two operations');
+    }
+    const leaves = operations.map(({ account, digest }) => (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: 'address' }, { type: 'bytes32' }], [account, digest])));
+    const layers = [leaves];
+    while (layers.at(-1).length > 1) {
+        const current = layers.at(-1);
+        const next = [];
+        for (let index = 0; index < current.length; index += 2) {
+            next.push(index + 1 < current.length
+                ? hashQuorumMerklePair(current[index], current[index + 1])
+                : current[index]);
+        }
+        layers.push(next);
+    }
+    const root = layers.at(-1)[0];
+    return {
+        root,
+        operations: operations.map(({ account, digest }, leafIndex) => {
+            const proof = [];
+            let index = leafIndex;
+            for (const layer of layers.slice(0, -1)) {
+                const siblingIndex = index % 2 === 0 ? index + 1 : index - 1;
+                if (siblingIndex < layer.length)
+                    proof.push(layer[siblingIndex]);
+                index = Math.floor(index / 2);
+            }
+            return { account, digest, leaf: leaves[leafIndex], root, proof };
+        }),
+    };
+}
+function getQuorumMerkleRootSignableHash(input) {
+    return (0, viem_1.hashTypedData)({
+        domain: {
+            name: 'Quorum Signer',
+            version: '1',
+            verifyingContract: input.validator,
+        },
+        types: {
+            WeightedMerkleRoot: [{ name: 'root', type: 'bytes32' }],
+        },
+        primaryType: 'WeightedMerkleRoot',
+        message: { root: input.root },
+    });
+}
+function getQuorumValidator(config) {
+    const owners = resolveOwners(config).sort((left, right) => (0, ordering_1.compareHexValues)(left.signer, right.signer));
+    validateQuorumConfig(owners, config.thresholdWeight);
+    return {
+        address: config.module,
+        initData: (0, viem_1.encodeAbiParameters)([
+            { name: 'thresholdWeight', type: 'uint256' },
+            {
+                name: 'owners',
+                type: 'tuple[]',
+                components: [
+                    { name: 'addr', type: 'address' },
+                    { name: 'weight', type: 'uint96' },
+                ],
+            },
+        ], [
+            config.thresholdWeight,
+            owners.map(({ signer, weight }) => ({ addr: signer, weight })),
+        ]),
+        deInitData: '0x',
+        additionalContext: '0x',
+        type: common_1.MODULE_TYPE_ID_VALIDATOR,
+    };
+}
+function encodeQuorumOwnerSignatures(input) {
+    validateQuorumConfig(input.owners, input.thresholdWeight);
+    const configured = new Map(input.owners.map((owner) => [owner.ownerId, owner]));
+    const contributions = new Map();
+    for (const contribution of input.signatures) {
+        if (!configured.has(contribution.ownerId)) {
+            throw new Error(`Unknown validator owner ${contribution.ownerId}`);
+        }
+        if (contributions.has(contribution.ownerId)) {
+            throw new Error(`Duplicate validator owner ${contribution.ownerId}`);
+        }
+        contributions.set(contribution.ownerId, contribution.signature);
+    }
+    const selected = input.owners
+        .filter((owner) => contributions.has(owner.ownerId))
+        .sort((left, right) => (0, ordering_1.compareHexValues)(left.signer, right.signer));
+    const signedWeight = selected.reduce((sum, owner) => sum + owner.weight, 0n);
+    if (signedWeight < input.thresholdWeight) {
+        throw new Error(`Insufficient validator contribution weight: required ${input.thresholdWeight}, received ${signedWeight}`);
+    }
+    return encodeQuorumEntries(selected.map((owner) => ({
+        signer: owner.signer,
+        signature: contributions.get(owner.ownerId),
+    })));
+}
+function encodeQuorumErc1271Signature(input) {
+    if (input.signatures === '0x') {
+        throw new Error('Quorum owner signatures must not be empty');
+    }
+    return (0, viem_1.concat)(['0x00', input.signatures]);
+}
+function encodeQuorumMerkleSignature(input) {
+    if (input.operation.proof.length < 1 || input.operation.proof.length > 32) {
+        throw new Error('Quorum Merkle proof length must be between 1 and 32');
+    }
+    if (input.signatures === '0x') {
+        throw new Error('Quorum Merkle signatures must not be empty');
+    }
+    return (0, viem_1.concat)([
+        (0, viem_1.toHex)(input.operation.proof.length, { size: 1 }),
+        input.operation.root,
+        ...input.operation.proof,
+        input.signatures,
+    ]);
+}
+function getQuorumMockSignature(config) {
+    const owners = resolveOwners(config);
+    validateQuorumConfig(owners, config.thresholdWeight);
+    return encodeQuorumErc1271Signature({
+        signatures: encodeQuorumEntries(owners
+            .map(({ signer }) => ({ signer, signature: QUORUM_MOCK_SIGNATURE }))
+            .sort((left, right) => (0, ordering_1.compareHexValues)(left.signer, right.signer))),
+    });
+}
+function getQuorumConfigOwners(config) {
+    return resolveOwners(config);
+}
+function encodeQuorumEntries(entries) {
+    if (entries.length === 0) {
+        throw new Error('Quorum signature must not be empty');
+    }
+    let previous;
+    const packed = entries.map(({ signer, signature }) => {
+        if (previous && (0, ordering_1.compareHexValues)(previous, signer) >= 0) {
+            throw new Error('Quorum signer addresses must be strictly sorted and unique');
+        }
+        previous = signer;
+        const signatureLength = (0, viem_1.size)(signature);
+        if (signatureLength > MAX_SIGNATURE_LENGTH) {
+            throw new Error(`Quorum inner signature exceeds ${MAX_SIGNATURE_LENGTH} bytes`);
+        }
+        return (0, viem_1.concat)([signer, (0, viem_1.toHex)(signatureLength, { size: 2 }), signature]);
+    });
+    return (0, viem_1.concat)(packed);
+}
+function resolveOwners(config) {
+    return config.owners.map(({ account, weight }) => ({
+        ownerId: account.address.toLowerCase(),
+        signer: account.address,
+        weight,
+    }));
+}
+function validateQuorumConfig(owners, thresholdWeight) {
+    if (owners.length < 1 || owners.length > MAX_QUORUM_OWNERS) {
+        throw new Error(`Quorum owners length must be between 1 and ${MAX_QUORUM_OWNERS}`);
+    }
+    const seen = new Set();
+    let totalWeight = 0n;
+    for (const [index, owner] of owners.entries()) {
+        const signer = owner.signer.toLowerCase();
+        if (signer === viem_1.zeroAddress) {
+            throw new Error(`Quorum owner ${index} cannot be the zero address`);
+        }
+        if (seen.has(signer)) {
+            throw new Error(`Duplicate quorum owner ${owner.signer}`);
+        }
+        seen.add(signer);
+        if (owner.weight <= 0n || owner.weight > MAX_UINT96) {
+            throw new Error(`Quorum owner ${owner.signer} weight must fit uint96 and be non-zero`);
+        }
+        totalWeight += owner.weight;
+    }
+    if (thresholdWeight <= 0n || thresholdWeight > totalWeight) {
+        throw new Error(`Quorum threshold weight must be between 1 and total owner weight ${totalWeight}`);
+    }
+}
+function hashQuorumMerklePair(left, right) {
+    return (0, ordering_1.compareHexValues)(left, right) < 0
+        ? (0, viem_1.keccak256)((0, viem_1.concat)([left, right]))
+        : (0, viem_1.keccak256)((0, viem_1.concat)([right, left]));
+}

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

@@ -0,0 +1,3 @@
+import type { Abi } from 'viem';
+export declare function namedParamOffsets(abi: Abi, functionName: string): Record<string, bigint>;
+//# sourceMappingURL=abi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../../../../../../modules/validators/smart-sessions/swap/abi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAA6B,MAAM,MAAM,CAAA;AAuD1D,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,GAAG,EACR,YAAY,EAAE,MAAM,GACnB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAcxB"}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.namedParamOffsets = namedParamOffsets;
+function isStaticAbiType(type) {
+    if (type === 'address' || type === 'bool')
+        return true;
+    if (/^u?int\d*$/.test(type))
+        return true;
+    if (/^bytes\d+$/.test(type)) {
+        const size = Number.parseInt(type.slice(5), 10);
+        return size >= 1 && size <= 32;
+    }
+    return false;
+}
+const ARRAY_SUFFIX = /^(.*)\[(\d*)\]$/;
+function withType(param, type) {
+    return { ...param, type };
+}
+function tupleComponents(param) {
+    return param.components ?? [];
+}
+function isDynamicAbiParam(param) {
+    if (param.type === 'bytes' || param.type === 'string')
+        return true;
+    const array = ARRAY_SUFFIX.exec(param.type);
+    if (array) {
+        const [, elementType, length] = array;
+        if (length === '')
+            return true;
+        return isDynamicAbiParam(withType(param, elementType));
+    }
+    if (param.type === 'tuple') {
+        return tupleComponents(param).some(isDynamicAbiParam);
+    }
+    return false;
+}
+function headSize(param) {
+    if (isDynamicAbiParam(param))
+        return 32;
+    const array = ARRAY_SUFFIX.exec(param.type);
+    if (array) {
+        const [, elementType, length] = array;
+        return Number.parseInt(length, 10) * headSize(withType(param, elementType));
+    }
+    if (param.type === 'tuple') {
+        return tupleComponents(param).reduce((sum, item) => sum + headSize(item), 0);
+    }
+    return 32;
+}
+function headOffset(inputs, index) {
+    let offset = 0;
+    for (let i = 0; i < index; i++)
+        offset += headSize(inputs[i]);
+    return BigInt(offset);
+}
+function namedParamOffsets(abi, functionName) {
+    const entry = abi.find((item) => item.type === 'function' && item.name === functionName);
+    if (!entry)
+        throw new Error(`Function "${functionName}" not found in ABI`);
+    const offsets = {};
+    entry.inputs.forEach((param, index) => {
+        if (param.name && isStaticAbiType(param.type)) {
+            offsets[param.name] = headOffset(entry.inputs, index);
+        }
+    });
+    return offsets;
+}

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';
+import type { VenueContext, VenueScoping } from './rules';
+/**
+ * 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;AACjE,OAAO,KAAK,EACV,SAAS,EAEV,MAAM,mBAAmB,CAAA;AAE1B,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,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FYND_SWAP_SELECTOR = exports.tychoRouterAbi = exports.FYND_ROUTERS = exports.FYND_CHAIN_IDS = void 0;
+exports.fynd = fynd;
+exports.scopeFynd = scopeFynd;
+const viem_1 = require("viem");
+const abi_1 = require("./abi");
+const rules_1 = require("./rules");
+/**
+ * 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. */
+exports.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.
+ */
+exports.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.
+ */
+exports.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' }],
+    },
+];
+exports.FYND_SWAP_SELECTOR = (0, viem_1.toFunctionSelector)(exports.tychoRouterAbi[0]);
+/** Head offsets derived from the ABI — never hardcoded. */
+const OFFSETS = (0, abi_1.namedParamOffsets)(exports.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.
+ */
+function fynd(options = {}) {
+    return {
+        id: 'fynd',
+        ...(options.maxSpend !== undefined ? { maxSpend: options.maxSpend } : {}),
+    };
+}
+function scopeFynd(ctx) {
+    const router = exports.FYND_ROUTERS[ctx.chainId];
+    if (router === undefined) {
+        throw new Error(`fynd is not available on chain ${ctx.chainId}. ` +
+            `Supported: ${exports.FYND_CHAIN_IDS.join(', ')}.`);
+    }
+    const rules = [
+        (0, rules_1.pin)(OFFSETS.tokenIn, ctx.sellToken),
+        (0, rules_1.pin)(OFFSETS.tokenOut, ctx.buyToken),
+        (0, rules_1.pin)(OFFSETS.receiver, ctx.recipient),
+    ];
+    if (ctx.cap !== undefined) {
+        rules.push((0, rules_1.cumulativeCap)(OFFSETS.amountIn, ctx.cap));
+    }
+    return {
+        approveSpenders: [router],
+        actions: [(0, rules_1.swapAction)(router, exports.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';
+import type { VenueContext, VenueScoping } from './rules';
+/**
+ * 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;AAC3E,OAAO,KAAK,EACV,mBAAmB,EACnB,yBAAyB,EAE1B,MAAM,mBAAmB,CAAA;AAG1B,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"}