@charterlabs/rhinestone-sdk 0.1.0 → 0.1.2

package/dist/src/execution/utils.d.ts

@@ -0,0 +1,45 @@
+import { type Address, type Chain, type Hex, type PublicClient, type SignedAuthorization, type SignedAuthorizationList } from 'viem';
+import { type UserOperation } from 'viem/account-abstraction';
+import { type IntentOp, type IntentRoute } from '../orchestrator';
+import type { Call, CallInput, RhinestoneAccountConfig, SignerSet, TokenRequest, Transaction } from '../types';
+type TransactionResult = {
+    type: 'userop';
+    hash: Hex;
+    chain: number;
+} | {
+    type: 'intent';
+    id: bigint;
+    sourceChain?: number;
+    targetChain: number;
+};
+interface IntentData {
+    type: 'intent';
+    hash: Hex;
+    intentRoute: IntentRoute;
+}
+interface UserOpData {
+    type: 'userop';
+    hash: Hex;
+    userOp: UserOperation;
+}
+interface PreparedTransactionData {
+    data: IntentData | UserOpData;
+    transaction: Transaction;
+}
+interface SignedTransactionData extends PreparedTransactionData {
+    signature: Hex;
+}
+declare function prepareTransaction(config: RhinestoneAccountConfig, transaction: Transaction): Promise<PreparedTransactionData>;
+declare function signTransaction(config: RhinestoneAccountConfig, preparedTransaction: PreparedTransactionData): Promise<SignedTransactionData>;
+declare function signAuthorizations(config: RhinestoneAccountConfig, preparedTransaction: PreparedTransactionData): Promise<SignedAuthorization[]>;
+declare function signAuthorizationsInternal(config: RhinestoneAccountConfig, data: IntentData | UserOpData): Promise<SignedAuthorization[]>;
+declare function submitTransaction(config: RhinestoneAccountConfig, signedTransaction: SignedTransactionData, authorizations: SignedAuthorizationList): Promise<TransactionResult>;
+declare function prepareTransactionAsIntent(config: RhinestoneAccountConfig, sourceChains: Chain[] | undefined, targetChain: Chain, callInputs: CallInput[], gasLimit: bigint | undefined, tokenRequests: TokenRequest[], accountAddress: Address, isSponsored: boolean, eip7702InitSignature?: Hex): Promise<IntentData>;
+declare function signIntent(config: RhinestoneAccountConfig, targetChain: Chain, intentHash: Hex, signers?: SignerSet): Promise<`0x${string}`>;
+declare function getOrchestratorByChain(chainId: number, apiKey: string): import("../orchestrator").Orchestrator;
+declare function submitIntentInternal(config: RhinestoneAccountConfig, sourceChains: Chain[] | undefined, targetChain: Chain, intentOp: IntentOp, signature: Hex, authorizations: SignedAuthorizationList): Promise<TransactionResult>;
+declare function getValidatorAccount(config: RhinestoneAccountConfig, signers: SignerSet | undefined, publicClient: PublicClient, chain: Chain): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">> | null | undefined>;
+declare function parseCalls(calls: CallInput[], chainId: number): Call[];
+export { prepareTransaction, signTransaction, signAuthorizations, signAuthorizationsInternal, submitTransaction, getOrchestratorByChain, signIntent, prepareTransactionAsIntent, submitIntentInternal, getValidatorAccount, parseCalls, };
+export type { IntentData, TransactionResult, PreparedTransactionData, SignedTransactionData, };
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/execution/utils.d.ts.map

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

