@rhinestone/sdk 0.7.9 → 0.8.0

package/dist/src/modules/omni-account.d.ts

@@ -1,9 +0,0 @@
-import type { Address } from 'viem';
-declare const OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS: Address;
-declare const RHINESTONE_MODULE_REGISTRY_ADDRESS: Address;
-declare const RHINESTONE_ATTESTER_ADDRESS: Address;
-declare const HOOK_ADDRESS: Address;
-declare const TARGET_MODULE_ADDRESS: Address;
-declare const SAME_CHAIN_MODULE_ADDRESS: Address;
-export { OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS, RHINESTONE_MODULE_REGISTRY_ADDRESS, RHINESTONE_ATTESTER_ADDRESS, HOOK_ADDRESS, TARGET_MODULE_ADDRESS, SAME_CHAIN_MODULE_ADDRESS, };
-//# sourceMappingURL=omni-account.d.ts.map

package/dist/src/modules/omni-account.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"omni-account.d.ts","sourceRoot":"","sources":["../../../modules/omni-account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,QAAA,MAAM,kCAAkC,EAAE,OACI,CAAA;AAE9C,QAAA,MAAM,kCAAkC,EAAE,OACI,CAAA;AAC9C,QAAA,MAAM,2BAA2B,EAAE,OACW,CAAA;AAE9C,QAAA,MAAM,YAAY,EAAE,OAAsD,CAAA;AAC1E,QAAA,MAAM,qBAAqB,EAAE,OACiB,CAAA;AAC9C,QAAA,MAAM,yBAAyB,EAAE,OACa,CAAA;AAE9C,OAAO,EACL,kCAAkC,EAClC,kCAAkC,EAClC,2BAA2B,EAC3B,YAAY,EACZ,qBAAqB,EACrB,yBAAyB,GAC1B,CAAA"}

package/dist/src/modules/omni-account.js

@@ -1,7 +0,0 @@
-const OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS = '0x6D0515e8E499468DCe9583626f0cA15b887f9d03';
-const RHINESTONE_MODULE_REGISTRY_ADDRESS = '0x000000000069e2a187aeffb852bf3ccdc95151b2';
-const RHINESTONE_ATTESTER_ADDRESS = '0x000000333034E9f539ce08819E12c1b8Cb29084d';
-const HOOK_ADDRESS = '0x0000000000f6Ed8Be424d673c63eeFF8b9267420';
-const TARGET_MODULE_ADDRESS = '0x0000000000E5a37279A001301A837a91b5de1D5E';
-const SAME_CHAIN_MODULE_ADDRESS = '0x000000000043ff16d5776c7F0f65Ec485C17Ca04';
-export { OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS, RHINESTONE_MODULE_REGISTRY_ADDRESS, RHINESTONE_ATTESTER_ADDRESS, HOOK_ADDRESS, TARGET_MODULE_ADDRESS, SAME_CHAIN_MODULE_ADDRESS, };

package/dist/src/modules/validators/core.d.ts

@@ -1,23 +0,0 @@
-import { type Address, type Hex } from 'viem';
-import type { OwnerSet, RhinestoneAccountConfig } from '../../types';
-import { type Module } from '../common';
-interface PublicKey {
-    prefix?: number | undefined;
-    x: bigint;
-    y: bigint;
-}
-interface WebauthnCredential {
-    pubKey: PublicKey | Hex | Uint8Array;
-    authenticatorId: string;
-    hook?: Address;
-}
-declare function getOwnerValidator(config: RhinestoneAccountConfig): Module;
-declare function getMockSignature(ownerSet: OwnerSet): Hex;
-declare function getValidator(owners: OwnerSet): Module;
-declare function getOwnableValidator({ threshold, owners, }: {
-    threshold: number;
-    owners: Address[];
-}): Module;
-declare function getWebAuthnValidator(webAuthnCredential: WebauthnCredential): Module;
-export { getOwnerValidator, getValidator, getOwnableValidator, getWebAuthnValidator, getMockSignature, };
-//# sourceMappingURL=core.d.ts.map

