@rhinestone/sdk 1.0.41-alpha.0 → 1.0.41

package/dist/src/index.d.ts

@@ -0,0 +1,74 @@
+import type { Address, Chain, HashTypedDataParameters, Hex, SignableMessage, SignedAuthorizationList, TypedData, TypedDataDefinition } from 'viem';
+import type { UserOperationReceipt } from 'viem/account-abstraction';
+import { walletClientToAccount, wrapParaAccount } from './accounts/walletClient';
+import { deployAccountsForOwners } from './actions/deployment';
+import { type TransactionResult, type TransactionStatus, type UserOperationResult } from './execution';
+import { type BatchPermit2Result, checkERC20AllowanceDirect, getPermit2Address, type MultiChainPermit2Config, type MultiChainPermit2Result, signPermit2Batch, signPermit2Sequential } from './execution/permit2';
+import { type SessionDetails } from './execution/smart-session';
+import { type IntentRoute, type PreparedTransactionData, type PreparedUserOperationData, type SignedTransactionData, type SignedUserOperationData } from './execution/utils';
+import { type ApprovalRequired, getAllSupportedChainsAndTokens, getSupportedTokens, getTokenAddress, getTokenDecimals, type IntentCost, type IntentInput, type IntentOp, type IntentOpStatus, type Portfolio, type SettlementLayer, type SignedIntentOp, type TokenRequirements, type WrapRequired } from './orchestrator';
+import type { AccountProviderConfig, AccountType, BundlerConfig, Call, CallInput, MultiFactorValidatorConfig, OwnableValidatorConfig, OwnerSet, PaymasterConfig, Policy, ProviderConfig, Recovery, RhinestoneAccountConfig, RhinestoneConfig, RhinestoneSDKConfig, Session, SignerSet, TokenRequest, TokenSymbol, Transaction, UniversalActionPolicyParamCondition, UserOperationTransaction, WebauthnValidatorConfig } from './types';
+interface RhinestoneAccount {
+    config: RhinestoneAccountConfig;
+    deploy: (chain: Chain, params?: {
+        session?: Session;
+        sponsored?: boolean;
+    }) => Promise<boolean>;
+    isDeployed: (chain: Chain) => Promise<boolean>;
+    setup: (chain: Chain) => Promise<boolean>;
+    getInitData(): {
+        factory: Address;
+        factoryData: Hex;
+    };
+    signEip7702InitData: () => Promise<Hex>;
+    prepareTransaction: (transaction: Transaction) => Promise<PreparedTransactionData>;
+    getTransactionMessages: (preparedTransaction: PreparedTransactionData) => {
+        origin: TypedDataDefinition[];
+        destination: TypedDataDefinition;
+    };
+    signTransaction: (preparedTransaction: PreparedTransactionData) => Promise<SignedTransactionData>;
+    signAuthorizations: (preparedTransaction: PreparedTransactionData) => Promise<SignedAuthorizationList>;
+    signMessage: (message: SignableMessage, chain: Chain, signers: SignerSet | undefined) => Promise<Hex>;
+    signTypedData: <typedData extends TypedData | Record<string, unknown> = TypedData, primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData>(parameters: HashTypedDataParameters<typedData, primaryType>, chain: Chain, signers: SignerSet | undefined) => Promise<Hex>;
+    submitTransaction: (signedTransaction: SignedTransactionData, authorizations?: SignedAuthorizationList, dryRun?: boolean) => Promise<TransactionResult>;
+    sendTransaction: (transaction: Transaction) => Promise<TransactionResult>;
+    prepareUserOperation: (transaction: UserOperationTransaction) => Promise<PreparedUserOperationData>;
+    signUserOperation: (preparedUserOperation: PreparedUserOperationData) => Promise<SignedUserOperationData>;
+    submitUserOperation: (signedUserOperation: SignedUserOperationData) => Promise<UserOperationResult>;
+    sendUserOperation: (transaction: UserOperationTransaction) => Promise<UserOperationResult>;
+    waitForExecution(result: TransactionResult, acceptsPreconfirmations?: boolean): Promise<TransactionStatus>;
+    waitForExecution(result: UserOperationResult, acceptsPreconfirmations?: boolean): Promise<UserOperationReceipt>;
+    getAddress: () => Address;
+    getPortfolio: (onTestnets?: boolean) => Promise<Portfolio>;
+    getMaxSpendableAmount: (chain: Chain, tokenAddress: Address | TokenSymbol, gasUnits: bigint, sponsored?: boolean) => Promise<bigint>;
+    getSessionDetails: (sessions: Session[], sessionIndex: number, initialNonces?: bigint[], signature?: Hex) => Promise<SessionDetails>;
+    getOwners: (chain: Chain) => Promise<{
+        accounts: Address[];
+        threshold: number;
+    } | null>;
+    getValidators: (chain: Chain) => Promise<Address[]>;
+    checkERC20Allowance: (tokenAddress: Address, chain: Chain) => Promise<bigint>;
+}
+/**
+ * Initialize a Rhinestone account
+ * Note: accounts are deployed onchain only when the first transaction is sent.
+ * @param config Account config (e.g. implementation vendor, owner signers, smart sessions)
+ * @returns account
+ */
+declare function createRhinestoneAccount(config: RhinestoneConfig): Promise<RhinestoneAccount>;
+declare class RhinestoneSDK {
+    private apiKey?;
+    private endpointUrl?;
+    private provider?;
+    private bundler?;
+    private paymaster?;
+    private useDevContracts?;
+    constructor(options?: RhinestoneSDKConfig);
+    createAccount(config: RhinestoneAccountConfig): Promise<RhinestoneAccount>;
+    getIntentStatus(intentId: bigint): Promise<TransactionStatus & {
+        status: IntentOpStatus["status"];
+    }>;
+}
+export { RhinestoneSDK, createRhinestoneAccount, deployAccountsForOwners, walletClientToAccount, wrapParaAccount, getSupportedTokens, getTokenAddress, getTokenDecimals, getAllSupportedChainsAndTokens, checkERC20AllowanceDirect, getPermit2Address, signPermit2Batch, signPermit2Sequential, };
+export type { RhinestoneAccount, AccountType, RhinestoneAccountConfig, AccountProviderConfig, ProviderConfig, BundlerConfig, PaymasterConfig, Transaction, TokenSymbol, CallInput, Call, TokenRequest, OwnerSet, OwnableValidatorConfig, WebauthnValidatorConfig, MultiFactorValidatorConfig, SignerSet, Session, Recovery, Policy, UniversalActionPolicyParamCondition, PreparedTransactionData, SignedTransactionData, TransactionResult, PreparedUserOperationData, SignedUserOperationData, UserOperationResult, IntentCost, IntentInput, IntentOp, IntentOpStatus, IntentRoute, SettlementLayer, SignedIntentOp, Portfolio, TokenRequirements, WrapRequired, ApprovalRequired, MultiChainPermit2Config, MultiChainPermit2Result, BatchPermit2Result, };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"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"}

