@rhinestone/sdk 2.0.0-beta.44 → 2.0.0-beta.45

package/dist/src/api/direct-signing.d.ts

@@ -0,0 +1,27 @@
+import { type Hex, type SignableMessage, type TypedDataDefinition } from 'viem';
+import type { AccountRuntime } from '../accounts/adapter.js';
+import type { EvmChainReference } from '../chains/types.js';
+import type { ResolvedSessionSignerSet } from '../modules/validators/smart-sessions/types.js';
+import type { OwnerSignerSelection, SignerInvocationPort, SigningCheckpointPort, SigningTranscript } from '../signing/types.js';
+interface RuntimeSigningInput {
+    readonly chain: EvmChainReference;
+    readonly runtime: AccountRuntime;
+    readonly signerInvoker: SignerInvocationPort;
+    readonly checkpoints: SigningCheckpointPort;
+    readonly selection?: OwnerSignerSelection;
+    readonly session?: ResolvedSessionSignerSet;
+}
+export declare function signRuntimeMessage(input: RuntimeSigningInput & {
+    readonly message: SignableMessage;
+}): Promise<{
+    readonly signature: Hex;
+    readonly transcript: SigningTranscript;
+}>;
+export declare function signRuntimeTypedData(input: RuntimeSigningInput & {
+    readonly typedData: TypedDataDefinition;
+}): Promise<{
+    readonly signature: Hex;
+    readonly transcript: SigningTranscript;
+}>;
+export {};
+//# sourceMappingURL=direct-signing.d.ts.map

package/dist/src/api/direct-signing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"direct-signing.d.ts","sourceRoot":"","sources":["../../../api/direct-signing.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,GAAG,EAGR,KAAK,eAAe,EACpB,KAAK,mBAAmB,EAEzB,MAAM,MAAM,CAAA;AACb,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAIxD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAA;AAa1F,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,kBAAkB,CAAA;AAEzB,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,QAAQ,CAAC,aAAa,EAAE,oBAAoB,CAAA;IAC5C,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAA;IAC3C,QAAQ,CAAC,SAAS,CAAC,EAAE,oBAAoB,CAAA;IACzC,QAAQ,CAAC,OAAO,CAAC,EAAE,wBAAwB,CAAA;CAC5C;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,mBAAmB,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;CAAE,GACjE,OAAO,CAAC;IACT,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAA;CACvC,CAAC,CA4ED;AAED,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,mBAAmB,GAAG;IAAE,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;CAAE,GACvE,OAAO,CAAC;IACT,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAA;CACvC,CAAC,CAyDD"}

package/dist/src/api/direct-signing.js