package/dist/src/modules/validators/core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../modules/validators/core.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAIZ,KAAK,GAAG,EAIT,MAAM,MAAM,CAAA;AAEb,OAAO,KAAK,EAAE,QAAQ,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAEpE,OAAO,EAA4B,KAAK,MAAM,EAAE,MAAM,WAAW,CAAA;AAEjE,UAAU,SAAS;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,UAAU,kBAAkB;IAC1B,MAAM,EAAE,SAAS,GAAG,GAAG,GAAG,UAAU,CAAA;IACpC,eAAe,EAAE,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AAYD,iBAAS,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,UAEzD;AAED,iBAAS,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,GAAG,CAUjD;AAED,iBAAS,YAAY,CAAC,MAAM,EAAE,QAAQ,UAarC;AAED,iBAAS,mBAAmB,CAAC,EAC3B,SAAS,EACT,MAAM,GACP,EAAE;IACD,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,OAAO,EAAE,CAAA;CAClB,GAAG,MAAM,CAiBT;AAED,iBAAS,oBAAoB,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,MAAM,CAwD5E;AAeD,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,GACjB,CAAA"}

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

@@ -1,112 +0,0 @@
-import { bytesToHex, concat, encodeAbiParameters, hexToBytes, keccak256, toHex, } from 'viem';
-import { MODULE_TYPE_ID_VALIDATOR } from '../common.js';
-const OWNABLE_VALIDATOR_ADDRESS = '0x2483DA3A338895199E5e538530213157e931Bf06';
-const WEBAUTHN_VALIDATOR_ADDRESS = '0x2f167e55d42584f65e2e30a748f41ee75a311414';
-const ECDSA_MOCK_SIGNATURE = '0x81d4b4981670cb18f99f0b4a66446df1bf5b204d24cfcb659bf38ba27a4359b5711649ec2423c5e1247245eba2964679b6a1dbb85c992ae40b9b00c6935b02ff1b';
-const WEBAUTHN_MOCK_SIGNATURE = '0x00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000001635bc6d0f68ff895cae8a288ecf7542a6a9cd555df784b73e1e2ea7e9104b1db15e9015d280cb19527881c625fee43fd3a405d5b0d199a8c8e6589a7381209e40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002549960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d97631d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f47b2274797065223a22776562617574686e2e676574222c226368616c6c656e6765223a22746278584e465339585f3442797231634d77714b724947422d5f3330613051685a36793775634d30424f45222c226f726967696e223a22687474703a2f2f6c6f63616c686f73743a33303030222c2263726f73734f726967696e223a66616c73652c20226f746865725f6b6579735f63616e5f62655f61646465645f68657265223a22646f206e6f7420636f6d7061726520636c69656e74446174614a534f4e20616761696e737420612074656d706c6174652e205365652068747470733a2f2f676f6f2e676c2f796162506578227d000000000000000000000000';
-function getOwnerValidator(config) {
-    return getValidator(config.owners);
-}
-function getMockSignature(ownerSet) {
-    switch (ownerSet.type) {
-        case 'ecdsa': {
-            const owners = ownerSet.accounts.map((account) => account.address);
-            const signatures = owners.map(() => ECDSA_MOCK_SIGNATURE);
-            return concat(signatures);
-        }
-        case 'passkey':
-            return WEBAUTHN_MOCK_SIGNATURE;
-    }
-}
-function getValidator(owners) {
-    switch (owners.type) {
-        case 'ecdsa':
-            return getOwnableValidator({
-                threshold: owners.threshold ?? 1,
-                owners: owners.accounts.map((account) => account.address),
-            });
-        case 'passkey':
-            return getWebAuthnValidator({
-                pubKey: owners.account.publicKey,
-                authenticatorId: owners.account.id,
-            });
-    }
-}
-function getOwnableValidator({ threshold, owners, }) {
-    return {
-        address: OWNABLE_VALIDATOR_ADDRESS,
-        initData: encodeAbiParameters([
-            { name: 'threshold', type: 'uint256' },
-            { name: 'owners', type: 'address[]' },
-        ], [
-            BigInt(threshold),
-            owners.map((owner) => owner.toLowerCase()).sort(),
-        ]),
-        deInitData: '0x',
-        additionalContext: '0x',
-        type: MODULE_TYPE_ID_VALIDATOR,
-    };
-}
-function getWebAuthnValidator(webAuthnCredential) {
-    let pubKeyX;
-    let pubKeyY;
-    // Distinguish between PublicKey and Hex / byte encoded public key
-    if (typeof webAuthnCredential.pubKey === 'string' ||
-        webAuthnCredential.pubKey instanceof Uint8Array) {
-        // It's a P256Credential
-        const { x, y, prefix } = parsePublicKey(webAuthnCredential.pubKey);
-        pubKeyX = x;
-        pubKeyY = y;
-        if (prefix && prefix !== 4) {
-            throw new Error('Only uncompressed public keys are supported');
-        }
-    }
-    else {
-        // It's already a PublicKey
-        pubKeyX = webAuthnCredential.pubKey.x;
-        pubKeyY = webAuthnCredential.pubKey.y;
-    }
-    return {
-        address: WEBAUTHN_VALIDATOR_ADDRESS,
-        initData: encodeAbiParameters([
-            {
-                components: [
-                    {
-                        name: 'pubKeyX',
-                        type: 'uint256',
-                    },
-                    {
-                        name: 'pubKeyY',
-                        type: 'uint256',
-                    },
-                ],
-                type: 'tuple',
-            },
-            {
-                type: 'bytes32',
-                name: 'authenticatorIdHash',
-            },
-        ], [
-            {
-                pubKeyX,
-                pubKeyY,
-            },
-            keccak256(toHex(webAuthnCredential.authenticatorId)),
-        ]),
-        deInitData: '0x',
-        additionalContext: '0x',
-        type: MODULE_TYPE_ID_VALIDATOR,
-    };
-}
-function parsePublicKey(publicKey) {
-    const bytes = typeof publicKey === 'string' ? hexToBytes(publicKey) : publicKey;
-    const offset = bytes.length === 65 ? 1 : 0;
-    const x = bytes.slice(offset, 32 + offset);
-    const y = bytes.slice(32 + offset, 64 + offset);
-    return {
-        prefix: bytes.length === 65 ? bytes[0] : undefined,
-        x: BigInt(bytesToHex(x)),
-        y: BigInt(bytesToHex(y)),
-    };
-}
-export { getOwnerValidator, getValidator, getOwnableValidator, getWebAuthnValidator, getMockSignature, };

