@rhinestone/sdk 1.5.1 → 2.0.0-beta.1

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

@@ -1,19 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.packSignature = exports.isSessionEnabled = exports.buildMockSignature = exports.getMockSignature = exports.getPermissionId = exports.getEnableSessionCall = exports.getSmartSessionValidator = exports.getOwnerValidator = exports.DUMMY_PRECLAIMOP_SELECTOR = exports.DUMMY_PRECLAIMOP_TARGET = exports.SMART_SESSION_EMISSARY_ADDRESS = exports.MULTI_FACTOR_VALIDATOR_ADDRESS = exports.WEBAUTHN_VALIDATOR_ADDRESS = exports.OWNABLE_VALIDATOR_ADDRESS = void 0;
-const core_1 = require("./core");
-Object.defineProperty(exports, "getMockSignature", { enumerable: true, get: function () { return core_1.getMockSignature; } });
-Object.defineProperty(exports, "getOwnerValidator", { enumerable: true, get: function () { return core_1.getOwnerValidator; } });
-Object.defineProperty(exports, "MULTI_FACTOR_VALIDATOR_ADDRESS", { enumerable: true, get: function () { return core_1.MULTI_FACTOR_VALIDATOR_ADDRESS; } });
-Object.defineProperty(exports, "OWNABLE_VALIDATOR_ADDRESS", { enumerable: true, get: function () { return core_1.OWNABLE_VALIDATOR_ADDRESS; } });
-Object.defineProperty(exports, "SMART_SESSION_EMISSARY_ADDRESS", { enumerable: true, get: function () { return core_1.SMART_SESSION_EMISSARY_ADDRESS; } });
-Object.defineProperty(exports, "WEBAUTHN_VALIDATOR_ADDRESS", { enumerable: true, get: function () { return core_1.WEBAUTHN_VALIDATOR_ADDRESS; } });
-const smart_sessions_1 = require("./smart-sessions");
-Object.defineProperty(exports, "buildMockSignature", { enumerable: true, get: function () { return smart_sessions_1.buildMockSignature; } });
-Object.defineProperty(exports, "DUMMY_PRECLAIMOP_SELECTOR", { enumerable: true, get: function () { return smart_sessions_1.DUMMY_PRECLAIMOP_SELECTOR; } });
-Object.defineProperty(exports, "DUMMY_PRECLAIMOP_TARGET", { enumerable: true, get: function () { return smart_sessions_1.DUMMY_PRECLAIMOP_TARGET; } });
-Object.defineProperty(exports, "getEnableSessionCall", { enumerable: true, get: function () { return smart_sessions_1.getEnableSessionCall; } });
-Object.defineProperty(exports, "getPermissionId", { enumerable: true, get: function () { return smart_sessions_1.getPermissionId; } });
-Object.defineProperty(exports, "getSmartSessionValidator", { enumerable: true, get: function () { return smart_sessions_1.getSmartSessionValidator; } });
-Object.defineProperty(exports, "isSessionEnabled", { enumerable: true, get: function () { return smart_sessions_1.isSessionEnabled; } });
-Object.defineProperty(exports, "packSignature", { enumerable: true, get: function () { return smart_sessions_1.packSignature; } });
+import { getMockSignature, getOwnerValidator, MULTI_FACTOR_VALIDATOR_ADDRESS, OWNABLE_VALIDATOR_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS, } from './core.js';
+import { buildMockSignature, DUMMY_PRECLAIMOP_SELECTOR, DUMMY_PRECLAIMOP_TARGET, getEnableSessionCall, getPermissionId, getSmartSessionValidator, isSessionEnabled, packSignature, } from './smart-sessions.js';
+export { OWNABLE_VALIDATOR_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS, MULTI_FACTOR_VALIDATOR_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, DUMMY_PRECLAIMOP_TARGET, DUMMY_PRECLAIMOP_SELECTOR, getOwnerValidator, getSmartSessionValidator, getEnableSessionCall, getPermissionId, getMockSignature, buildMockSignature, isSessionEnabled, packSignature, };