@@ -0,0 +1,191 @@
+import { encodePacked, hashMessage, pad, zeroHash, } from 'viem';
+import { wrapKernelMessageHash } from '../accounts/adapters/kernel.js';
+import { defineValidator } from '../modules/validators/definition.js';
+import { getPermissionId } from '../modules/validators/smart-sessions/digest.js';
+import { getSmartSessionEmissaryAddress } from '../modules/validators/smart-sessions/module.js';
+import { createAccountSigningContext, getAccountSignatureRoute, getSigningValidatorCodec, } from '../signing/context.js';
+import { signAccountMessage } from '../signing/message.js';
+import { createValidatorSigningTasks, signingTopology } from '../signing/plan.js';
+import { resolveAccountTypedDataSigning, signAccountTypedData, } from '../signing/typed-data.js';
+export async function signRuntimeMessage(input) {
+    const selection = input.session
+        ? sessionOwnerSelection(input.session)
+        : input.selection;
+    const context = createAccountSigningContext({
+        runtime: input.runtime,
+        purpose: 'erc1271',
+        signerInvoker: input.signerInvoker,
+        ...(selection ? { selection } : {}),
+    });
+    const topology = signingTopology(context.validator, selection?.signerIds);
+    const payload = hashMessage(input.message);
+    const accountHash = input.runtime.construction.account.kind === 'kernel'
+        ? wrapKernelMessageHash(payload, context.account.address)
+        : payload;
+    const signingMaterial = input.session
+        ? {
+            kind: 'message',
+            message: {
+                raw: hashMessage({
+                    raw: encodePacked(['bytes32', 'bytes32'], [pad(context.account.address, { size: 32 }), accountHash]),
+                }),
+            },
+        }
+        : input.runtime.construction.account.kind === 'kernel'
+            ? {
+                kind: 'message',
+                message: { raw: accountHash },
+            }
+            : undefined;
+    const route = getAccountSignatureRoute(input.runtime, context);
+    return signAccountMessage({
+        context,
+        checkpoints: input.checkpoints,
+        planInput: {
+            message: input.message,
+            ...(signingMaterial ? { signingMaterial } : {}),
+            chain: input.chain,
+            ...topology,
+            tasks: createValidatorSigningTasks({
+                validator: context.validator,
+                signerReferences: context.signerReferences,
+                taskPrefix: 'message',
+                ecdsaInvocation: 'ecdsa-sign-message',
+                webauthnInvocation: 'webauthn-sign-hash',
+                ...(selection ? { selectedSignerIds: selection.signerIds } : {}),
+            }),
+            route: input.session
+                ? {
+                    ...route,
+                    validatorCodec: {
+                        kind: 'smart-session',
+                        validator: {
+                            kind: 'validator',
+                            address: getSmartSessionEmissaryAddress(input.runtime.construction.sessions.environment),
+                        },
+                        mode: 'notarized',
+                        permissionId: getPermissionId(input.session.session),
+                        signerCodec: requireSessionOwnerCodec(getSigningValidatorCodec(context)),
+                    },
+                    accountEnvelope: smartSessionEnvelope(route.accountEnvelope, input.runtime.construction.sessions.environment),
+                }
+                : route,
+        },
+    });
+}
+export async function signRuntimeTypedData(input) {
+    const selection = input.session
+        ? sessionOwnerSelection(input.session)
+        : input.selection;
+    const context = createAccountSigningContext({
+        runtime: input.runtime,
+        purpose: 'erc1271',
+        signerInvoker: input.signerInvoker,
+        ...(selection ? { selection } : {}),
+    });
+    const topology = signingTopology(context.validator, selection?.signerIds);
+    const typedData = input.session
+        ? sessionTypedData(input.typedData, input.runtime, input.chain)
+        : input.typedData;
+    const route = resolveAccountTypedDataSigning({
+        typedData,
+        chain: input.chain,
+        context,
+    });
+    const accountRoute = getAccountSignatureRoute(input.runtime, context, route.erc7739, route.payloadKind);
+    return signAccountTypedData({
+        context,
+        checkpoints: input.checkpoints,
+        planInput: {
+            typedData,
+            signingMaterial: route.material,
+            chain: input.chain,
+            ...topology,
+            tasks: createValidatorSigningTasks({
+                validator: context.validator,
+                signerReferences: context.signerReferences,
+                taskPrefix: 'typed-data',
+                ecdsaInvocation: route.ecdsaInvocation,
+                webauthnInvocation: route.webauthnInvocation,
+                ...(selection ? { selectedSignerIds: selection.signerIds } : {}),
+            }),
+            route: input.session
+                ? {
+                    ...accountRoute,
+                    erc7739: {
+                        kind: 'wrap-session-typed-data',
+                        typedData: input.typedData,
+                        permissionId: getPermissionId(input.session.session),
+                    },
+                    accountEnvelope: smartSessionEnvelope(accountRoute.accountEnvelope, input.runtime.construction.sessions.environment),
+                }
+                : accountRoute,
+        },
+    });
+}
+function sessionOwnerSelection(session) {
+    const validator = defineValidator(session.session.owners, 'smart-session-validator');
+    return {
+        kind: 'owner',
+        validator,
+        signerIds: validator.kind === 'multi-factor'
+            ? validator.validators.flatMap((factor) => factor.owners.map(({ signerId }) => signerId))
+            : validator.owners.map(({ signerId }) => signerId),
+    };
+}
+function requireSessionOwnerCodec(codec) {
+    if (codec.kind === 'smart-session') {
+        throw new Error('A Smart Session owner cannot use a session validator');
+    }
+    return codec;
+}
+function smartSessionEnvelope(envelope, environment) {
+    if (envelope.kind === 'none')
+        return envelope;
+    const validator = getSmartSessionEmissaryAddress(environment);
+    return envelope.kind === 'kernel'
+        ? { ...envelope, validator, isRoot: false }
+        : { ...envelope, validator };
+}
+function sessionTypedData(typedData, runtime, chain) {
+    const verifier = sessionVerifierDomain(runtime, chain);
+    return {
+        domain: typedData.domain,
+        primaryType: 'TypedDataSign',
+        types: {
+            ...typedData.types,
+            TypedDataSign: [
+                { name: 'contents', type: typedData.primaryType },
+                { name: 'name', type: 'string' },
+                { name: 'version', type: 'string' },
+                { name: 'chainId', type: 'uint256' },
+                { name: 'verifyingContract', type: 'address' },
+                { name: 'salt', type: 'bytes32' },
+            ],
+        },
+        message: {
+            contents: typedData.message,
+            ...verifier,
+        },
+    };
+}
+function sessionVerifierDomain(runtime, chain) {
+    const common = {
+        chainId: chain.id,
+        verifyingContract: runtime.identity.address,
+        salt: zeroHash,
+    };
+    switch (runtime.construction.account.kind) {
+        case 'safe':
+            return { ...common, name: 'rhinestone safe7579', version: 'v1.0.0' };
+        case 'nexus':
+        case 'hca':
+            return { ...common, name: 'Nexus', version: '1.2.0' };
+        case 'kernel':
+            return { ...common, name: 'Kernel', version: '0.3.3' };
+        case 'startale':
+            return { ...common, name: 'Startale', version: '1.0.0' };
+        case 'eoa':
+            throw new Error('EOA accounts do not have an EIP-712 domain');
+    }
+}