package/dist/src/modules/validators/index.d.ts

@@ -1,4 +0,0 @@
-import { getMockSignature, getOwnerValidator } from './core';
-import { encodeSmartSessionSignature, getAccountEIP712Domain, getEnableSessionCall, getPermissionId, getSessionAllowedERC7739Content, getSmartSessionValidator, isSessionEnabled, SMART_SESSION_MODE_ENABLE, SMART_SESSION_MODE_USE, SMART_SESSIONS_VALIDATOR_ADDRESS } from './smart-sessions';
-export { SMART_SESSION_MODE_USE, SMART_SESSION_MODE_ENABLE, SMART_SESSIONS_VALIDATOR_ADDRESS, getOwnerValidator, getSmartSessionValidator, getEnableSessionCall, encodeSmartSessionSignature, getPermissionId, getMockSignature, getAccountEIP712Domain, isSessionEnabled, getSessionAllowedERC7739Content, };
-//# sourceMappingURL=index.d.ts.map

package/dist/src/modules/validators/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../modules/validators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAC5D,OAAO,EACL,2BAA2B,EAC3B,sBAAsB,EACtB,oBAAoB,EACpB,eAAe,EACf,+BAA+B,EAC/B,wBAAwB,EACxB,gBAAgB,EAChB,yBAAyB,EACzB,sBAAsB,EACtB,gCAAgC,EACjC,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,gCAAgC,EAChC,iBAAiB,EACjB,wBAAwB,EACxB,oBAAoB,EACpB,2BAA2B,EAC3B,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,EAChB,+BAA+B,GAChC,CAAA"}

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

@@ -1,3 +0,0 @@
-import { getMockSignature, getOwnerValidator } from './core.js';
-import { encodeSmartSessionSignature, getAccountEIP712Domain, getEnableSessionCall, getPermissionId, getSessionAllowedERC7739Content, getSmartSessionValidator, isSessionEnabled, SMART_SESSION_MODE_ENABLE, SMART_SESSION_MODE_USE, SMART_SESSIONS_VALIDATOR_ADDRESS, } from './smart-sessions.js';
-export { SMART_SESSION_MODE_USE, SMART_SESSION_MODE_ENABLE, SMART_SESSIONS_VALIDATOR_ADDRESS, getOwnerValidator, getSmartSessionValidator, getEnableSessionCall, encodeSmartSessionSignature, getPermissionId, getMockSignature, getAccountEIP712Domain, isSessionEnabled, getSessionAllowedERC7739Content, };

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