package/dist/src/execution/utils.js

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareTransaction = prepareTransaction;
+exports.signTransaction = signTransaction;
+exports.signAuthorizations = signAuthorizations;
+exports.signAuthorizationsInternal = signAuthorizationsInternal;
+exports.submitTransaction = submitTransaction;
+exports.getOrchestratorByChain = getOrchestratorByChain;
+exports.signIntent = signIntent;
+exports.prepareTransactionAsIntent = prepareTransactionAsIntent;
+exports.submitIntentInternal = submitIntentInternal;
+exports.getValidatorAccount = getValidatorAccount;
+exports.parseCalls = parseCalls;
+const viem_1 = require("viem");
+const account_abstraction_1 = require("viem/account-abstraction");
+const accounts_1 = require("../accounts");
+const utils_1 = require("../accounts/utils");
+const validators_1 = require("../modules/validators");
+const core_1 = require("../modules/validators/core");
+const orchestrator_1 = require("../orchestrator");
+const consts_1 = require("../orchestrator/consts");
+const registry_1 = require("../orchestrator/registry");
+const error_1 = require("./error");
+async function prepareTransaction(config, transaction) {
+    const { sourceChains, targetChain, tokenRequests, signers, sponsored, eip7702InitSignature, } = getTransactionParams(transaction);
+    const accountAddress = (0, accounts_1.getAddress)(config);
+    let data;
+    const asUserOp = signers?.type === 'guardians' || signers?.type === 'session';
+    if (asUserOp) {
+        if (sourceChains && sourceChains.length > 0) {
+            throw new error_1.SourceChainsNotAvailableForUserOpFlowError();
+        }
+        // Smart sessions require a UserOp flow
+        data = await prepareTransactionAsUserOp(config, targetChain, transaction.calls, signers);
+    }
+    else {
+        data = await prepareTransactionAsIntent(config, sourceChains, targetChain, transaction.calls, transaction.gasLimit, tokenRequests, accountAddress, sponsored ?? false, eip7702InitSignature);
+    }
+    return {
+        data,
+        transaction,
+    };
+}
+async function signTransaction(config, preparedTransaction) {
+    const { targetChain, signers } = getTransactionParams(preparedTransaction.transaction);
+    const data = preparedTransaction.data;
+    const asUserOp = data.type === 'userop';
+    let signature;
+    if (asUserOp) {
+        const chain = targetChain;
+        const userOp = data.userOp;
+        if (!userOp) {
+            throw new error_1.UserOperationRequiredForSmartSessionsError();
+        }
+        // Smart sessions require a UserOp flow
+        signature = await signUserOp(config, chain, signers, userOp);
+    }
+    else {
+        signature = await signIntent(config, targetChain, data.hash, signers);
+    }
+    return {
+        data,
+        transaction: preparedTransaction.transaction,
+        signature,
+    };
+}
+async function signAuthorizations(config, preparedTransaction) {
+    return await signAuthorizationsInternal(config, preparedTransaction.data);
+}
+async function signAuthorizationsInternal(config, data) {
+    const eoa = config.eoa;
+    if (!eoa) {
+        throw new Error('EIP-7702 initialization is required for EOA accounts');
+    }
+    const accountAddress = (0, accounts_1.getAddress)(config);
+    const requiredDelegations = data.type === 'intent'
+        ? data.intentRoute.intentOp.signedMetadata.account.requiredDelegations ||
+            {}
+        : {};
+    const authorizations = [];
+    for (const chainId in requiredDelegations) {
+        const delegation = requiredDelegations[chainId];
+        const chain = (0, registry_1.getChainById)(Number(chainId));
+        if (!chain) {
+            throw new Error(`Chain not supported: ${chainId}`);
+        }
+        const walletClient = (0, viem_1.createWalletClient)({
+            chain,
+            account: eoa,
+            transport: (0, utils_1.createTransport)(chain, config.provider),
+        }).extend(viem_1.publicActions);
+        const code = await walletClient.getCode({
+            address: accountAddress,
+        });
+        const isDelegated = code === (0, viem_1.concat)(['0xef0100', delegation.contract.toLowerCase()]);
+        if (isDelegated) {
+            continue;
+        }
+        const authorization = await walletClient.signAuthorization({
+            contractAddress: delegation.contract,
+            chainId: Number(chainId),
+        });
+        authorizations.push(authorization);
+    }
+    return authorizations;
+}
+async function submitTransaction(config, signedTransaction, authorizations) {
+    const { data, transaction, signature } = signedTransaction;
+    const { sourceChains, targetChain } = getTransactionParams(transaction);
+    const asUserOp = data.type === 'userop';
+    if (asUserOp) {
+        const chain = targetChain;
+        const userOp = data.userOp;
+        if (!userOp) {
+            throw new error_1.UserOperationRequiredForSmartSessionsError();
+        }
+        // Smart sessions require a UserOp flow
+        return await submitUserOp(config, chain, userOp, signature);
+    }
+    else {
+        const intentOp = data.intentRoute.intentOp;
+        if (!intentOp) {
+            throw new error_1.OrderPathRequiredForIntentsError();
+        }
+        return await submitIntent(config, sourceChains, targetChain, intentOp, signature, authorizations);
+    }
+}
+function getTransactionParams(transaction) {
+    const sourceChains = 'chain' in transaction ? [transaction.chain] : transaction.sourceChains;
+    const targetChain = 'chain' in transaction ? transaction.chain : transaction.targetChain;
+    const initialTokenRequests = transaction.tokenRequests;
+    const signers = transaction.signers;
+    const eip7702InitSignature = transaction.eip7702InitSignature;
+    const sponsored = transaction.sponsored;
+    // Across requires passing some value to repay the solvers
+    const tokenRequests = !initialTokenRequests || initialTokenRequests.length === 0
+        ? [
+            {
+                address: viem_1.zeroAddress,
+                amount: 1n,
+            },
+        ]
+        : initialTokenRequests;
+    return {
+        sourceChains,
+        targetChain,
+        tokenRequests,
+        signers,
+        sponsored,
+        eip7702InitSignature,
+    };
+}
+async function prepareTransactionAsUserOp(config, chain, callInputs, signers) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, utils_1.createTransport)(chain, config.provider),
+    });
+    const validatorAccount = await getValidatorAccount(config, signers, publicClient, chain);
+    if (!validatorAccount) {
+        throw new Error('No validator account found');
+    }
+    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+    const calls = parseCalls(callInputs, chain.id);
+    const userOp = await bundlerClient.prepareUserOperation({
+        account: validatorAccount,
+        calls,
+    });
+    return {
+        type: 'userop',
+        userOp,
+        hash: (0, account_abstraction_1.getUserOperationHash)({
+            userOperation: userOp,
+            chainId: chain.id,
+            entryPointAddress: account_abstraction_1.entryPoint07Address,
+            entryPointVersion: '0.7',
+        }),
+    };
+}
+async function prepareTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress, isSponsored, eip7702InitSignature) {
+    const calls = parseCalls(callInputs, targetChain.id);
+    const accountAccessList = sourceChains && sourceChains.length > 0
+        ? {
+            chainIds: sourceChains.map((chain) => chain.id),
+        }
+        : undefined;
+    const { setupOps, delegations } = await getSetupOperationsAndDelegations(config, accountAddress, eip7702InitSignature);
+    const metaIntent = {
+        destinationChainId: targetChain.id,
+        tokenTransfers: tokenRequests.map((tokenRequest) => ({
+            tokenAddress: (0, registry_1.resolveTokenAddress)(tokenRequest.address, targetChain.id),
+            amount: tokenRequest.amount,
+        })),
+        account: {
+            address: accountAddress,
+            accountType: 'ERC7579',
+            setupOps: setupOps || [],
+            delegations,
+        },
+        destinationExecutions: calls,
+        destinationGasUnits: gasLimit,
+        accountAccessList,
+        options: {
+            topupCompact: false,
+            sponsorSettings: {
+                gasSponsored: isSponsored,
+                bridgeFeesSponsored: isSponsored,
+                swapFeesSponsored: isSponsored,
+            },
+        },
+    };
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
+    const intentRoute = await orchestrator.getIntentRoute(metaIntent);
+    const intentHash = (0, orchestrator_1.getIntentOpHash)(intentRoute.intentOp);
+    return {
+        type: 'intent',
+        intentRoute,
+        hash: intentHash,
+    };
+}
+async function signIntent(config, targetChain, intentHash, signers) {
+    const validator = getValidator(config, signers);
+    if (!validator) {
+        throw new Error('Validator not available');
+    }
+    const ownerValidator = (0, validators_1.getOwnerValidator)(config);
+    const isRoot = validator.address === ownerValidator.address;
+    const signature = await (0, accounts_1.getPackedSignature)(config, signers, targetChain, {
+        address: validator.address,
+        isRoot,
+    }, intentHash);
+    return signature;
+}
+async function signUserOp(config, chain, signers, userOp) {
+    const validator = getValidator(config, signers);
+    if (!validator) {
+        throw new Error('Validator not available');
+    }
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, utils_1.createTransport)(chain, config.provider),
+    });
+    const account = await getValidatorAccount(config, signers, publicClient, chain);
+    if (!account) {
+        throw new Error('No account found');
+    }
+    return await account.signUserOperation(userOp);
+}
+async function submitUserOp(config, chain, userOp, signature) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, utils_1.createTransport)(chain, config.provider),
+    });
+    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+    const hash = await bundlerClient.request({
+        method: 'eth_sendUserOperation',
+        params: [
+            {
+                sender: userOp.sender,
+                nonce: (0, viem_1.toHex)(userOp.nonce),
+                factory: userOp.factory,
+                factoryData: userOp.factoryData,
+                callData: userOp.callData,
+                callGasLimit: (0, viem_1.toHex)(userOp.callGasLimit),
+                verificationGasLimit: (0, viem_1.toHex)(userOp.verificationGasLimit),
+                preVerificationGas: (0, viem_1.toHex)(userOp.preVerificationGas),
+                maxPriorityFeePerGas: (0, viem_1.toHex)(userOp.maxPriorityFeePerGas),
+                maxFeePerGas: (0, viem_1.toHex)(userOp.maxFeePerGas),
+                paymaster: userOp.paymaster,
+                paymasterVerificationGasLimit: userOp.paymasterVerificationGasLimit
+                    ? (0, viem_1.toHex)(userOp.paymasterVerificationGasLimit)
+                    : undefined,
+                paymasterPostOpGasLimit: userOp.paymasterPostOpGasLimit
+                    ? (0, viem_1.toHex)(userOp.paymasterPostOpGasLimit)
+                    : undefined,
+                paymasterData: userOp.paymasterData,
+                signature,
+            },
+            account_abstraction_1.entryPoint07Address,
+        ],
+    });
+    return {
+        type: 'userop',
+        hash,
+        chain: chain.id,
+    };
+}
+async function submitIntent(config, sourceChains, targetChain, intentOp, signature, authorizations) {
+    return submitIntentInternal(config, sourceChains, targetChain, intentOp, signature, authorizations);
+}
+function getOrchestratorByChain(chainId, apiKey) {
+    const orchestratorUrl = (0, registry_1.isTestnet)(chainId)
+        ? consts_1.STAGING_ORCHESTRATOR_URL
+        : consts_1.PROD_ORCHESTRATOR_URL;
+    return (0, orchestrator_1.getOrchestrator)(apiKey, orchestratorUrl);
+}
+async function submitIntentInternal(config, sourceChains, targetChain, intentOp, signature, authorizations) {
+    const signedIntentOp = {
+        ...intentOp,
+        originSignatures: Array(intentOp.elements.length).fill(signature),
+        destinationSignature: signature,
+        signedAuthorizations: authorizations.length > 0
+            ? authorizations.map((authorization) => ({
+                chainId: authorization.chainId,
+                address: authorization.address,
+                nonce: authorization.nonce,
+                yParity: authorization.yParity ?? 0,
+                r: authorization.r,
+                s: authorization.s,
+            }))
+            : undefined,
+    };
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
+    const intentResults = await orchestrator.submitIntent(signedIntentOp);
+    return {
+        type: 'intent',
+        id: BigInt(intentResults.result.id),
+        sourceChains: sourceChains?.map((chain) => chain.id),
+        targetChain: targetChain.id,
+    };
+}
+async function getValidatorAccount(config, signers, publicClient, chain) {
+    if (!signers) {
+        return undefined;
+    }
+    // Owners
+    const withOwner = signers.type === 'owner' ? signers : null;
+    if (withOwner) {
+        return (0, accounts_1.getSmartAccount)(config, publicClient, chain);
+    }
+    const withSession = signers.type === 'session' ? signers : null;
+    const withGuardians = signers.type === 'guardians' ? signers : null;
+    return withSession
+        ? await (0, accounts_1.getSmartSessionSmartAccount)(config, publicClient, chain, withSession.session, withSession.enableData || null)
+        : withGuardians
+            ? await (0, accounts_1.getGuardianSmartAccount)(config, publicClient, chain, {
+                type: 'ecdsa',
+                accounts: withGuardians.guardians,
+            })
+            : null;
+}
+function getValidator(config, signers) {
+    if (!signers) {
+        return (0, validators_1.getOwnerValidator)(config);
+    }
+    // Owners
+    const withOwner = signers.type === 'owner' ? signers : null;
+    if (withOwner) {
+        // ECDSA
+        if (withOwner.kind === 'ecdsa') {
+            return (0, core_1.getOwnableValidator)(1, withOwner.accounts.map((account) => account.address));
+        }
+        // Passkeys (WebAuthn)
+        if (withOwner.kind === 'passkey') {
+            const passkeyAccount = withOwner.account;
+            return (0, core_1.getWebAuthnValidator)({
+                pubKey: passkeyAccount.publicKey,
+                authenticatorId: passkeyAccount.id,
+            });
+        }
+        // Multi-factor
+        if (withOwner.kind === 'multi-factor') {
+            // Convert validators to proper format
+            const validators = withOwner.validators.map(validator => {
+                if (validator.type === 'ecdsa') {
+                    return { type: 'ecdsa', accounts: validator.accounts, threshold: 1 };
+                }
+                else {
+                    return { type: 'passkey', account: validator.account, credentialIds: [] };
+                }
+            });
+            return (0, core_1.getMultiFactorValidator)(1, validators);
+        }
+    }
+    // Smart sessions
+    const withSession = signers.type === 'session' ? signers.session : null;
+    if (withSession) {
+        return (0, validators_1.getSmartSessionValidator)(config);
+    }
+    // Guardians (social recovery)
+    const withGuardians = signers.type === 'guardians' ? signers : null;
+    if (withGuardians) {
+        return (0, core_1.getSocialRecoveryValidator)(withGuardians.guardians);
+    }
+    // Fallback
+    return undefined;
+}
+function parseCalls(calls, chainId) {
+    return calls.map((call) => ({
+        data: call.data ?? '0x',
+        value: call.value ?? 0n,
+        to: (0, registry_1.resolveTokenAddress)(call.to, chainId),
+    }));
+}
+async function getSetupOperationsAndDelegations(config, accountAddress, eip7702InitSignature) {
+    const initCode = (0, accounts_1.getInitCode)(config);
+    if (config.eoa) {
+        // EIP-7702 initialization is only needed for EOA accounts
+        if (!eip7702InitSignature || eip7702InitSignature === '0x') {
+            throw new Error('EIP-7702 initialization signature is required for EOA accounts');
+        }
+        const { initData: eip7702InitData, contract: eip7702Contract } = await (0, accounts_1.getEip7702InitCall)(config, eip7702InitSignature);
+        return {
+            setupOps: [
+                {
+                    to: accountAddress,
+                    data: eip7702InitData,
+                },
+            ],
+            delegations: {
+                0: {
+                    contract: eip7702Contract,
+                },
+            },
+        };
+    }
+    else if (initCode) {
+        // Contract account with init code
+        return {
+            setupOps: [
+                {
+                    to: initCode.factory,
+                    data: initCode.factoryData,
+                },
+            ],
+        };
+    }
+    else {
+        // Already deployed contract account
+        return {
+            setupOps: [],
+        };
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,41 @@
+import type { Address, Chain, Hex, SignedAuthorizationList } from 'viem';
+import type { UserOperationReceipt } from 'viem/account-abstraction';
+import { AccountError, Eip7702AccountMustHaveEoaError, Eip7702NotSupportedForAccountError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, isAccountError, SigningNotSupportedForAccountError, SignMessageNotSupportedByAccountError, SmartSessionsNotEnabledError } from './accounts';
+import { createTransport } from './accounts/utils';
+import { addOwner, changeMultiFactorThreshold, changeThreshold, disableEcdsa, disableMultiFactor, disablePasskeys, enableEcdsa, enableMultiFactor, enablePasskeys, encodeSmartSessionSignature, recover, removeOwner, removeSubValidator, setSubValidator, setUpRecovery } from './actions';
+import type { TransactionResult } from './execution';
+import { ExecutionError, IntentFailedError, isExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError } from './execution';
+import { type SessionDetails } from './execution/smart-session';
+import { type IntentData, type PreparedTransactionData, type SignedTransactionData } from './execution/utils';
+import { AuthenticationRequiredError, InsufficientBalanceError, type IntentCost, type IntentInput, IntentNotFoundError, type IntentOp, type IntentOpStatus, type IntentResult, type IntentRoute, InvalidApiKeyError, InvalidIntentSignatureError, isOrchestratorError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, type Portfolio, type SettlementSystem, type SignedIntentOp, TokenNotSupportedError, UnsupportedChainError, UnsupportedChainIdError, UnsupportedTokenError } from './orchestrator';
+import type { Call, RhinestoneAccountConfig, Session, Transaction } from './types';
+interface RhinestoneAccount {
+    config: RhinestoneAccountConfig;
+    deploy: (chain: Chain, session?: Session) => Promise<void>;
+    signEip7702InitData: () => Promise<Hex>;
+    prepareTransaction: (transaction: Transaction) => Promise<PreparedTransactionData>;
+    signTransaction: (preparedTransaction: PreparedTransactionData) => Promise<SignedTransactionData>;
+    signAuthorizations: (preparedTransaction: PreparedTransactionData) => Promise<SignedAuthorizationList>;
+    submitTransaction: (signedTransaction: SignedTransactionData, authorizations?: SignedAuthorizationList) => Promise<TransactionResult>;
+    sendTransaction: (transaction: Transaction) => Promise<TransactionResult>;
+    waitForExecution: (result: TransactionResult, acceptsPreconfirmations?: boolean) => Promise<IntentOpStatus | UserOperationReceipt>;
+    getAddress: () => Address;
+    getPortfolio: (onTestnets?: boolean) => Promise<Portfolio>;
+    getMaxSpendableAmount: (chain: Chain, tokenAddress: Address, gasUnits: bigint) => Promise<bigint>;
+    getSessionDetails: (sessions: Session[], sessionIndex: number, signature?: Hex) => Promise<SessionDetails>;
+    getOwners: (chain: Chain) => Promise<{
+        accounts: Address[];
+        threshold: number;
+    } | null>;
+    getValidators: (chain: Chain) => Promise<Address[]>;
+}
+/**
+ * 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: RhinestoneAccountConfig): Promise<RhinestoneAccount>;
+export { createRhinestoneAccount, createTransport, addOwner, changeMultiFactorThreshold, changeThreshold, disableEcdsa, disableMultiFactor, disablePasskeys, enableEcdsa, enableMultiFactor, enablePasskeys, encodeSmartSessionSignature, recover, removeOwner, removeSubValidator, setSubValidator, setUpRecovery, isAccountError, AccountError, Eip7702AccountMustHaveEoaError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, SmartSessionsNotEnabledError, SigningNotSupportedForAccountError, SignMessageNotSupportedByAccountError, Eip7702NotSupportedForAccountError, isExecutionError, IntentFailedError, ExecutionError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError, OrderPathRequiredForIntentsError, SessionChainRequiredError, isOrchestratorError, AuthenticationRequiredError, InsufficientBalanceError, InvalidApiKeyError, InvalidIntentSignatureError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, IntentNotFoundError, TokenNotSupportedError, UnsupportedChainError, UnsupportedChainIdError, UnsupportedTokenError, };
+export type { RhinestoneAccount, Session, Call, IntentData, PreparedTransactionData, SignedTransactionData, TransactionResult, IntentCost, IntentInput, IntentOp, IntentOpStatus, IntentResult, IntentRoute, SettlementSystem, SignedIntentOp, Portfolio, };
+//# 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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"}