package/dist/src/api/project-mappers.d.ts

@@ -0,0 +1,7 @@
+import type { SplitIntentsInput, SplitIntentsResult } from '../clients/orchestrator/public.js';
+import type { OrchestratorSplitRequest, OrchestratorSplitResult } from '../clients/orchestrator/types.js';
+import type { IntentStatus, TransactionStatus } from '../transactions/intents/types.js';
+export declare function toPublicTransactionStatus(status: IntentStatus): TransactionStatus;
+export declare function toOrchestratorSplitRequest(input: SplitIntentsInput): OrchestratorSplitRequest;
+export declare function toPublicSplitResult(result: OrchestratorSplitResult): SplitIntentsResult;
+//# sourceMappingURL=project-mappers.d.ts.map

package/dist/src/api/project-mappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-mappers.d.ts","sourceRoot":"","sources":["../../../api/project-mappers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,gCAAgC,CAAA;AACvC,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AACtC,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EAClB,MAAM,+BAA+B,CAAA;AAEtC,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,YAAY,GACnB,iBAAiB,CAOnB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,iBAAiB,GACvB,wBAAwB,CAQ1B;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,uBAAuB,GAC9B,kBAAkB,CAKpB"}

package/dist/src/api/project-mappers.js

@@ -0,0 +1,23 @@
+export function toPublicTransactionStatus(status) {
+    return {
+        traceId: status.traceId,
+        status: status.status,
+        accountAddress: status.account,
+        operations: [...status.operations],
+    };
+}
+export function toOrchestratorSplitRequest(input) {
+    return {
+        chainId: input.chain.id,
+        tokens: input.tokens,
+        ...(input.settlementLayers
+            ? { settlementLayers: input.settlementLayers }
+            : {}),
+    };
+}
+export function toPublicSplitResult(result) {
+    return {
+        traceId: result.traceId,
+        intents: result.intents.map((intent) => ({ ...intent })),
+    };
+}

package/dist/src/api/queries/app-fees.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectQueryPort } from '../../clients/orchestrator/port.js';
+import type { OrchestratorAppFeeBalances } from '../../clients/orchestrator/types.js';
+export declare function getAppFeeBalances(client: ProjectQueryPort): Promise<OrchestratorAppFeeBalances>;
+//# sourceMappingURL=app-fees.d.ts.map

package/dist/src/api/queries/app-fees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-fees.d.ts","sourceRoot":"","sources":["../../../../api/queries/app-fees.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AACvE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAA;AAElF,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,0BAA0B,CAAC,CAErC"}

package/dist/src/api/queries/app-fees.js

@@ -0,0 +1,3 @@
+export function getAppFeeBalances(client) {
+    return client.getAppFeeBalances();
+}

package/dist/src/api/queries/portfolio.d.ts