@@ -1,29 +0,0 @@
-import { type Address, type Chain, type Hex, type PublicClient } from 'viem';
-import type { RhinestoneAccountConfig, Session } from '../../types';
-import { type Module } from '../common';
-type SmartSessionModeType = typeof SMART_SESSION_MODE_USE | typeof SMART_SESSION_MODE_ENABLE | typeof SMART_SESSION_MODE_UNSAFE_ENABLE;
-declare const SMART_SESSIONS_VALIDATOR_ADDRESS: Address;
-declare const SMART_SESSION_MODE_USE = "0x00";
-declare const SMART_SESSION_MODE_ENABLE = "0x01";
-declare const SMART_SESSION_MODE_UNSAFE_ENABLE = "0x02";
-declare function getEnableSessionCall(chain: Chain, session: Session): Promise<{
-    to: `0x${string}`;
-    data: `0x${string}`;
-}>;
-declare function getSessionAllowedERC7739Content(chain: Chain): Promise<{
-    appDomainSeparator: `0x${string}`;
-    contentsType: string;
-}>;
-declare function getSmartSessionValidator(config: RhinestoneAccountConfig): Module | null;
-declare function isSessionEnabled(client: PublicClient, address: Address, permissionId: Hex): Promise<boolean>;
-declare function encodeSmartSessionSignature(mode: SmartSessionModeType, permissionId: Hex, signature: Hex): `0x${string}`;
-declare function getPermissionId(session: Session): `0x${string}`;
-declare function getAccountEIP712Domain(client: PublicClient, account: Address): Promise<{
-    name: string;
-    version: string;
-    chainId: bigint;
-    verifyingContract: `0x${string}`;
-    salt: `0x${string}`;
-}>;
-export { SMART_SESSION_MODE_USE, SMART_SESSION_MODE_ENABLE, SMART_SESSIONS_VALIDATOR_ADDRESS, getSmartSessionValidator, getEnableSessionCall, encodeSmartSessionSignature, getPermissionId, getAccountEIP712Domain, isSessionEnabled, getSessionAllowedERC7739Content, };
-//# sourceMappingURL=smart-sessions.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../../modules/validators/smart-sessions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,KAAK,EAKV,KAAK,GAAG,EAIR,KAAK,YAAY,EAKlB,MAAM,MAAM,CAAA;AAMb,OAAO,KAAK,EAEV,uBAAuB,EACvB,OAAO,EAER,MAAM,aAAa,CAAA;AAEpB,OAAO,EAA4B,KAAK,MAAM,EAAE,MAAM,WAAW,CAAA;AA6DjE,KAAK,oBAAoB,GACrB,OAAO,sBAAsB,GAC7B,OAAO,yBAAyB,GAChC,OAAO,gCAAgC,CAAA;AAE3C,QAAA,MAAM,gCAAgC,EAAE,OACM,CAAA;AAE9C,QAAA,MAAM,sBAAsB,SAAS,CAAA;AACrC,QAAA,MAAM,yBAAyB,SAAS,CAAA;AACxC,QAAA,MAAM,gCAAgC,SAAS,CAAA;AAyB/C,iBAAe,oBAAoB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO;;;GAsBjE;AA6BD,iBAAe,+BAA+B,CAAC,KAAK,EAAE,KAAK;;;GAgB1D;AA0DD,iBAAS,wBAAwB,CAC/B,MAAM,EAAE,uBAAuB,GAC9B,MAAM,GAAG,IAAI,CAWf;AA8KD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,GAAG,oBAiClB;AAED,iBAAS,2BAA2B,CAClC,IAAI,EAAE,oBAAoB,EAC1B,YAAY,EAAE,GAAG,EACjB,SAAS,EAAE,GAAG,iBAcf;AAED,iBAAS,eAAe,CAAC,OAAO,EAAE,OAAO,iBAyBxC;AAED,iBAAe,sBAAsB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO;;;;;;GAoD3E;AAED,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,gCAAgC,EAChC,wBAAwB,EACxB,oBAAoB,EACpB,2BAA2B,EAC3B,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EAChB,+BAA+B,GAChC,CAAA"}

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