package/dist/src/index.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signPermit2Sequential = exports.signPermit2Batch = exports.getPermit2Address = exports.checkERC20AllowanceDirect = exports.getAllSupportedChainsAndTokens = exports.getTokenDecimals = exports.getTokenAddress = exports.getSupportedTokens = exports.wrapParaAccount = exports.walletClientToAccount = exports.deployAccountsForOwners = exports.RhinestoneSDK = void 0;
+exports.createRhinestoneAccount = createRhinestoneAccount;
+const accounts_1 = require("./accounts");
+const walletClient_1 = require("./accounts/walletClient");
+Object.defineProperty(exports, "walletClientToAccount", { enumerable: true, get: function () { return walletClient_1.walletClientToAccount; } });
+Object.defineProperty(exports, "wrapParaAccount", { enumerable: true, get: function () { return walletClient_1.wrapParaAccount; } });
+const deployment_1 = require("./actions/deployment");
+Object.defineProperty(exports, "deployAccountsForOwners", { enumerable: true, get: function () { return deployment_1.deployAccountsForOwners; } });
+const execution_1 = require("./execution");
+const permit2_1 = require("./execution/permit2");
+Object.defineProperty(exports, "checkERC20AllowanceDirect", { enumerable: true, get: function () { return permit2_1.checkERC20AllowanceDirect; } });
+Object.defineProperty(exports, "getPermit2Address", { enumerable: true, get: function () { return permit2_1.getPermit2Address; } });
+Object.defineProperty(exports, "signPermit2Batch", { enumerable: true, get: function () { return permit2_1.signPermit2Batch; } });
+Object.defineProperty(exports, "signPermit2Sequential", { enumerable: true, get: function () { return permit2_1.signPermit2Sequential; } });
+const smart_session_1 = require("./execution/smart-session");
+const utils_1 = require("./execution/utils");
+const modules_1 = require("./modules");
+const orchestrator_1 = require("./orchestrator");
+Object.defineProperty(exports, "getAllSupportedChainsAndTokens", { enumerable: true, get: function () { return orchestrator_1.getAllSupportedChainsAndTokens; } });
+Object.defineProperty(exports, "getSupportedTokens", { enumerable: true, get: function () { return orchestrator_1.getSupportedTokens; } });
+Object.defineProperty(exports, "getTokenAddress", { enumerable: true, get: function () { return orchestrator_1.getTokenAddress; } });
+Object.defineProperty(exports, "getTokenDecimals", { enumerable: true, get: function () { return orchestrator_1.getTokenDecimals; } });
+/**
+ * Initialize a Rhinestone account
+ * Note: accounts are deployed onchain only when the first transaction is sent.
+ * @param config Account config (e.g. implementation vendor, owner signers, smart sessions)
+ * @returns account
+ */
+async function createRhinestoneAccount(config) {
+    // Sanity check for existing (externally created) accounts
+    // Ensures we decode the initdata correctly
+    (0, accounts_1.checkAddress)(config);
+    // Validate that owners field is provided for non-EOA accounts
+    if (config.account?.type !== 'eoa' && !config.owners) {
+        throw new accounts_1.OwnersFieldRequiredError();
+    }
+    /**
+     * Deploys the account on a given chain
+     * @param chain Chain to deploy the account on
+     * @param session Session to deploy the account on (optional)
+     */
+    function deploy(chain, params) {
+        return (0, accounts_1.deploy)(config, chain, params);
+    }
+    /**
+     * Checks if the account is deployed on a given chain
+     * @param chain Chain to check if the account is deployed on
+     * @returns true if the account is deployed, false otherwise
+     */
+    function isDeployed(chain) {
+        return (0, accounts_1.isDeployed)(config, chain);
+    }
+    /**
+     * Sets up the existing account on a given chain
+     * by installing the missing modules (if any).
+     * @param chain Chain to set up the account on
+     */
+    function setup(chain) {
+        return (0, accounts_1.setup)(config, chain);
+    }
+    /**
+     * Get the account initialization data. Used for deploying the account onchain.
+     * @returns factory address and factory data
+     */
+    function getInitData() {
+        const initData = (0, accounts_1.getInitCode)(config);
+        if (!initData) {
+            throw new accounts_1.FactoryArgsNotAvailableError();
+        }
+        if (!('factory' in initData)) {
+            throw new accounts_1.FactoryArgsNotAvailableError();
+        }
+        return {
+            factory: initData.factory,
+            factoryData: initData.factoryData,
+        };
+    }
+    /**
+     * Prepare and sign the EIP-7702 account initialization data
+     * @returns init data signature
+     */
+    function signEip7702InitData() {
+        return (0, accounts_1.signEip7702InitData)(config);
+    }
+    /**
+     * Prepare a transaction data
+     * @param transaction Transaction to prepare
+     * @returns prepared transaction data
+     */
+    function prepareTransaction(transaction) {
+        return (0, utils_1.prepareTransaction)(config, transaction);
+    }
+    /**
+     * Get the transaction typed data message to sign
+     * @param preparedTransaction Prepared transaction data
+     * @see {@link prepareTransaction} to prepare the transaction data for signing
+     */
+    function getTransactionMessages(preparedTransaction) {
+        return (0, utils_1.getTransactionMessages)(config, preparedTransaction);
+    }
+    /**
+     * Sign a transaction
+     * @param preparedTransaction Prepared transaction data
+     * @returns signed transaction data
+     * @see {@link prepareTransaction} to prepare the transaction data for signing
+     */
+    function signTransaction(preparedTransaction) {
+        return (0, utils_1.signTransaction)(config, preparedTransaction);
+    }
+    /**
+     * Sign the required EIP-7702 authorizations for a transaction
+     * @param preparedTransaction Prepared transaction data
+     * @returns signed authorizations
+     * @see {@link prepareTransaction} to prepare the transaction data for signing
+     */
+    function signAuthorizations(preparedTransaction) {
+        return (0, utils_1.signAuthorizations)(config, preparedTransaction);
+    }
+    /**
+     * Sign a message (EIP-191)
+     * @param message Message to sign
+     * @param chain Chain to sign the message on
+     * @param signers Signers to use for signing
+     * @returns signature
+     */
+    function signMessage(message, chain, signers) {
+        return (0, utils_1.signMessage)(config, message, chain, signers);
+    }
+    /**
+     * Sign a typed data (EIP-712)
+     * @param parameters Typed data parameters
+     * @param chain Chain to sign the typed data on
+     * @param signers Signers to use for signing
+     * @returns signature
+     */
+    function signTypedData(parameters, chain, signers) {
+        return (0, utils_1.signTypedData)(config, parameters, chain, signers);
+    }
+    /**
+     * Submit a transaction
+     * @param signedTransaction Signed transaction data
+     * @param authorizations EIP-7702 authorizations to submit (optional)
+     * @returns transaction result object (a UserOp hash)
+     * @see {@link signTransaction} to sign the transaction data
+     * @see {@link signAuthorizations} to sign the required EIP-7702 authorizations
+     * @see {@link dryRun} true when intent is not executed onchain (internal use only)
+     */
+    function submitTransaction(signedTransaction, authorizations, dryRun) {
+        return (0, utils_1.submitTransaction)(config, signedTransaction, authorizations ?? [], dryRun);
+    }
+    /**
+     * Prepare a user operation data
+     * @param transaction User operation to prepare
+     * @returns prepared user operation data
+     */
+    function prepareUserOperation(transaction) {
+        return (0, utils_1.prepareUserOperation)(config, transaction);
+    }
+    /**
+     * Sign a user operation
+     * @param preparedUserOperation Prepared user operation data
+     * @returns signed user operation data
+     * @see {@link prepareUserOperation} to prepare the user operation data for signing
+     */
+    function signUserOperation(preparedUserOperation) {
+        return (0, utils_1.signUserOperation)(config, preparedUserOperation);
+    }
+    /**
+     * Submit a transaction
+     * @param signedTransaction Signed transaction data
+     * @returns transaction result object (a UserOp hash)
+     * @see {@link signUserOperation} to sign the user operation data
+     */
+    function submitUserOperation(signedUserOperation) {
+        return (0, utils_1.submitUserOperation)(config, signedUserOperation);
+    }
+    /**
+     * Sign and send a transaction
+     * @param transaction Transaction to send
+     * @returns transaction result object (an intent ID)
+     */
+    function sendTransaction(transaction) {
+        return (0, execution_1.sendTransaction)(config, transaction);
+    }
+    /**
+     * Sign and send a user operation
+     * @param transaction User operation to send
+     * @returns user operation result object (a UserOp hash)
+     */
+    function sendUserOperation(transaction) {
+        return (0, execution_1.sendUserOperation)(config, transaction);
+    }
+    function waitForExecution(result, acceptsPreconfirmations = true) {
+        return (0, execution_1.waitForExecution)(config, result, acceptsPreconfirmations);
+    }
+    /**
+     * Get account address
+     * @returns Address of the smart account
+     */
+    function getAddress() {
+        return (0, accounts_1.getAddress)(config);
+    }
+    /**
+     * Get account portfolio
+     * @param onTestnets Whether to query the testnet balances (default is `false`)
+     * @returns Account balances
+     */
+    function getPortfolio(onTestnets = false) {
+        return (0, execution_1.getPortfolio)(config, onTestnets);
+    }
+    /**
+     * Get the maximum spendable token amount on the target chain
+     * @param chain Target chain
+     * @param token Token address (on the target chain)
+     * @param gasUnits Gas cost estimate for the transaction execution
+     * @returns Maximum spendable amount in absolute units
+     */
+    function getMaxSpendableAmount(chain, token, gasUnits, sponsored = false) {
+        return (0, execution_1.getMaxSpendableAmount)(config, chain, token, gasUnits, sponsored);
+    }
+    /**
+     * Get account owners (ECDSA)
+     * @param chain Chain to get the owners on
+     * @returns Account owners
+     */
+    function getOwners(chain) {
+        const account = getAddress();
+        return (0, modules_1.getOwners)(account, chain, config.provider);
+    }
+    /**
+     * Get account validator modules
+     * @param chain Chain to get the validators on
+     * @returns List of account validators
+     */
+    function getValidators(chain) {
+        const accountType = (0, accounts_1.getAccountProvider)(config).type;
+        const account = getAddress();
+        return (0, modules_1.getValidators)(accountType, account, chain, config.provider);
+    }
+    function getSessionDetails(sessions, sessionIndex, initialNonces, signature) {
+        return (0, smart_session_1.getSessionDetails)(config, sessions, sessionIndex, initialNonces, signature);
+    }
+    /**
+     * Check ERC20 allowance for the account owner and token (using Permit2 as spender)
+     * @param tokenAddress The token contract address
+     * @param chain The chain to check the allowance on
+     * @returns The allowance amount
+     */
+    function checkERC20Allowance(tokenAddress, chain) {
+        if (!config.provider) {
+            throw new Error('Provider configuration is required');
+        }
+        return (0, permit2_1.checkERC20Allowance)(tokenAddress, chain, config);
+    }
+    return {
+        config,
+        deploy,
+        isDeployed,
+        setup,
+        signEip7702InitData,
+        prepareTransaction,
+        getTransactionMessages,
+        signTransaction,
+        signAuthorizations,
+        signMessage,
+        signTypedData,
+        submitTransaction,
+        prepareUserOperation,
+        signUserOperation,
+        submitUserOperation,
+        sendTransaction,
+        sendUserOperation,
+        waitForExecution,
+        getAddress,
+        getPortfolio,
+        getMaxSpendableAmount,
+        getSessionDetails,
+        getOwners,
+        getValidators,
+        checkERC20Allowance,
+        getInitData,
+    };
+}
+class RhinestoneSDK {
+    apiKey;
+    endpointUrl;
+    provider;
+    bundler;
+    paymaster;
+    useDevContracts;
+    constructor(options) {
+        this.apiKey = options?.apiKey;
+        this.endpointUrl = options?.endpointUrl;
+        this.provider = options?.provider;
+        this.bundler = options?.bundler;
+        this.paymaster = options?.paymaster;
+        this.useDevContracts = options?.useDevContracts;
+    }
+    createAccount(config) {
+        const rhinestoneConfig = {
+            ...config,
+            apiKey: this.apiKey,
+            endpointUrl: this.endpointUrl,
+            provider: this.provider,
+            bundler: this.bundler,
+            paymaster: this.paymaster,
+            useDevContracts: this.useDevContracts,
+        };
+        return createRhinestoneAccount(rhinestoneConfig);
+    }
+    getIntentStatus(intentId) {
+        return (0, execution_1.getIntentStatus)(this.apiKey, this.endpointUrl, intentId);
+    }
+}
+exports.RhinestoneSDK = RhinestoneSDK;

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