@@ -0,0 +1,9 @@
+import type { AccountRuntimePort } from '../../accounts/adapter.js';
+import type { AccountQueryPort, ChainCatalogPort } from '../../clients/orchestrator/port.js';
+import type { OrchestratorPortfolio } from '../../clients/orchestrator/types.js';
+export declare function getPortfolio(input: {
+    readonly account: AccountRuntimePort;
+    readonly client: AccountQueryPort & ChainCatalogPort;
+    readonly onTestnets: boolean;
+}): Promise<OrchestratorPortfolio>;
+//# sourceMappingURL=portfolio.d.ts.map

package/dist/src/api/queries/portfolio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portfolio.d.ts","sourceRoot":"","sources":["../../../../api/queries/portfolio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAEhE,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,iCAAiC,CAAA;AACxC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAA;AAE7E,wBAAsB,YAAY,CAAC,KAAK,EAAE;IACxC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;IACpC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAAA;IACpD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;CAC7B,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA6BjC"}

package/dist/src/api/queries/portfolio.js

@@ -0,0 +1,28 @@
+import { toEvmChainReference } from '../../chains/caip2.js';
+export async function getPortfolio(input) {
+    // Filter on the catalog's own `testnet` flag — authoritative for every chain
+    // the orchestrator supports (incl. non-EVM and chains newer than the SDK's
+    // viem). Filtering through viem would silently drop unknown chains, so their
+    // balances would disappear until an SDK/viem bump.
+    const catalog = await input.client.getChainCatalog();
+    const chainIds = catalog
+        .getSupportedChainIds()
+        .filter((chainId) => catalog.isTestnet(chainId) === input.onTestnets);
+    const accountChainId = chainIds.find((chainId) => {
+        try {
+            toEvmChainReference(chainId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (accountChainId === undefined) {
+        throw new Error('No EVM chain is available for portfolio account resolution');
+    }
+    const runtime = await input.account.forChain(toEvmChainReference(accountChainId));
+    return input.client.getPortfolio({
+        account: runtime.identity.address,
+        chainIds,
+    });
+}

package/dist/src/api/queries/session.d.ts

@@ -0,0 +1,8 @@
+import type { ChainCatalogPort } from '../../clients/orchestrator/port.js';
+import type { Session, SessionDefinition } from '../../modules/validators/smart-sessions/types.js';
+export declare function createSession(input: {
+    readonly orchestrator: ChainCatalogPort;
+    readonly environment: 'production' | 'development';
+    readonly definition: SessionDefinition;
+}): Promise<Session>;
+//# sourceMappingURL=session.d.ts.map

package/dist/src/api/queries/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../api/queries/session.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAEvE,OAAO,KAAK,EACV,OAAO,EACP,iBAAiB,EAClB,MAAM,+CAA+C,CAAA;AAEtD,wBAAsB,aAAa,CAAC,KAAK,EAAE;IACzC,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAA;IACvC,QAAQ,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,CAAA;IAClD,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAA;CACvC,GAAG,OAAO,CAAC,OAAO,CAAC,CAiBnB"}

package/dist/src/api/queries/session.js

@@ -0,0 +1,15 @@
+import { toSession } from '../../modules/validators/smart-sessions/resolve.js';
+export async function createSession(input) {
+    const catalog = await input.orchestrator.getChainCatalog();
+    const wrappedNativeToken = catalog.getWrappedNativeToken(input.definition.chain.id)?.address;
+    // Fail fast: without the wrapped-native address we can't add the native-wrap
+    // `deposit()` permission, and a silently under-scoped session would
+    // sign/enable fine but break native-wrap intents later.
+    if (!wrappedNativeToken) {
+        throw new Error(`createSession: the orchestrator's /chains has no wrapped-native token for chain ${input.definition.chain.id}. The chain must be supported and advertise its wrappedNativeToken.`);
+    }
+    return toSession(input.definition, {
+        wrappedNativeToken,
+        environment: input.environment,
+    });
+}

package/dist/src/api/sdk.d.ts

@@ -0,0 +1,80 @@
+import type { AppFeeBalances, SplitIntentsInput, SplitIntentsResult } from '../clients/orchestrator/public.js';
+import type { RhinestoneAccountConfig, RhinestoneSDKConfig } from '../config/account.js';
+import type { Session, SessionDefinition } from '../modules/validators/smart-sessions/types.js';
+import type { TransactionStatus } from '../transactions/intents/types.js';
+import type { RhinestoneAccount } from './account.js';
+/**
+ * Stateful entry point that holds shared configuration (auth, provider,
+ * bundler, paymaster) and creates accounts from it, delegating all work to the
+ * SDK-core composition.
+ */
+declare class RhinestoneSDK {
+    #private;
+    private authProvider;
+    private endpointUrl;
+    private provider;
+    private bundler;
+    private paymaster;
+    private useDevContracts;
+    private headers;
+    /**
+     * Create a Rhinestone SDK instance.
+     * @param options Shared configuration applied to every account created by this instance
+     */
+    constructor(options: RhinestoneSDKConfig);
+    /**
+     * Create an account using this instance's shared configuration.
+     * @param config Per-account configuration (owners, account type, modules, sessions)
+     * @returns The account instance
+     * @example
+     * ```ts
+     * import { RhinestoneSDK } from '@rhinestone/sdk'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const owner = privateKeyToAccount('0x...')
+     *
+     * const sdk = new RhinestoneSDK({
+     *   auth: { mode: 'apiKey', apiKey: process.env.RHINESTONE_API_KEY! },
+     * })
+     *
+     * const account = await sdk.createAccount({
+     *   owners: { type: 'ecdsa', accounts: [owner] },
+     * })
+     * ```
+     */
+    createAccount(config: RhinestoneAccountConfig): Promise<RhinestoneAccount>;
+    /**
+     * Get the current status of a submitted intent.
+     * @param intentId The intent ID returned when the transaction was submitted
+     * @returns The intent status
+     */
+    getIntentStatus(intentId: string): Promise<TransactionStatus>;
+    /**
+     * Split a transaction into multiple intents across chains.
+     * @param input The intents to split
+     * @returns The split-intents result
+     */
+    splitIntents(input: SplitIntentsInput): Promise<SplitIntentsResult>;
+    /**
+     * Get the integrator's accrued app-fee balance, as USD totals.
+     *
+     * App fees are earned by the integrator identified by this instance's API key
+     * (project-scoped, not tied to any account) and valued in USD at the moment
+     * each fee is collected, so the balance is not affected by later price
+     * movements of the collected tokens.
+     * @returns The withdrawable and pending app-fee balances in USD
+     */
+    getAppFeeBalances(): Promise<AppFeeBalances>;
+    /**
+     * Create a smart session, resolving the chain's wrapped-native token from the
+     * orchestrator's chain catalog (`GET /chains`) so native-token wrapping is
+     * permitted automatically. Project-scoped — needs the API key but no account.
+     * For a fully offline build, use the standalone {@link toSession} and pass
+     * `wrappedNativeToken` yourself.
+     * @param definition The session definition
+     * @returns The resolved session
+     */
+    createSession(definition: SessionDefinition): Promise<Session>;
+}
+export { RhinestoneSDK };
+//# sourceMappingURL=sdk.d.ts.map

package/dist/src/api/sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../../../api/sdk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,gCAAgC,CAAA;AACvC,OAAO,KAAK,EACV,uBAAuB,EACvB,mBAAmB,EACpB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,KAAK,EACV,OAAO,EACP,iBAAiB,EAClB,MAAM,4CAA4C,CAAA;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAQlD;;;;GAIG;AACH,cAAM,aAAa;;IAKjB,OAAO,CAAC,YAAY,CAAA;IACpB,OAAO,CAAC,WAAW,CAAA;IACnB,OAAO,CAAC,QAAQ,CAAA;IAChB,OAAO,CAAC,OAAO,CAAA;IACf,OAAO,CAAC,SAAS,CAAA;IACjB,OAAO,CAAC,eAAe,CAAA;IACvB,OAAO,CAAC,OAAO,CAAA;IAEf;;;OAGG;gBACS,OAAO,EAAE,mBAAmB;IAYxC;;;;;;;;;;;;;;;;;;;OAmBG;IACG,aAAa,CACjB,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,iBAAiB,CAAC;IAI7B;;;;OAIG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAM7D;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAMnE;;;;;;;;OAQG;IACH,iBAAiB,IAAI,OAAO,CAAC,cAAc,CAAC;IAI5C;;;;;;;;OAQG;IACH,aAAa,CAAC,UAAU,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC;CAG/D;AAED,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/dist/src/api/sdk.js

@@ -0,0 +1,103 @@
+import { attachAccount, composeSdk } from './accounts.js';
+import { toOrchestratorSplitRequest, toPublicSplitResult, toPublicTransactionStatus, } from './project-mappers.js';
+/**
+ * Stateful entry point that holds shared configuration (auth, provider,
+ * bundler, paymaster) and creates accounts from it, delegating all work to the
+ * SDK-core composition.
+ */
+class RhinestoneSDK {
+    #sdk;
+    // Retained shared-config slots. The composition owns the resolved values;
+    // these mirror the published field surface and let the instance answer
+    // config questions without re-reaching into the composition internals.
+    authProvider;
+    endpointUrl;
+    provider;
+    bundler;
+    paymaster;
+    useDevContracts;
+    headers;
+    /**
+     * Create a Rhinestone SDK instance.
+     * @param options Shared configuration applied to every account created by this instance
+     */
+    constructor(options) {
+        const input = options;
+        this.provider = input.provider;
+        this.bundler = input.bundler;
+        this.paymaster = input.paymaster;
+        this.endpointUrl = input.endpointUrl;
+        this.useDevContracts = input.useDevContracts;
+        this.headers = input.headers;
+        this.#sdk = composeSdk(input);
+        this.authProvider = this.#sdk.snapshot.authProvider;
+    }
+    /**
+     * Create an account using this instance's shared configuration.
+     * @param config Per-account configuration (owners, account type, modules, sessions)
+     * @returns The account instance
+     * @example
+     * ```ts
+     * import { RhinestoneSDK } from '@rhinestone/sdk'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const owner = privateKeyToAccount('0x...')
+     *
+     * const sdk = new RhinestoneSDK({
+     *   auth: { mode: 'apiKey', apiKey: process.env.RHINESTONE_API_KEY! },
+     * })
+     *
+     * const account = await sdk.createAccount({
+     *   owners: { type: 'ecdsa', accounts: [owner] },
+     * })
+     * ```
+     */
+    async createAccount(config) {
+        return attachAccount(this.#sdk, config);
+    }
+    /**
+     * Get the current status of a submitted intent.
+     * @param intentId The intent ID returned when the transaction was submitted
+     * @returns The intent status
+     */
+    getIntentStatus(intentId) {
+        return this.#sdk.composition.project
+            .getIntentStatus(intentId)
+            .then(toPublicTransactionStatus);
+    }
+    /**
+     * Split a transaction into multiple intents across chains.
+     * @param input The intents to split
+     * @returns The split-intents result
+     */
+    splitIntents(input) {
+        return this.#sdk.composition.project
+            .splitIntents(toOrchestratorSplitRequest(input))
+            .then(toPublicSplitResult);
+    }
+    /**
+     * Get the integrator's accrued app-fee balance, as USD totals.
+     *
+     * App fees are earned by the integrator identified by this instance's API key
+     * (project-scoped, not tied to any account) and valued in USD at the moment
+     * each fee is collected, so the balance is not affected by later price
+     * movements of the collected tokens.
+     * @returns The withdrawable and pending app-fee balances in USD
+     */
+    getAppFeeBalances() {
+        return this.#sdk.composition.project.getAppFeeBalances();
+    }
+    /**
+     * Create a smart session, resolving the chain's wrapped-native token from the
+     * orchestrator's chain catalog (`GET /chains`) so native-token wrapping is
+     * permitted automatically. Project-scoped — needs the API key but no account.
+     * For a fully offline build, use the standalone {@link toSession} and pass
+     * `wrappedNativeToken` yourself.
+     * @param definition The session definition
+     * @returns The resolved session
+     */
+    createSession(definition) {
+        return this.#sdk.composition.project.createSession(definition);
+    }
+}
+export { RhinestoneSDK };

package/dist/src/api/signer-selection.d.ts

@@ -0,0 +1,7 @@
+import type { SignerSet } from '../config/account.js';
+import type { ResolvedAccountConfig } from '../config/resolved.js';
+import type { OwnerSignerSelection } from '../signing/types.js';
+import type { IntentSessionSelection } from '../transactions/intents/types.js';
+export type AdaptedSignerSelection = OwnerSignerSelection | IntentSessionSelection;
+export declare function adaptSignerSelection(account: ResolvedAccountConfig, signers: SignerSet): AdaptedSignerSelection;
+//# sourceMappingURL=signer-selection.d.ts.map

package/dist/src/api/signer-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer-selection.d.ts","sourceRoot":"","sources":["../../../api/signer-selection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAW/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AAI3E,MAAM,MAAM,sBAAsB,GAC9B,oBAAoB,GACpB,sBAAsB,CAAA;AAE1B,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,SAAS,GACjB,sBAAsB,CAKxB"}

package/dist/src/api/signer-selection.js

@@ -0,0 +1,109 @@
+import { defineValidator } from '../modules/validators/definition.js';
+import { ecdsaSignerId, webauthnSignerId, } from '../modules/validators/signer-id.js';
+export function adaptSignerSelection(account, signers) {
+    if (signers.type === 'experimental_session') {
+        return adaptSessionSelection(signers);
+    }
+    return adaptOwnerSelection(account, signers);
+}
+function adaptOwnerSelection(account, signers) {
+    switch (signers.kind) {
+        case 'ecdsa': {
+            const signerIds = signers.accounts.map(ecdsaSignerId);
+            return {
+                kind: 'owner',
+                validator: account.owners
+                    ? replaceValidatorAccounts(account.owners, signers.accounts)
+                    : defineValidator({ type: 'ecdsa', accounts: signers.accounts }),
+                signerIds,
+            };
+        }
+        case 'passkey': {
+            const signerIds = signers.accounts.map(webauthnSignerId);
+            return {
+                kind: 'owner',
+                validator: defineValidator({
+                    type: 'passkey',
+                    accounts: signers.accounts,
+                    ...(signers.module ? { module: signers.module } : {}),
+                }),
+                signerIds,
+            };
+        }
+        case 'multi-factor': {
+            const validator = defineValidator({
+                type: 'multi-factor',
+                validators: signers.validators.map((factor) => factor.type === 'passkey'
+                    ? { type: 'passkey', accounts: factor.accounts }
+                    : { type: 'ecdsa', accounts: factor.accounts }),
+                ...(signers.module ? { module: signers.module } : {}),
+            });
+            if (validator.kind !== 'multi-factor') {
+                throw new Error('Multi-factor signer selection did not resolve');
+            }
+            return {
+                kind: 'owner',
+                validator: {
+                    ...validator,
+                    validators: validator.validators.map((factor, index) => ({
+                        ...factor,
+                        publicId: signers.validators[index]?.id ?? factor.publicId,
+                    })),
+                },
+                signerIds: signers.validators.flatMap((factor) => factor.type === 'passkey'
+                    ? factor.accounts.map(webauthnSignerId)
+                    : factor.accounts.map(ecdsaSignerId)),
+            };
+        }
+    }
+}
+function replaceValidatorAccounts(configured, selectedAccounts) {
+    const accounts = new Map(selectedAccounts.map((account) => [
+        account.type === 'webAuthn'
+            ? webauthnSignerId(account)
+            : ecdsaSignerId(account),
+        account,
+    ]));
+    if (configured.kind === 'multi-factor') {
+        return {
+            ...configured,
+            validators: configured.validators.map((validator) => replaceAtomicValidatorAccounts(validator, accounts)),
+        };
+    }
+    return replaceAtomicValidatorAccounts(configured, accounts);
+}
+function replaceAtomicValidatorAccounts(configured, accounts) {
+    return {
+        ...configured,
+        owners: configured.owners.map((owner) => replaceOwnerAccount(owner, accounts.get(owner.signerId))),
+    };
+}
+function replaceOwnerAccount(owner, account) {
+    if (!account)
+        return owner;
+    return owner.kind === 'webauthn' && account.type === 'webAuthn'
+        ? { ...owner, account }
+        : owner.kind !== 'webauthn' && account.type !== 'webAuthn'
+            ? { ...owner, account }
+            : owner;
+}
+function adaptSessionSelection(signers) {
+    if ('sessions' in signers) {
+        return {
+            kind: 'smart-session',
+            byChain: Object.fromEntries(Object.entries(signers.sessions).map(([chainId, selection]) => [
+                Number(chainId),
+                selection,
+            ])),
+        };
+    }
+    return {
+        kind: 'smart-session',
+        byChain: {
+            [signers.session.chain.id]: {
+                session: signers.session,
+                ...(signers.enableData ? { enableData: signers.enableData } : {}),
+            },
+        },
+    };
+}