@@ -1,414 +0,0 @@
-import { createPublicClient, encodeAbiParameters, encodeFunctionData, encodePacked, http, isHex, keccak256, padHex, parseAbi, toHex, zeroHash, } from 'viem';
-import { getWethAddress, RHINESTONE_SPOKE_POOL_ADDRESS, } from '../../orchestrator/index.js';
-import { enableSessionsAbi } from '../abi/smart-sessions.js';
-import { MODULE_TYPE_ID_VALIDATOR } from '../common.js';
-import { HOOK_ADDRESS } from '../omni-account.js';
-import { getValidator } from './core.js';
-const SMART_SESSIONS_VALIDATOR_ADDRESS = '0x00000000002b0ecfbd0496ee71e01257da0e37de';
-const SMART_SESSION_MODE_USE = '0x00';
-const SMART_SESSION_MODE_ENABLE = '0x01';
-const SMART_SESSION_MODE_UNSAFE_ENABLE = '0x02';
-const SPENDING_LIMITS_POLICY_ADDRESS = '0x00000088D48cF102A8Cdb0137A9b173f957c6343';
-const TIME_FRAME_POLICY_ADDRESS = '0x8177451511dE0577b911C254E9551D981C26dc72';
-const SUDO_POLICY_ADDRESS = '0x0000003111cD8e92337C100F22B7A9dbf8DEE301';
-const UNIVERSAL_ACTION_POLICY_ADDRESS = '0x0000006DDA6c463511C4e9B05CFc34C1247fCF1F';
-const USAGE_LIMIT_POLICY_ADDRESS = '0x1F34eF8311345A3A4a4566aF321b313052F51493';
-const VALUE_LIMIT_POLICY_ADDRESS = '0x730DA93267E7E513e932301B47F2ac7D062abC83';
-const SMART_SESSIONS_FALLBACK_TARGET_FLAG = '0x0000000000000000000000000000000000000001';
-const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = '0x00000001';
-const ACTION_CONDITION_EQUAL = 0;
-const ACTION_CONDITION_GREATER_THAN = 1;
-const ACTION_CONDITION_LESS_THAN = 2;
-const ACTION_CONDITION_GREATER_THAN_OR_EQUAL = 3;
-const ACTION_CONDITION_LESS_THAN_OR_EQUAL = 4;
-const ACTION_CONDITION_NOT_EQUAL = 5;
-const ACTION_CONDITION_IN_RANGE = 6;
-async function getEnableSessionCall(chain, session) {
-    const { appDomainSeparator, contentsType } = await getSessionAllowedERC7739Content(chain);
-    const allowedERC7739Content = [
-        {
-            appDomainSeparator,
-            contentName: [contentsType],
-        },
-    ];
-    const sessionData = await getSmartSessionData(chain, session, allowedERC7739Content);
-    return {
-        to: SMART_SESSIONS_VALIDATOR_ADDRESS,
-        data: encodeFunctionData({
-            abi: enableSessionsAbi,
-            functionName: 'enableSessions',
-            args: [[sessionData]],
-        }),
-    };
-}
-function getOmniAccountActions(chain) {
-    const wethAddress = getWethAddress(chain);
-    const omniActions = [
-        {
-            actionTarget: RHINESTONE_SPOKE_POOL_ADDRESS,
-            actionTargetSelector: '0xa2418864', // injected execution
-            actionPolicies: [getPolicyData({ type: 'sudo' })],
-        },
-        {
-            actionTarget: HOOK_ADDRESS,
-            actionTargetSelector: '0x27c777a9', // injected execution
-            actionPolicies: [getPolicyData({ type: 'sudo' })],
-        },
-        {
-            actionTarget: wethAddress,
-            actionTargetSelector: '0xd0e30db0', // deposit
-            actionPolicies: [getPolicyData({ type: 'sudo' })],
-        },
-        {
-            actionTarget: wethAddress,
-            actionTargetSelector: '0x2e1a7d4d', // widthdraw
-            actionPolicies: [getPolicyData({ type: 'sudo' })],
-        },
-    ];
-    return omniActions;
-}
-async function getSessionAllowedERC7739Content(chain) {
-    const publicClient = createPublicClient({
-        chain,
-        transport: http(),
-    });
-    const appDomainSeparator = await publicClient.readContract({
-        address: HOOK_ADDRESS,
-        abi: parseAbi(['function DOMAIN_SEPARATOR() view returns (bytes32)']),
-        functionName: 'DOMAIN_SEPARATOR',
-    });
-    const contentsType = 'MultichainCompact(address sponsor,uint256 nonce,uint256 expires,Segment[] segments)Segment(address arbiter,uint256 chainId,uint256[2][] idsAndAmounts,Witness witness)Witness(address recipient,uint256[2][] tokenOut,uint256 depositId,uint256 targetChain,uint32 fillDeadline,XchainExec[] execs,bytes32 userOpHash,uint32 maxFeeBps)XchainExec(address to,uint256 value,bytes data)';
-    return {
-        appDomainSeparator,
-        contentsType,
-    };
-}
-async function getSmartSessionData(chain, session, allowedERC7739Content) {
-    const omniActions = getOmniAccountActions(chain);
-    const sessionValidator = getValidator(session.owners);
-    const userOpPolicies = (session.policies || [
-        {
-            type: 'sudo',
-        },
-    ]).map((policy) => {
-        return getPolicyData(policy);
-    });
-    return {
-        sessionValidator: sessionValidator.address,
-        sessionValidatorInitData: sessionValidator.initData,
-        salt: session.salt ?? zeroHash,
-        userOpPolicies,
-        // Using the fallback action by default (any transaction will pass)
-        actions: (session.actions || [
-            {
-                target: SMART_SESSIONS_FALLBACK_TARGET_FLAG,
-                selector: SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
-            },
-        ])
-            .map((action) => {
-            const actionPolicies = (action.policies || [
-                {
-                    type: 'sudo',
-                },
-            ]).map((policy) => {
-                return getPolicyData(policy);
-            });
-            return {
-                actionTargetSelector: action.selector,
-                actionTarget: action.target,
-                actionPolicies,
-            };
-        })
-            .concat(omniActions),
-        erc7739Policies: {
-            allowedERC7739Content,
-            erc1271Policies: [getPolicyData({ type: 'sudo' })],
-        },
-        permitERC4337Paymaster: true,
-    };
-}
-function getSmartSessionValidator(config) {
-    if (!config.sessions) {
-        return null;
-    }
-    return {
-        address: SMART_SESSIONS_VALIDATOR_ADDRESS,
-        initData: '0x',
-        deInitData: '0x',
-        additionalContext: '0x',
-        type: MODULE_TYPE_ID_VALIDATOR,
-    };
-}
-function getPolicyData(policy) {
-    switch (policy.type) {
-        case 'sudo':
-            return {
-                policy: SUDO_POLICY_ADDRESS,
-                initData: '0x',
-            };
-        case 'universal-action': {
-            function getCondition(condition) {
-                switch (condition) {
-                    case 'equal':
-                        return ACTION_CONDITION_EQUAL;
-                    case 'greaterThan':
-                        return ACTION_CONDITION_GREATER_THAN;
-                    case 'lessThan':
-                        return ACTION_CONDITION_LESS_THAN;
-                    case 'greaterThanOrEqual':
-                        return ACTION_CONDITION_GREATER_THAN_OR_EQUAL;
-                    case 'lessThanOrEqual':
-                        return ACTION_CONDITION_LESS_THAN_OR_EQUAL;
-                    case 'notEqual':
-                        return ACTION_CONDITION_NOT_EQUAL;
-                    case 'inRange':
-                        return ACTION_CONDITION_IN_RANGE;
-                }
-            }
-            const MAX_RULES = 16;
-            const rules = createFixedArray(MAX_RULES, () => ({
-                condition: ACTION_CONDITION_EQUAL,
-                offset: 0n,
-                isLimited: false,
-                ref: zeroHash,
-                usage: { limit: 0n, used: 0n },
-            }));
-            for (let i = 0; i < policy.rules.length; i++) {
-                const rule = policy.rules[i];
-                const ref = isHex(rule.referenceValue)
-                    ? padHex(rule.referenceValue)
-                    : toHex(rule.referenceValue, { size: 32 });
-                rules[i] = {
-                    condition: getCondition(rule.condition),
-                    offset: rule.calldataOffset,
-                    isLimited: rule.usageLimit !== undefined,
-                    ref,
-                    usage: {
-                        limit: rule.usageLimit ? rule.usageLimit : 0n,
-                        used: 0n,
-                    },
-                };
-            }
-            return {
-                policy: UNIVERSAL_ACTION_POLICY_ADDRESS,
-                initData: encodeAbiParameters([
-                    {
-                        components: [
-                            {
-                                name: 'valueLimitPerUse',
-                                type: 'uint256',
-                            },
-                            {
-                                components: [
-                                    {
-                                        name: 'length',
-                                        type: 'uint256',
-                                    },
-                                    {
-                                        components: [
-                                            {
-                                                name: 'condition',
-                                                type: 'uint8',
-                                            },
-                                            {
-                                                name: 'offset',
-                                                type: 'uint64',
-                                            },
-                                            {
-                                                name: 'isLimited',
-                                                type: 'bool',
-                                            },
-                                            {
-                                                name: 'ref',
-                                                type: 'bytes32',
-                                            },
-                                            {
-                                                components: [
-                                                    {
-                                                        name: 'limit',
-                                                        type: 'uint256',
-                                                    },
-                                                    {
-                                                        name: 'used',
-                                                        type: 'uint256',
-                                                    },
-                                                ],
-                                                name: 'usage',
-                                                type: 'tuple',
-                                            },
-                                        ],
-                                        name: 'rules',
-                                        type: 'tuple[16]',
-                                    },
-                                ],
-                                name: 'paramRules',
-                                type: 'tuple',
-                            },
-                        ],
-                        name: 'ActionConfig',
-                        type: 'tuple',
-                    },
-                ], [
-                    {
-                        valueLimitPerUse: policy.valueLimitPerUse ?? 0n,
-                        paramRules: {
-                            length: BigInt(policy.rules.length),
-                            rules: rules,
-                        },
-                    },
-                ]),
-            };
-        }
-        case 'spending-limits': {
-            const tokens = policy.limits.map(({ token }) => token);
-            const limits = policy.limits.map(({ amount }) => amount);
-            return {
-                policy: SPENDING_LIMITS_POLICY_ADDRESS,
-                initData: encodeAbiParameters([{ type: 'address[]' }, { type: 'uint256[]' }], [tokens, limits]),
-            };
-        }
-        case 'time-frame': {
-            return {
-                policy: TIME_FRAME_POLICY_ADDRESS,
-                initData: encodePacked(['uint128', 'uint128'], [
-                    BigInt(policy.validUntil) / 1000n,
-                    BigInt(policy.validAfter) / 1000n,
-                ]),
-            };
-        }
-        case 'usage-limit': {
-            return {
-                policy: USAGE_LIMIT_POLICY_ADDRESS,
-                initData: encodePacked(['uint128'], [policy.limit]),
-            };
-        }
-        case 'value-limit': {
-            return {
-                policy: VALUE_LIMIT_POLICY_ADDRESS,
-                initData: encodeAbiParameters([{ type: 'uint256' }], [policy.limit]),
-            };
-        }
-    }
-}
-function createFixedArray(length, getValue) {
-    return Array.from({ length }, (_, i) => getValue(i));
-}
-async function isSessionEnabled(client, address, permissionId) {
-    return await client.readContract({
-        address: SMART_SESSIONS_VALIDATOR_ADDRESS,
-        abi: [
-            {
-                inputs: [
-                    {
-                        internalType: 'PermissionId',
-                        name: 'permissionId',
-                        type: 'bytes32',
-                    },
-                    {
-                        internalType: 'address',
-                        name: 'account',
-                        type: 'address',
-                    },
-                ],
-                name: 'isPermissionEnabled',
-                outputs: [
-                    {
-                        internalType: 'bool',
-                        name: '',
-                        type: 'bool',
-                    },
-                ],
-                stateMutability: 'view',
-                type: 'function',
-            },
-        ],
-        functionName: 'isPermissionEnabled',
-        args: [permissionId, address],
-    });
-}
-function encodeSmartSessionSignature(mode, permissionId, signature) {
-    switch (mode) {
-        case SMART_SESSION_MODE_USE:
-            return encodePacked(['bytes1', 'bytes32', 'bytes'], [mode, permissionId, signature]);
-        case SMART_SESSION_MODE_ENABLE:
-        case SMART_SESSION_MODE_UNSAFE_ENABLE:
-            throw new Error('Enable mode not implemented');
-        default:
-            throw new Error(`Unknown mode ${mode}`);
-    }
-}
-function getPermissionId(session) {
-    const sessionValidator = getValidator(session.owners);
-    return keccak256(encodeAbiParameters([
-        {
-            type: 'address',
-            name: 'sessionValidator',
-        },
-        {
-            type: 'bytes',
-            name: 'sessionValidatorInitData',
-        },
-        {
-            type: 'bytes32',
-            name: 'salt',
-        },
-    ], [
-        sessionValidator.address,
-        sessionValidator.initData,
-        session.salt ?? zeroHash,
-    ]));
-}
-async function getAccountEIP712Domain(client, account) {
-    const data = await client.readContract({
-        address: account,
-        abi: [
-            {
-                type: 'function',
-                name: 'eip712Domain',
-                inputs: [],
-                outputs: [
-                    {
-                        type: 'bytes1',
-                        name: 'fields,',
-                    },
-                    {
-                        type: 'string',
-                        name: 'name',
-                    },
-                    {
-                        type: 'string',
-                        name: 'version',
-                    },
-                    {
-                        type: 'uint256',
-                        name: 'chainId',
-                    },
-                    {
-                        type: 'address',
-                        name: 'verifyingContract',
-                    },
-                    {
-                        type: 'bytes32',
-                        name: 'salt',
-                    },
-                    {
-                        type: 'uint256[]',
-                        name: 'extensions',
-                    },
-                ],
-                stateMutability: 'view',
-                constant: true,
-            },
-        ],
-        functionName: 'eip712Domain',
-        args: [],
-    });
-    return {
-        name: data[1],
-        version: data[2],
-        chainId: data[3],
-        verifyingContract: data[4],
-        salt: data[5],
-    };
-}
-export { SMART_SESSION_MODE_USE, SMART_SESSION_MODE_ENABLE, SMART_SESSIONS_VALIDATOR_ADDRESS, getSmartSessionValidator, getEnableSessionCall, encodeSmartSessionSignature, getPermissionId, getAccountEIP712Domain, isSessionEnabled, getSessionAllowedERC7739Content, };