package/dist/src/modules/validators/policies/claim/permit2.d.ts

@@ -1,5 +1,5 @@
 import { type Address, type Hex } from 'viem';
-import type { Permit2ClaimPolicy } from '../../../../types';
+import type { Permit2ClaimPolicy } from '../../../../types.js';
 /** Typed representation of the Permit2 message fields used for calldata building */
 export interface Permit2ClaimMessage {
     permitted: readonly {

package/dist/src/modules/validators/policies/claim/permit2.js

@@ -1,10 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PERMIT2_CLAIM_POLICY_ADDRESS = void 0;
-exports.buildPermit2ClaimPolicyCalldata = buildPermit2ClaimPolicyCalldata;
-exports.encodePermit2ClaimPolicyInitData = encodePermit2ClaimPolicyInitData;
-const viem_1 = require("viem");
-const types_1 = require("./types");
+import { concat, encodeAbiParameters, encodePacked, hashStruct, keccak256, maxUint256, toHex, } from 'viem';
+import { ANY_ADDRESS, FIELD_ARBITER, FIELD_EXPIRY, FIELD_FILL_EXPIRY, FIELD_RECIPIENT, FIELD_RECIPIENT_IS_SPONSOR, FIELD_TOKEN_IN, FIELD_TOKEN_OUT, MODE_CHECK_STORAGE, } from './types.js';
 // EIP-712 type definitions for Permit2/Mandate struct encoding.
 // Note: the token-out struct is named 'Token' in the Solidity contract (matching the
 // signed Permit2 message types in execution/permit2.ts).
@@ -42,31 +37,31 @@ const PERMIT2_TYPES = {
 };
 // --- EIP-712 hash helpers ---
 function hashArray(hashes) {
-    return (0, viem_1.keccak256)(hashes.length > 0 ? (0, viem_1.concat)(hashes) : '0x');
+    return keccak256(hashes.length > 0 ? concat(hashes) : '0x');
 }
 function hashTokenPermissionsArray(permitted) {
-    return hashArray(permitted.map(({ token, amount }) => (0, viem_1.hashStruct)({
+    return hashArray(permitted.map(({ token, amount }) => hashStruct({
         primaryType: 'TokenPermissions',
         types: PERMIT2_TYPES,
         data: { token, amount },
     })));
 }
 function hashTokenOutArray(tokenOut) {
-    return hashArray(tokenOut.map(({ token, amount }) => (0, viem_1.hashStruct)({
+    return hashArray(tokenOut.map(({ token, amount }) => hashStruct({
         primaryType: 'Token',
         types: PERMIT2_TYPES,
         data: { token, amount },
     })));
 }
 function hashOpStruct(op) {
-    return (0, viem_1.hashStruct)({
+    return hashStruct({
         primaryType: 'Op',
         types: PERMIT2_TYPES,
         data: { vt: op.vt, ops: Array.from(op.ops) },
     });
 }
 function hashMandateStruct(mandate) {
-    return (0, viem_1.hashStruct)({
+    return hashStruct({
         primaryType: 'Mandate',
         types: PERMIT2_TYPES,
         data: {
@@ -89,7 +84,7 @@ function hashMandateStruct(mandate) {
 // --- Token array encoding helpers ---
 /** Encodes a token+amount pair as [token_as_uint256:32][amount:32] (64 bytes) */
 function encodeTokenEntry(token, amount) {
-    return (0, viem_1.encodeAbiParameters)([{ type: 'address' }, { type: 'uint256' }], [token, amount]);
+    return encodeAbiParameters([{ type: 'address' }, { type: 'uint256' }], [token, amount]);
 }
 /**
  * Builds the policySpecificData calldata for a Permit2ClaimPolicy EIP-1271 check.
@@ -101,7 +96,7 @@ function encodeTokenEntry(token, amount) {
  *            else — pre-computed mandateHash [32]
  *
  */
-function buildPermit2ClaimPolicyCalldata(policy, message) {
+export function buildPermit2ClaimPolicyCalldata(policy, message) {
     const tokenInEnabled = !!policy.tokensIn?.length;
     const recipientEnabled = !!policy.recipients?.length;
     const fillExpiryEnabled = !!policy.fillExpiryBounds?.length;
@@ -114,13 +109,13 @@ function buildPermit2ClaimPolicyCalldata(policy, message) {
         recipientIsSponsorEnabled;
     const parts = [];
     // Header: [spender:20][nonce:32][deadline:32]  (spender == arbiter in Permit2 context)
-    parts.push((0, viem_1.encodePacked)(['address', 'uint256', 'uint256'], [message.spender, message.nonce, message.deadline]));
+    parts.push(encodePacked(['address', 'uint256', 'uint256'], [message.spender, message.nonce, message.deadline]));
     // TokenIn section
     if (tokenInEnabled) {
         // Expanded: [count:1][token_as_uint256:32][amount:32]...
         if (message.permitted.length > 255)
             throw new Error('permitted array exceeds max length of 255');
-        parts.push((0, viem_1.toHex)(message.permitted.length, { size: 1 }));
+        parts.push(toHex(message.permitted.length, { size: 1 }));
         for (const { token, amount } of message.permitted) {
             parts.push(encodeTokenEntry(token, amount));
         }
@@ -137,12 +132,12 @@ function buildPermit2ClaimPolicyCalldata(policy, message) {
         // Expanded mandate: target fields + minGas + ops hashes + q
         const target = message.mandate.target;
         // Target: [recipient:20][targetChain:32][fillExpiry:32]
-        parts.push((0, viem_1.encodePacked)(['address', 'uint256', 'uint256'], [target.recipient, target.targetChain, target.fillExpiry]));
+        parts.push(encodePacked(['address', 'uint256', 'uint256'], [target.recipient, target.targetChain, target.fillExpiry]));
         // TokenOut (inside target)
         if (tokenOutEnabled) {
             if (target.tokenOut.length > 255)
                 throw new Error('tokenOut array exceeds max length of 255');
-            parts.push((0, viem_1.toHex)(target.tokenOut.length, { size: 1 }));
+            parts.push(toHex(target.tokenOut.length, { size: 1 }));
             for (const { token, amount } of target.tokenOut) {
                 parts.push(encodeTokenEntry(token, amount));
             }
@@ -151,65 +146,65 @@ function buildPermit2ClaimPolicyCalldata(policy, message) {
             parts.push(hashTokenOutArray(target.tokenOut));
         }
         // minGas: uint128 = 16 bytes
-        parts.push((0, viem_1.toHex)(message.mandate.minGas, { size: 16 }));
+        parts.push(toHex(message.mandate.minGas, { size: 16 }));
         // originOpsHash and destOpsHash: always 32-byte hashes (we don't support ops checks)
         parts.push(hashOpStruct(message.mandate.originOps));
         parts.push(hashOpStruct(message.mandate.destOps));
         // qualificationHash: q is already keccak256(qualifier.encodedVal)
         parts.push(message.mandate.q);
     }
-    return (0, viem_1.concat)(parts);
+    return concat(parts);
 }
-exports.PERMIT2_CLAIM_POLICY_ADDRESS = '0x62E3588C6d861C9f986E82EC3757434EDF16ce91';
-function encodePermit2ClaimPolicyInitData(policy) {
+export const PERMIT2_CLAIM_POLICY_ADDRESS = '0x62E3588C6d861C9f986E82EC3757434EDF16ce91';
+export function encodePermit2ClaimPolicyInitData(policy) {
     let modeConfig = 0;
     const setMode = (fieldId) => {
-        modeConfig |= types_1.MODE_CHECK_STORAGE << (fieldId * 2);
+        modeConfig |= MODE_CHECK_STORAGE << (fieldId * 2);
     };
     if (policy.arbiters?.length)
-        setMode(types_1.FIELD_ARBITER);
+        setMode(FIELD_ARBITER);
     if (policy.expiryBounds)
-        setMode(types_1.FIELD_EXPIRY);
+        setMode(FIELD_EXPIRY);
     if (policy.tokensIn?.length)
-        setMode(types_1.FIELD_TOKEN_IN);
+        setMode(FIELD_TOKEN_IN);
     if (policy.recipients?.length)
-        setMode(types_1.FIELD_RECIPIENT);
+        setMode(FIELD_RECIPIENT);
     if (policy.fillExpiryBounds?.length)
-        setMode(types_1.FIELD_FILL_EXPIRY);
+        setMode(FIELD_FILL_EXPIRY);
     if (policy.tokensOut?.length)
-        setMode(types_1.FIELD_TOKEN_OUT);
+        setMode(FIELD_TOKEN_OUT);
     if (policy.recipientIsSponsor)
-        setMode(types_1.FIELD_RECIPIENT_IS_SPONSOR);
-    const parts = [(0, viem_1.toHex)(modeConfig, { size: 4 })];
+        setMode(FIELD_RECIPIENT_IS_SPONSOR);
+    const parts = [toHex(modeConfig, { size: 4 })];
     // Arbiter: [count: 1][address: 20] each
     if (policy.arbiters?.length) {
         if (policy.arbiters.length > 255)
             throw new Error('arbiters array exceeds max length of 255');
-        parts.push((0, viem_1.encodePacked)(['uint8', ...policy.arbiters.map(() => 'address')], [policy.arbiters.length, ...policy.arbiters]));
+        parts.push(encodePacked(['uint8', ...policy.arbiters.map(() => 'address')], [policy.arbiters.length, ...policy.arbiters]));
     }
     // Expiry: [maxExpiry: 16][minExpiry: 16] packed into uint256
     if (policy.expiryBounds) {
         const mask128 = (1n << 128n) - 1n;
         const min = (policy.expiryBounds.min ?? 0n) & mask128;
-        const max = (policy.expiryBounds.max ?? viem_1.maxUint256) & mask128;
-        parts.push((0, viem_1.toHex)((min & mask128) | (max << 128n), { size: 32 }));
+        const max = (policy.expiryBounds.max ?? maxUint256) & mask128;
+        parts.push(toHex((min & mask128) | (max << 128n), { size: 32 }));
     }
     // TokenIn: [count: 1][chainId: 32][token: 20] each
     if (policy.tokensIn?.length) {
         if (policy.tokensIn.length > 255)
             throw new Error('tokensIn array exceeds max length of 255');
-        parts.push((0, viem_1.toHex)(policy.tokensIn.length, { size: 1 }));
+        parts.push(toHex(policy.tokensIn.length, { size: 1 }));
         for (const { chainId, token } of policy.tokensIn) {
-            parts.push((0, viem_1.encodePacked)(['uint256', 'address'], [BigInt(chainId), token]));
+            parts.push(encodePacked(['uint256', 'address'], [BigInt(chainId), token]));
         }
     }
     // Recipient: [count: 1][chainId: 32][recipient: 20] each
     if (policy.recipients?.length) {
         if (policy.recipients.length > 255)
             throw new Error('recipients array exceeds max length of 255');
-        parts.push((0, viem_1.toHex)(policy.recipients.length, { size: 1 }));
+        parts.push(toHex(policy.recipients.length, { size: 1 }));
         for (const { chainId, recipient } of policy.recipients) {
-            parts.push((0, viem_1.encodePacked)(['uint256', 'address'], [BigInt(chainId), recipient === 'any' ? types_1.ANY_ADDRESS : recipient]));
+            parts.push(encodePacked(['uint256', 'address'], [BigInt(chainId), recipient === 'any' ? ANY_ADDRESS : recipient]));
         }
     }
     // FillExpiry: [count: 1][chainId: 32][max<<128|min packed into uint256] each
@@ -217,23 +212,23 @@ function encodePermit2ClaimPolicyInitData(policy) {
         if (policy.fillExpiryBounds.length > 255)
             throw new Error('fillExpiryBounds array exceeds max length of 255');
         const mask128 = (1n << 128n) - 1n;
-        parts.push((0, viem_1.toHex)(policy.fillExpiryBounds.length, { size: 1 }));
+        parts.push(toHex(policy.fillExpiryBounds.length, { size: 1 }));
         for (const { chainId, min: fMin, max: fMax } of policy.fillExpiryBounds) {
             const minVal = (fMin ?? 0n) & mask128;
-            const maxVal = (fMax ?? viem_1.maxUint256) & mask128;
+            const maxVal = (fMax ?? maxUint256) & mask128;
             const packed = minVal | (maxVal << 128n);
-            parts.push((0, viem_1.encodePacked)(['uint256', 'uint256'], [BigInt(chainId), packed]));
+            parts.push(encodePacked(['uint256', 'uint256'], [BigInt(chainId), packed]));
         }
     }
     // TokenOut: [count: 1][chainId: 32][token: 20] each
     if (policy.tokensOut?.length) {
         if (policy.tokensOut.length > 255)
             throw new Error('tokensOut array exceeds max length of 255');
-        parts.push((0, viem_1.toHex)(policy.tokensOut.length, { size: 1 }));
+        parts.push(toHex(policy.tokensOut.length, { size: 1 }));
         for (const { chainId, token } of policy.tokensOut) {
-            parts.push((0, viem_1.encodePacked)(['uint256', 'address'], [BigInt(chainId), token]));
+            parts.push(encodePacked(['uint256', 'address'], [BigInt(chainId), token]));
         }
     }
     // RecipientIsSponsor has no data payload — mode bit alone enables it
-    return (0, viem_1.concat)(parts);
+    return concat(parts);
 }

package/dist/src/modules/validators/policies/claim/types.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ANY_ADDRESS = exports.MODE_CHECK_STORAGE = exports.FIELD_RECIPIENT_IS_SPONSOR = exports.FIELD_DEST_OPS = exports.FIELD_ORIGIN_OPS = exports.FIELD_TOKEN_OUT = exports.FIELD_FILL_EXPIRY = exports.FIELD_RECIPIENT = exports.FIELD_TOKEN_IN = exports.FIELD_EXPIRY = exports.FIELD_ARBITER = void 0;
 // Field IDs matching BaseDataTypes.sol
-exports.FIELD_ARBITER = 0;
-exports.FIELD_EXPIRY = 1;
-exports.FIELD_TOKEN_IN = 2;
-exports.FIELD_RECIPIENT = 3;
-exports.FIELD_FILL_EXPIRY = 4;
-exports.FIELD_TOKEN_OUT = 5;
-exports.FIELD_ORIGIN_OPS = 6;
-exports.FIELD_DEST_OPS = 7;
+export const FIELD_ARBITER = 0;
+export const FIELD_EXPIRY = 1;
+export const FIELD_TOKEN_IN = 2;
+export const FIELD_RECIPIENT = 3;
+export const FIELD_FILL_EXPIRY = 4;
+export const FIELD_TOKEN_OUT = 5;
+export const FIELD_ORIGIN_OPS = 6;
+export const FIELD_DEST_OPS = 7;
 // Field 8 is reserved in BaseDataTypes.sol
-exports.FIELD_RECIPIENT_IS_SPONSOR = 9;
+export const FIELD_RECIPIENT_IS_SPONSOR = 9;
 // Mode values
-exports.MODE_CHECK_STORAGE = 1;
+export const MODE_CHECK_STORAGE = 1;
 // Sentinel: allows any recipient address
-exports.ANY_ADDRESS = '0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF';
+export const ANY_ADDRESS = '0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF';

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

@@ -1,7 +1,7 @@
 import { type Address, type Hex, type TypedDataDefinition } from 'viem';
-import type { Policy, ProviderConfig, RhinestoneAccountConfig, RhinestoneConfig, Session, SessionEnableData } from '../../types';
-import { type Module } from '../common';
-import { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV } from './core';
+import type { Policy, ProviderConfig, RhinestoneAccountConfig, RhinestoneConfig, Session, SessionEnableData } from '../../types.js';
+import { type Module } from '../common.js';
+import { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV } from './core.js';
 interface SessionData {
     sessionValidator: Address;
     sessionValidatorInitData: Hex;