@@ -0,0 +1,104 @@
+declare const enableSessionsAbi: readonly [{
+    readonly type: "function";
+    readonly name: "enableSessions";
+    readonly inputs: readonly [{
+        readonly name: "sessions";
+        readonly type: "tuple[]";
+        readonly internalType: "struct Session[]";
+        readonly components: readonly [{
+            readonly name: "sessionValidator";
+            readonly type: "address";
+            readonly internalType: "contract ISessionValidator";
+        }, {
+            readonly name: "sessionValidatorInitData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "salt";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }, {
+            readonly name: "userOpPolicies";
+            readonly type: "tuple[]";
+            readonly internalType: "struct PolicyData[]";
+            readonly components: readonly [{
+                readonly name: "policy";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "initData";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }, {
+            readonly name: "erc7739Policies";
+            readonly type: "tuple";
+            readonly internalType: "struct ERC7739Data";
+            readonly components: readonly [{
+                readonly name: "allowedERC7739Content";
+                readonly type: "tuple[]";
+                readonly internalType: "struct ERC7739Context[]";
+                readonly components: readonly [{
+                    readonly name: "appDomainSeparator";
+                    readonly type: "bytes32";
+                    readonly internalType: "bytes32";
+                }, {
+                    readonly name: "contentName";
+                    readonly type: "string[]";
+                    readonly internalType: "string[]";
+                }];
+            }, {
+                readonly name: "erc1271Policies";
+                readonly type: "tuple[]";
+                readonly internalType: "struct PolicyData[]";
+                readonly components: readonly [{
+                    readonly name: "policy";
+                    readonly type: "address";
+                    readonly internalType: "address";
+                }, {
+                    readonly name: "initData";
+                    readonly type: "bytes";
+                    readonly internalType: "bytes";
+                }];
+            }];
+        }, {
+            readonly name: "actions";
+            readonly type: "tuple[]";
+            readonly internalType: "struct ActionData[]";
+            readonly components: readonly [{
+                readonly name: "actionTargetSelector";
+                readonly type: "bytes4";
+                readonly internalType: "bytes4";
+            }, {
+                readonly name: "actionTarget";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "actionPolicies";
+                readonly type: "tuple[]";
+                readonly internalType: "struct PolicyData[]";
+                readonly components: readonly [{
+                    readonly name: "policy";
+                    readonly type: "address";
+                    readonly internalType: "address";
+                }, {
+                    readonly name: "initData";
+                    readonly type: "bytes";
+                    readonly internalType: "bytes";
+                }];
+            }];
+        }, {
+            readonly name: "permitERC4337Paymaster";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly name: "permissionIds";
+        readonly type: "bytes32[]";
+        readonly internalType: "PermissionId[]";
+    }];
+    readonly stateMutability: "nonpayable";
+}];
+export { enableSessionsAbi };
+//# sourceMappingURL=smart-sessions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../../modules/abi/smart-sessions.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8Hb,CAAA;AAEV,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableSessionsAbi = void 0;
+const enableSessionsAbi = [
+    {
+        type: 'function',
+        name: 'enableSessions',
+        inputs: [
+            {
+                name: 'sessions',
+                type: 'tuple[]',
+                internalType: 'struct Session[]',
+                components: [
+                    {
+                        name: 'sessionValidator',
+                        type: 'address',
+                        internalType: 'contract ISessionValidator',
+                    },
+                    {
+                        name: 'sessionValidatorInitData',
+                        type: 'bytes',
+                        internalType: 'bytes',
+                    },
+                    { name: 'salt', type: 'bytes32', internalType: 'bytes32' },
+                    {
+                        name: 'userOpPolicies',
+                        type: 'tuple[]',
+                        internalType: 'struct PolicyData[]',
+                        components: [
+                            {
+                                name: 'policy',
+                                type: 'address',
+                                internalType: 'address',
+                            },
+                            { name: 'initData', type: 'bytes', internalType: 'bytes' },
+                        ],
+                    },
+                    {
+                        name: 'erc7739Policies',
+                        type: 'tuple',
+                        internalType: 'struct ERC7739Data',
+                        components: [
+                            {
+                                name: 'allowedERC7739Content',
+                                type: 'tuple[]',
+                                internalType: 'struct ERC7739Context[]',
+                                components: [
+                                    {
+                                        name: 'appDomainSeparator',
+                                        type: 'bytes32',
+                                        internalType: 'bytes32',
+                                    },
+                                    {
+                                        name: 'contentName',
+                                        type: 'string[]',
+                                        internalType: 'string[]',
+                                    },
+                                ],
+                            },
+                            {
+                                name: 'erc1271Policies',
+                                type: 'tuple[]',
+                                internalType: 'struct PolicyData[]',
+                                components: [
+                                    {
+                                        name: 'policy',
+                                        type: 'address',
+                                        internalType: 'address',
+                                    },
+                                    {
+                                        name: 'initData',
+                                        type: 'bytes',
+                                        internalType: 'bytes',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        name: 'actions',
+                        type: 'tuple[]',
+                        internalType: 'struct ActionData[]',
+                        components: [
+                            {
+                                name: 'actionTargetSelector',
+                                type: 'bytes4',
+                                internalType: 'bytes4',
+                            },
+                            {
+                                name: 'actionTarget',
+                                type: 'address',
+                                internalType: 'address',
+                            },
+                            {
+                                name: 'actionPolicies',
+                                type: 'tuple[]',
+                                internalType: 'struct PolicyData[]',
+                                components: [
+                                    {
+                                        name: 'policy',
+                                        type: 'address',
+                                        internalType: 'address',
+                                    },
+                                    {
+                                        name: 'initData',
+                                        type: 'bytes',
+                                        internalType: 'bytes',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        name: 'permitERC4337Paymaster',
+                        type: 'bool',
+                        internalType: 'bool',
+                    },
+                ],
+            },
+        ],
+        outputs: [
+            {
+                name: 'permissionIds',
+                type: 'bytes32[]',
+                internalType: 'PermissionId[]',
+            },
+        ],
+        stateMutability: 'nonpayable',
+    },
+];
+exports.enableSessionsAbi = enableSessionsAbi;

package/dist/src/modules/chain-abstraction.d.ts

@@ -0,0 +1,5 @@
+import type { Address } from 'viem';
+declare const INTENT_EXECUTOR_ADDRESS: Address;
+declare const INTENT_EXECUTOR_ADDRESS_DEV: Address;
+export { INTENT_EXECUTOR_ADDRESS, INTENT_EXECUTOR_ADDRESS_DEV };
+//# sourceMappingURL=chain-abstraction.d.ts.map

package/dist/src/modules/chain-abstraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-abstraction.d.ts","sourceRoot":"","sources":["../../../modules/chain-abstraction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,QAAA,MAAM,uBAAuB,EAAE,OACe,CAAA;AAC9C,QAAA,MAAM,2BAA2B,EAAE,OACW,CAAA;AAE9C,OAAO,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,CAAA"}

package/dist/src/modules/chain-abstraction.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTENT_EXECUTOR_ADDRESS_DEV = exports.INTENT_EXECUTOR_ADDRESS = void 0;
+const INTENT_EXECUTOR_ADDRESS = '0x00000000005aD9ce1f5035FD62CA96CEf16AdAAF';
+exports.INTENT_EXECUTOR_ADDRESS = INTENT_EXECUTOR_ADDRESS;
+const INTENT_EXECUTOR_ADDRESS_DEV = '0xbf9b5b917a83f8adac17b0752846d41d8d7b7e17';
+exports.INTENT_EXECUTOR_ADDRESS_DEV = INTENT_EXECUTOR_ADDRESS_DEV;