package/dist/src/orchestrator/client.d.ts

@@ -1,29 +0,0 @@
-import { type Address, type Hex } from 'viem';
-import type { UserOperation } from 'viem/account-abstraction';
-import type { BundleEvent, BundleResult, MetaIntent, OrderCostResult, OrderFeeInput, OrderPath, PostOrderBundleResult, SignedMultiChainCompact, UserTokenBalance } from './types';
-export declare class Orchestrator {
-    private serverUrl;
-    private apiKey;
-    constructor(serverUrl: string, apiKey: string);
-    getPortfolio(userAddress: Address, filter?: {
-        chainIds?: number[];
-        tokens?: {
-            [chainId: number]: Address[];
-        };
-    }): Promise<UserTokenBalance[]>;
-    getMaxTokenAmount(userAddress: Address, targetChainId: number, targetTokenAddress: Address, targetGasUnits: bigint): Promise<bigint>;
-    getIntentCost(intent: OrderFeeInput, userAddress: Address): Promise<OrderCostResult>;
-    getOrderPath(intent: MetaIntent, userAddress: Address): Promise<OrderPath>;
-    postSignedOrderBundle(signedOrderBundles: {
-        signedOrderBundle: SignedMultiChainCompact;
-        initCode?: Hex;
-        userOp?: UserOperation;
-    }[]): Promise<PostOrderBundleResult>;
-    getBundleStatus(bundleId: bigint): Promise<BundleResult>;
-    getPendingBundles(count?: number, offset?: number): Promise<{
-        pendingBundles: BundleEvent[];
-        nextOffset?: number;
-    }>;
-    private parseError;
-}
-//# sourceMappingURL=client.d.ts.map

