@swivy/expo 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,20 @@
-# Temporary Holding Version
+# @swivy/expo
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Swivy expo SDK. Testnet preview; production onboarding is gated on the Swop canary.
+
+Public npm distribution is being prepared. Before first publication, use all SDK tarballs
+from one operator-supplied release and verify its SHA256SUMS. After publication:
+
+```sh
+npm install @swivy/expo@next
+```
+
+Use an environment app ID and publishable key for browser/mobile apps. Keep environment
+secret keys on the backend and deployment bootstrap credentials with the deployment operator.
+Choose email or SMS in your environment policy; SMS recovery alone does not enable SMS login.
+Never log login codes, runtime sessions or signing material.
+
+Browser apps currently need a same-origin reverse proxy for `/v1/runtime/*`; the API
+does not advertise cross-origin browser access. Backend and native clients can use the API directly.
+
+The client exposes `requestSmsCode(phoneNumber)` and `verifySmsCode(challengeId, code)`. Supply phone numbers in E.164 format.

package/dist/packages/expo/src/index.d.ts

@@ -0,0 +1,270 @@
+import type { Chain, CustodyMode, LinkedWalletDescriptor, ManagedAccountDescriptor, OfflineSigningMeshPacket, OfflineTransactionSigningEnvelope, OfflineTransactionSigningResponseEnvelope, TransactionIntent, TypedDataDescriptor, WalletPurpose } from "@swivy/core";
+export interface SwivyExpoClientConfig {
+    baseUrl: string;
+    appId?: string;
+    publishableKey?: string;
+    environmentId?: string;
+    /**
+     * Legacy alias for publishableKey while existing apps migrate.
+     */
+    apiKey?: string;
+    sessionToken?: string;
+    sessionPersistence?: SwivyExpoSessionPersistenceAdapter;
+    passkeyAdapter?: SwivyExpoPasskeyAdapter;
+    bluetoothMeshAdapter?: SwivyExpoBluetoothMeshAdapter;
+}
+export interface SwivyExpoSessionPersistenceAdapter {
+    load(): Promise<string | undefined>;
+    save(token: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export interface SwivyExpoAsyncKeyValueStoreLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+export declare function createAsyncStorageSessionPersistence(storage: SwivyExpoAsyncKeyValueStoreLike, key?: string): SwivyExpoSessionPersistenceAdapter;
+export type SwivyChallengePurpose = "login" | "account_export" | "intent_approval" | "recovery" | "session_delegation" | "wallet_reconstruction";
+export interface SwivyExpoRuntimeAuthMethod {
+    id: string;
+    type: string;
+    label: string;
+    active: boolean;
+    recoveryCapable?: boolean;
+}
+export interface SwivyExpoRuntimeSession {
+    sessionToken?: string;
+    managedAccounts?: ManagedAccountDescriptor[];
+    linkedWallets?: LinkedWalletDescriptor[];
+    authMethods?: SwivyExpoRuntimeAuthMethod[];
+    environmentPolicy?: {
+        allowedChains?: Chain[];
+        walletPolicy?: {
+            allowManagedAccounts?: boolean;
+            allowSplitCustody?: boolean;
+            autoCreateManagedAccounts?: boolean;
+            defaultCustodyMode?: CustodyMode;
+            managedAccountChains?: Chain[];
+        };
+    };
+    [key: string]: unknown;
+}
+export interface SwivyExpoListAccountsPayload {
+    managedAccounts: ManagedAccountDescriptor[];
+    linkedWallets: LinkedWalletDescriptor[];
+}
+export interface SwivyExpoManagedAccountCreateOptions {
+    label?: string;
+    purpose?: WalletPurpose;
+    custodyMode?: CustodyMode;
+    splitCustody?: {
+        deviceShare: {
+            commitment: string;
+            encryptedPayload?: string;
+            metadata?: Record<string, unknown>;
+        };
+        recoveryShare?: {
+            commitment: string;
+            encryptedPayload?: string;
+            metadata?: Record<string, unknown>;
+        };
+    };
+}
+export interface SwivyExpoManagedAccountResolution {
+    account: ManagedAccountDescriptor;
+    existing: boolean;
+    attestation?: unknown;
+}
+export interface SwivyExpoWaitForIntentOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+}
+export interface SwivyExpoSigningPayload {
+    accountId: string;
+    chain: Chain;
+    challengeId?: string;
+    payload: Record<string, unknown>;
+}
+export interface SwivyExpoTypedDataSigningPayload {
+    accountId: string;
+    challengeId?: string;
+    typedData: TypedDataDescriptor;
+}
+export interface SwivyExpoPasskeyRegistrationStartPayload {
+    authMethod: {
+        id: string;
+        type: "passkey";
+        label: string;
+        active: boolean;
+        recoveryCapable: boolean;
+    };
+    challengeId: string;
+    methodType: "passkey";
+    options: Record<string, unknown>;
+    expiresAt: string;
+}
+export interface SwivyExpoPasskeyChallengePayload {
+    challengeId: string;
+    purpose: SwivyChallengePurpose;
+    expiresAt: string;
+    methodType: "passkey";
+    options: Record<string, unknown>;
+}
+export interface SwivyExpoPasskeyEnsureResult {
+    authMethod: SwivyExpoRuntimeAuthMethod;
+    existing: boolean;
+    enrollment?: Awaited<ReturnType<SwivyExpoClient["enrollPasskey"]>>;
+}
+export interface SwivyExpoPasskeyEnrollmentContext {
+    authMethodId: string;
+    challengeId: string;
+    label: string;
+}
+export interface SwivyExpoPasskeyAuthenticationContext {
+    challengeId: string;
+    purpose: SwivyChallengePurpose;
+    authMethodId: string;
+}
+export interface SwivyExpoPasskeyAdapter {
+    isSupported?(): Promise<boolean>;
+    register(options: Record<string, unknown>, context: SwivyExpoPasskeyEnrollmentContext): Promise<Record<string, unknown>>;
+    authenticate(options: Record<string, unknown>, context: SwivyExpoPasskeyAuthenticationContext): Promise<Record<string, unknown>>;
+}
+export interface SwivyExpoBluetoothMeshPeer {
+    id: string;
+    label?: string;
+    rssi?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface SwivyExpoBluetoothMeshSendOptions {
+    ttlSeconds?: number;
+    retryCount?: number;
+    retryDelayMs?: number;
+    maxPayloadBytes?: number;
+}
+export interface SwivyExpoBluetoothMeshAdapter {
+    isSupported?(): Promise<boolean>;
+    start(params: {
+        serviceId: string;
+        onPeerDiscovered(peer: SwivyExpoBluetoothMeshPeer): void;
+        onPacket(packet: OfflineSigningMeshPacket, peer?: SwivyExpoBluetoothMeshPeer): void;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    send(packet: OfflineSigningMeshPacket, peerId?: string): Promise<void>;
+}
+export interface SwivyExpoPasskeyApprovalResult {
+    challenge: SwivyExpoPasskeyChallengePayload;
+    verification: unknown;
+    authenticationResponse: Record<string, unknown>;
+}
+export interface SwivyExpoOidcDiscoveryDocument {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    userinfo_endpoint?: string;
+    jwks_uri: string;
+    end_session_endpoint?: string;
+    scopes_supported?: string[];
+    response_types_supported?: string[];
+    grant_types_supported?: string[];
+    code_challenge_methods_supported?: string[];
+    [key: string]: unknown;
+}
+export interface SwivyExpoBluetoothMeshSession {
+    stop(): Promise<void>;
+    sendEnvelope(envelope: OfflineTransactionSigningEnvelope | OfflineTransactionSigningResponseEnvelope | string, peerId?: string, options?: SwivyExpoBluetoothMeshSendOptions): Promise<{
+        messageId: string;
+        packetsSent: number;
+    }>;
+}
+export declare class SwivyExpoClient {
+    private readonly config;
+    private sessionToken?;
+    private initialized;
+    private readonly sessionTokenListeners;
+    constructor(config: SwivyExpoClientConfig);
+    static create(config: SwivyExpoClientConfig): Promise<SwivyExpoClient>;
+    initialize(): Promise<this>;
+    getSessionToken(): string | undefined;
+    setSessionToken(token: string | undefined): Promise<void>;
+    clearSessionToken(): Promise<void>;
+    onSessionTokenChange(listener: (token: string | undefined) => void): () => void;
+    requestEmailCode(email: string, externalUserId?: string): Promise<any>;
+    verifyEmailCode(email: string, code: string, externalUserId?: string): Promise<SwivyExpoRuntimeSession>;
+    exchangeOidcToken(token: string): Promise<SwivyExpoRuntimeSession>;
+    getMe(): Promise<SwivyExpoRuntimeSession>;
+    hydrateRuntimeSession(): Promise<SwivyExpoRuntimeSession>;
+    startPasskeyRegistration(label?: string): Promise<SwivyExpoPasskeyRegistrationStartPayload>;
+    finishPasskeyRegistration(authMethodId: string, challengeId: string, registrationResponse: Record<string, unknown>): Promise<any>;
+    /** Create a new account with a passkey only (Privy signupWithPasskey). */
+    signupWithPasskey(options?: {
+        displayName?: string;
+    }): Promise<any>;
+    /** Log in with any passkey registered for this app (Privy loginWithPasskey). */
+    loginWithPasskey(): Promise<any>;
+    /** Send a login code by SMS (Privy loginWithSMS, step 1). Phone in E.164. */
+    requestSmsCode(phoneNumber: string): Promise<any>;
+    verifySmsCode(challengeId: string, code: string): Promise<any>;
+    enrollPasskey(label?: string): Promise<any>;
+    ensurePasskey(label?: string): Promise<SwivyExpoPasskeyEnsureResult>;
+    createChallenge(authMethodId: string, purpose: SwivyChallengePurpose): Promise<any>;
+    verifyChallenge(challengeId: string, payload: Record<string, unknown>): Promise<any>;
+    approveWithPasskey(authMethodId: string, purpose: SwivyChallengePurpose): Promise<SwivyExpoPasskeyApprovalResult>;
+    listAccounts(): Promise<SwivyExpoListAccountsPayload>;
+    listEmbeddedWallets(): Promise<ManagedAccountDescriptor[]>;
+    getManagedAccount(chain: Chain, options?: {
+        purpose?: WalletPurpose;
+    }): Promise<ManagedAccountDescriptor | null>;
+    getEmbeddedWallet(chain: Chain): Promise<ManagedAccountDescriptor | null>;
+    createManagedAccount(chain: Chain, options?: string | SwivyExpoManagedAccountCreateOptions): Promise<any>;
+    ensureManagedAccount(chain: Chain, options?: string | SwivyExpoManagedAccountCreateOptions): Promise<SwivyExpoManagedAccountResolution>;
+    ensureEmbeddedWallet(chain: Chain, options?: string | SwivyExpoManagedAccountCreateOptions): Promise<SwivyExpoManagedAccountResolution>;
+    createSigningIntent(body: Record<string, unknown>): Promise<any>;
+    createTransactionIntent(body: Record<string, unknown>): Promise<any>;
+    getIntent(intentId: string): Promise<any>;
+    waitForIntent(intentId: string, options?: SwivyExpoWaitForIntentOptions): Promise<TransactionIntent>;
+    createSigningIntentAndWait(body: Record<string, unknown>, options?: SwivyExpoWaitForIntentOptions): Promise<TransactionIntent>;
+    createTransactionIntentAndWait(body: Record<string, unknown>, options?: SwivyExpoWaitForIntentOptions): Promise<TransactionIntent>;
+    signMessageAndWait(body: SwivyExpoSigningPayload & {
+        payload: {
+            message?: string;
+            messageHex?: string;
+            messageBase64?: string;
+        };
+    }, options?: SwivyExpoWaitForIntentOptions): Promise<TransactionIntent>;
+    signTypedDataAndWait(body: SwivyExpoTypedDataSigningPayload, options?: SwivyExpoWaitForIntentOptions): Promise<TransactionIntent>;
+    signTransactionAndWait(body: SwivyExpoSigningPayload & {
+        payload: {
+            transaction?: Record<string, unknown>;
+            serializedTransactionBase64?: string;
+        };
+    }, options?: SwivyExpoWaitForIntentOptions): Promise<TransactionIntent>;
+    createOfflineTransactionSigningEnvelope(body: {
+        accountId: string;
+        chain: Chain;
+        payload: {
+            network?: string | null;
+            transaction?: Record<string, unknown>;
+            serializedTransactionBase64?: string;
+            requestedValueUsd?: number | null;
+        };
+        expiresAt?: Date | string | null;
+        requester?: OfflineTransactionSigningEnvelope["requester"];
+        metadata?: Record<string, unknown>;
+    }): Promise<OfflineTransactionSigningEnvelope>;
+    encodeOfflineSigningEnvelope(envelope: OfflineTransactionSigningEnvelope | OfflineTransactionSigningResponseEnvelope): string;
+    decodeOfflineSigningEnvelope(envelope: string): OfflineTransactionSigningEnvelope | OfflineTransactionSigningResponseEnvelope;
+    startBluetoothMeshOfflineSigning(params: {
+        serviceId?: string;
+        onPeerDiscovered?(peer: SwivyExpoBluetoothMeshPeer): void;
+        onEnvelope(envelope: OfflineTransactionSigningEnvelope | OfflineTransactionSigningResponseEnvelope, peer?: SwivyExpoBluetoothMeshPeer): void | Promise<void>;
+    }): Promise<SwivyExpoBluetoothMeshSession>;
+    executeTransactionAndWait(body: Record<string, unknown>, options?: SwivyExpoWaitForIntentOptions): Promise<TransactionIntent>;
+    getOidcDiscovery(appId?: string | undefined): Promise<SwivyExpoOidcDiscoveryDocument>;
+    getOidcJwks(appId?: string | undefined): Promise<any>;
+    private requirePasskeyAdapter;
+    private requireBluetoothMeshAdapter;
+    private request;
+    private delay;
+}

package/dist/packages/expo/src/index.js

@@ -0,0 +1,541 @@
+import { createOfflineTransactionSigningEnvelope, createOfflineSigningMeshPackets, decodeOfflineSigningEnvelope, encodeOfflineSigningEnvelope, OfflineSigningMeshReassembler, } from "@swivy/core";
+export function createAsyncStorageSessionPersistence(storage, key = "swivy:session-token") {
+    return {
+        async load() {
+            const value = await storage.getItem(key);
+            return value ?? undefined;
+        },
+        async save(token) {
+            await storage.setItem(key, token);
+        },
+        async clear() {
+            await storage.removeItem(key);
+        },
+    };
+}
+function parseJsonResponseBody(response, text) {
+    if (!text) {
+        return {};
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        const contentType = response.headers.get("content-type") ?? "";
+        if (response.ok) {
+            throw new Error(contentType ? `invalid_json_response:${contentType}` : "invalid_json_response");
+        }
+        throw new Error(`http_${response.status}_non_json_response`);
+    }
+}
+function resolveResponseErrorMessage(response, payload) {
+    if (typeof payload?.error === "string" && payload.error) {
+        return payload.error;
+    }
+    if (typeof payload?.error?.message === "string" && payload.error.message) {
+        return payload.error.message;
+    }
+    if (typeof payload?.message === "string" && payload.message) {
+        return payload.message;
+    }
+    return response.statusText || `http_${response.status}`;
+}
+export class SwivyExpoClient {
+    config;
+    sessionToken;
+    initialized = false;
+    sessionTokenListeners = new Set();
+    constructor(config) {
+        this.config = config;
+        this.sessionToken = config.sessionToken;
+    }
+    static async create(config) {
+        const client = new SwivyExpoClient(config);
+        await client.initialize();
+        return client;
+    }
+    async initialize() {
+        if (this.initialized) {
+            return this;
+        }
+        this.initialized = true;
+        if (!this.sessionToken && this.config.sessionPersistence) {
+            this.sessionToken = await this.config.sessionPersistence.load();
+        }
+        return this;
+    }
+    getSessionToken() {
+        return this.sessionToken;
+    }
+    async setSessionToken(token) {
+        this.sessionToken = token;
+        if (token) {
+            await this.config.sessionPersistence?.save(token);
+        }
+        else {
+            await this.config.sessionPersistence?.clear();
+        }
+        for (const listener of this.sessionTokenListeners) {
+            listener(token);
+        }
+    }
+    async clearSessionToken() {
+        await this.setSessionToken(undefined);
+    }
+    onSessionTokenChange(listener) {
+        this.sessionTokenListeners.add(listener);
+        return () => {
+            this.sessionTokenListeners.delete(listener);
+        };
+    }
+    async requestEmailCode(email, externalUserId) {
+        await this.initialize();
+        return this.request("/v1/runtime/auth/email/request", {
+            method: "POST",
+            body: { email, externalUserId },
+        });
+    }
+    async verifyEmailCode(email, code, externalUserId) {
+        await this.initialize();
+        const payload = await this.request("/v1/runtime/auth/email/verify", {
+            method: "POST",
+            body: { email, code, externalUserId },
+        });
+        if (payload.sessionToken) {
+            await this.setSessionToken(payload.sessionToken);
+        }
+        return payload;
+    }
+    async exchangeOidcToken(token) {
+        await this.initialize();
+        const payload = await this.request("/v1/runtime/auth/oidc/exchange", {
+            method: "POST",
+            body: { token },
+        });
+        if (payload.sessionToken) {
+            await this.setSessionToken(payload.sessionToken);
+        }
+        return payload;
+    }
+    async getMe() {
+        await this.initialize();
+        return this.request("/v1/runtime/me", { method: "GET", runtime: true });
+    }
+    async hydrateRuntimeSession() {
+        return this.getMe();
+    }
+    async startPasskeyRegistration(label = "Passkey") {
+        await this.initialize();
+        return this.request("/v1/runtime/mfa/passkeys/register/start", {
+            method: "POST",
+            body: { label },
+            runtime: true,
+        });
+    }
+    async finishPasskeyRegistration(authMethodId, challengeId, registrationResponse) {
+        await this.initialize();
+        return this.request("/v1/runtime/mfa/passkeys/register/finish", {
+            method: "POST",
+            body: { authMethodId, challengeId, registrationResponse },
+            runtime: true,
+        });
+    }
+    /** Create a new account with a passkey only (Privy signupWithPasskey). */
+    async signupWithPasskey(options = {}) {
+        await this.initialize();
+        const adapter = await this.requirePasskeyAdapter();
+        const started = await this.request("/v1/runtime/auth/passkeys/signup/start", {
+            method: "POST",
+            body: { displayName: options.displayName },
+        });
+        const registrationResponse = await adapter.register(started.options, {
+            authMethodId: "",
+            challengeId: started.challengeId,
+            label: "Passkey",
+        });
+        const payload = await this.request("/v1/runtime/auth/passkeys/signup/finish", {
+            method: "POST",
+            body: { challengeId: started.challengeId, registrationResponse },
+        });
+        if (payload.sessionToken) {
+            await this.setSessionToken(payload.sessionToken);
+        }
+        return payload;
+    }
+    /** Log in with any passkey registered for this app (Privy loginWithPasskey). */
+    async loginWithPasskey() {
+        await this.initialize();
+        const adapter = await this.requirePasskeyAdapter();
+        const started = await this.request("/v1/runtime/auth/passkeys/login/start", { method: "POST", body: {} });
+        const authenticationResponse = await adapter.authenticate(started.options, {
+            challengeId: started.challengeId,
+            purpose: "login",
+            authMethodId: "",
+        });
+        const payload = await this.request("/v1/runtime/auth/passkeys/login/verify", {
+            method: "POST",
+            body: { challengeId: started.challengeId, authenticationResponse },
+        });
+        if (payload.sessionToken) {
+            await this.setSessionToken(payload.sessionToken);
+        }
+        return payload;
+    }
+    /** Send a login code by SMS (Privy loginWithSMS, step 1). Phone in E.164. */
+    async requestSmsCode(phoneNumber) {
+        await this.initialize();
+        return this.request("/v1/runtime/auth/sms/request", { method: "POST", body: { phoneNumber } });
+    }
+    async verifySmsCode(challengeId, code) {
+        await this.initialize();
+        const payload = await this.request("/v1/runtime/auth/sms/verify", {
+            method: "POST",
+            body: { challengeId, code },
+        });
+        if (payload.sessionToken) {
+            await this.setSessionToken(payload.sessionToken);
+        }
+        return payload;
+    }
+    async enrollPasskey(label = "Passkey") {
+        await this.initialize();
+        const adapter = await this.requirePasskeyAdapter();
+        const started = await this.startPasskeyRegistration(label);
+        const registrationResponse = await adapter.register(started.options, {
+            authMethodId: started.authMethod.id,
+            challengeId: started.challengeId,
+            label,
+        });
+        const completed = await this.finishPasskeyRegistration(started.authMethod.id, started.challengeId, registrationResponse);
+        return {
+            ...completed,
+            started,
+            registrationResponse,
+        };
+    }
+    async ensurePasskey(label = "Passkey") {
+        await this.initialize();
+        const me = await this.getMe();
+        const existing = (me.authMethods ?? []).find((method) => method.type === "passkey" && method.active);
+        if (existing) {
+            return {
+                authMethod: existing,
+                existing: true,
+            };
+        }
+        const enrollment = await this.enrollPasskey(label);
+        const authMethod = (enrollment.authMethod
+            ?? enrollment.started.authMethod);
+        return {
+            authMethod,
+            existing: false,
+            enrollment,
+        };
+    }
+    async createChallenge(authMethodId, purpose) {
+        await this.initialize();
+        return this.request("/v1/runtime/mfa/challenges", {
+            method: "POST",
+            body: { authMethodId, purpose },
+            runtime: true,
+        });
+    }
+    async verifyChallenge(challengeId, payload) {
+        await this.initialize();
+        return this.request("/v1/runtime/mfa/challenges/verify", {
+            method: "POST",
+            body: { challengeId, ...payload },
+            runtime: true,
+        });
+    }
+    async approveWithPasskey(authMethodId, purpose) {
+        await this.initialize();
+        const adapter = await this.requirePasskeyAdapter();
+        const challenge = (await this.createChallenge(authMethodId, purpose));
+        if (!challenge.options) {
+            throw new Error("passkey challenge options missing");
+        }
+        const authenticationResponse = await adapter.authenticate(challenge.options, {
+            challengeId: challenge.challengeId,
+            purpose,
+            authMethodId,
+        });
+        const verification = await this.verifyChallenge(challenge.challengeId, {
+            authenticationResponse,
+        });
+        return {
+            challenge,
+            verification,
+            authenticationResponse,
+        };
+    }
+    async listAccounts() {
+        await this.initialize();
+        return this.request("/v1/runtime/accounts", { method: "GET", runtime: true });
+    }
+    async listEmbeddedWallets() {
+        const payload = await this.listAccounts();
+        return payload.managedAccounts;
+    }
+    async getManagedAccount(chain, options) {
+        const payload = await this.listAccounts();
+        return (payload.managedAccounts.find((account) => account.chain === chain &&
+            (!options?.purpose || ((account.purpose ?? "agent") === options.purpose))) ?? null);
+    }
+    async getEmbeddedWallet(chain) {
+        return this.getManagedAccount(chain);
+    }
+    async createManagedAccount(chain, options) {
+        await this.initialize();
+        const normalizedOptions = typeof options === "string" ? { label: options } : options;
+        return this.request("/v1/runtime/accounts/managed", {
+            method: "POST",
+            body: { chain, ...normalizedOptions },
+            runtime: true,
+        });
+    }
+    async ensureManagedAccount(chain, options) {
+        const normalizedOptions = typeof options === "string" ? { label: options } : options;
+        const purpose = normalizedOptions?.purpose ??
+            (normalizedOptions?.custodyMode === "split_custody" ? "personal" : "agent");
+        const existing = await this.getManagedAccount(chain, {
+            purpose,
+        });
+        if (existing) {
+            return {
+                account: existing,
+                existing: true,
+            };
+        }
+        const created = await this.createManagedAccount(chain, normalizedOptions);
+        return {
+            account: created.account,
+            existing: Boolean(created.existing),
+            attestation: created.attestation,
+        };
+    }
+    async ensureEmbeddedWallet(chain, options) {
+        return this.ensureManagedAccount(chain, options);
+    }
+    async createSigningIntent(body) {
+        await this.initialize();
+        return this.request("/v1/runtime/intents/signing", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async createTransactionIntent(body) {
+        await this.initialize();
+        return this.request("/v1/runtime/intents/transactions", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async getIntent(intentId) {
+        await this.initialize();
+        return this.request(`/v1/runtime/intents/${intentId}`, {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async waitForIntent(intentId, options = {}) {
+        const timeoutMs = options.timeoutMs ?? 30_000;
+        const pollIntervalMs = options.pollIntervalMs ?? 1_000;
+        const startedAt = Date.now();
+        for (;;) {
+            if (options.signal?.aborted) {
+                throw new Error("intent_wait_aborted");
+            }
+            const payload = (await this.getIntent(intentId));
+            const intent = payload.intent;
+            if (intent.status === "completed" || intent.status === "failed") {
+                return intent;
+            }
+            if (Date.now() - startedAt >= timeoutMs) {
+                throw new Error("intent_wait_timeout");
+            }
+            await this.delay(pollIntervalMs, options.signal);
+        }
+    }
+    async createSigningIntentAndWait(body, options) {
+        const payload = (await this.createSigningIntent(body));
+        return this.waitForIntent(payload.intent.id, options);
+    }
+    async createTransactionIntentAndWait(body, options) {
+        const payload = (await this.createTransactionIntent(body));
+        return this.waitForIntent(payload.intent.id, options);
+    }
+    async signMessageAndWait(body, options) {
+        return this.createSigningIntentAndWait(body, options);
+    }
+    async signTypedDataAndWait(body, options) {
+        return this.createSigningIntentAndWait({
+            accountId: body.accountId,
+            chain: "evm",
+            challengeId: body.challengeId,
+            payload: {
+                typedData: body.typedData,
+            },
+        }, options);
+    }
+    async signTransactionAndWait(body, options) {
+        return this.createSigningIntentAndWait(body, options);
+    }
+    async createOfflineTransactionSigningEnvelope(body) {
+        await this.initialize();
+        return createOfflineTransactionSigningEnvelope({
+            accountId: body.accountId,
+            chain: body.chain,
+            expiresAt: body.expiresAt,
+            payload: body.payload,
+            requester: body.requester ?? {
+                appId: this.config.appId ?? this.config.environmentId,
+            },
+            metadata: body.metadata,
+        });
+    }
+    encodeOfflineSigningEnvelope(envelope) {
+        return encodeOfflineSigningEnvelope(envelope);
+    }
+    decodeOfflineSigningEnvelope(envelope) {
+        return decodeOfflineSigningEnvelope(envelope);
+    }
+    async startBluetoothMeshOfflineSigning(params) {
+        const adapter = await this.requireBluetoothMeshAdapter();
+        const reassembler = new OfflineSigningMeshReassembler();
+        await adapter.start({
+            serviceId: params.serviceId ?? "swivy-offline-signing-v1",
+            onPeerDiscovered(peer) {
+                params.onPeerDiscovered?.(peer);
+            },
+            onPacket(packet, peer) {
+                const envelope = reassembler.accept(packet);
+                if (envelope) {
+                    void params.onEnvelope(envelope, peer);
+                }
+            },
+        });
+        return {
+            stop: () => adapter.stop(),
+            sendEnvelope: async (envelope, peerId, options = {}) => {
+                const packets = createOfflineSigningMeshPackets({
+                    envelope,
+                    ttlSeconds: options.ttlSeconds,
+                    maxPayloadBytes: options.maxPayloadBytes,
+                });
+                const retryCount = Math.max(0, options.retryCount ?? 2);
+                const retryDelayMs = Math.max(0, options.retryDelayMs ?? 250);
+                for (const packet of packets) {
+                    let lastError;
+                    for (let attempt = 0; attempt <= retryCount; attempt += 1) {
+                        try {
+                            await adapter.send(packet, peerId);
+                            lastError = null;
+                            break;
+                        }
+                        catch (error) {
+                            lastError = error;
+                            if (attempt < retryCount) {
+                                await this.delay(retryDelayMs);
+                            }
+                        }
+                    }
+                    if (lastError) {
+                        throw lastError;
+                    }
+                }
+                return {
+                    messageId: packets[0]?.messageId ?? "",
+                    packetsSent: packets.length,
+                };
+            },
+        };
+    }
+    async executeTransactionAndWait(body, options) {
+        return this.createTransactionIntentAndWait(body, options);
+    }
+    async getOidcDiscovery(appId = this.config.appId ?? this.config.environmentId) {
+        if (!appId) {
+            throw new Error("Swivy appId is required");
+        }
+        return this.request(`/oidc/${appId}/.well-known/openid-configuration`, {
+            method: "GET",
+        });
+    }
+    async getOidcJwks(appId = this.config.appId ?? this.config.environmentId) {
+        if (!appId) {
+            throw new Error("Swivy appId is required");
+        }
+        return this.request(`/oidc/${appId}/jwks`, {
+            method: "GET",
+        });
+    }
+    async requirePasskeyAdapter() {
+        const adapter = this.config.passkeyAdapter;
+        if (!adapter) {
+            throw new Error("SwivyExpoClient requires a passkeyAdapter for native passkey enrollment and approval");
+        }
+        if (adapter.isSupported && !(await adapter.isSupported())) {
+            throw new Error("passkeys_not_supported_on_device");
+        }
+        return adapter;
+    }
+    async requireBluetoothMeshAdapter() {
+        const adapter = this.config.bluetoothMeshAdapter;
+        if (!adapter) {
+            throw new Error("SwivyExpoClient requires a bluetoothMeshAdapter backed by a native BLE module");
+        }
+        if (adapter.isSupported && !(await adapter.isSupported())) {
+            throw new Error("bluetooth_mesh_not_supported_on_device");
+        }
+        return adapter;
+    }
+    async request(path, options) {
+        const headers = {
+            "x-swivy-app-id": this.config.appId ?? this.config.environmentId ?? "",
+            "x-swivy-publishable-key": this.config.publishableKey ?? this.config.apiKey ?? "",
+        };
+        if (!headers["x-swivy-app-id"] || !headers["x-swivy-publishable-key"]) {
+            throw new Error("Swivy appId and publishableKey are required");
+        }
+        if (options.body !== undefined) {
+            headers["content-type"] = "application/json";
+        }
+        if (options.runtime) {
+            if (!this.sessionToken) {
+                throw new Error("session token is required");
+            }
+            headers.authorization = `Bearer ${this.sessionToken}`;
+        }
+        const response = await fetch(`${this.config.baseUrl}${path}`, {
+            method: options.method,
+            headers,
+            body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        const text = await response.text();
+        const payload = parseJsonResponseBody(response, text);
+        if (!response.ok) {
+            throw new Error(resolveResponseErrorMessage(response, payload));
+        }
+        return payload;
+    }
+    async delay(ms, signal) {
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve();
+            }, ms);
+            const onAbort = () => {
+                cleanup();
+                reject(new Error("intent_wait_aborted"));
+            };
+            const cleanup = () => {
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@swivy/expo",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Swivy Expo and React Native SDK",
+  "type": "module",
+  "main": "dist/packages/expo/src/index.js",
+  "types": "dist/packages/expo/src/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run test/*.test.ts"
+  },
+  "dependencies": {
+    "@swivy/core": "^1.0.1"
+  },
+  "files": [
+    "dist/packages/expo/src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/packages/expo/src/index.d.ts",
+      "import": "./dist/packages/expo/src/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Travisswop/Swivy.git",
+    "directory": "packages/expo"
+  }
+}