package/dist/src/orchestrator/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../orchestrator/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAU,KAAK,GAAG,EAAE,MAAM,MAAM,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAG7D,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,aAAa,EACb,SAAS,EACT,qBAAqB,EACrB,uBAAuB,EACvB,gBAAgB,EACjB,MAAM,SAAS,CAAA;AAShB,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAAQ;gBAEV,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAKvC,YAAY,CAChB,WAAW,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;QACnB,MAAM,CAAC,EAAE;YACP,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;SAC7B,CAAA;KACF,GACA,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAwCxB,iBAAiB,CACrB,WAAW,EAAE,OAAO,EACpB,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,OAAO,EAC3B,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC;IAgCZ,aAAa,CACjB,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,eAAe,CAAC;IAqBrB,YAAY,CAChB,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,SAAS,CAAC;IAgCf,qBAAqB,CACzB,kBAAkB,EAAE;QAClB,iBAAiB,EAAE,uBAAuB,CAAA;QAC1C,QAAQ,CAAC,EAAE,GAAG,CAAA;QACd,MAAM,CAAC,EAAE,aAAa,CAAA;KACvB,EAAE,GACF,OAAO,CAAC,qBAAqB,CAAC;IA2C3B,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAyBxD,iBAAiB,CACrB,KAAK,GAAE,MAAW,EAClB,MAAM,GAAE,MAAU,GACjB,OAAO,CAAC;QAAE,cAAc,EAAE,WAAW,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAuBlE,OAAO,CAAC,UAAU;CA6DnB"}