@arcanahq/sdk-integrations 0.1.0

package/README.md

@@ -0,0 +1,287 @@
+# Arcana SDK Integrations
+
+Optional wallet and account-abstraction integrations for `@arcanahq/sdk`.
+
+The base SDK remains provider-agnostic. This package normalizes Privy, Dynamic,
+and ZeroDev setup into Arcana's device-auth flow without making those providers
+required dependencies of `@arcanahq/sdk`.
+
+For environment variables, provider dashboard setup, and complete project setup,
+see [SETUP.md](./SETUP.md).
+
+## Install
+
+```bash
+npm install @arcanahq/sdk @arcanahq/sdk-integrations viem
+```
+
+Install only the provider packages your app uses.
+
+Privy:
+
+```bash
+npm install @privy-io/react-auth
+```
+
+Dynamic JavaScript SDK:
+
+```bash
+npm install @dynamic-labs-sdk/client @dynamic-labs-sdk/evm
+```
+
+Dynamic React SDK:
+
+```bash
+npm install @dynamic-labs/sdk-react-core @dynamic-labs/ethereum
+```
+
+Dynamic + ZeroDev:
+
+```bash
+npm install @dynamic-labs-sdk/client @dynamic-labs-sdk/evm @dynamic-labs-sdk/zerodev
+```
+
+Local test auth:
+
+```bash
+npm install @arcanahq/sdk-integrations viem
+```
+
+ZeroDev:
+
+```bash
+npm install @zerodev/sdk @zerodev/ecdsa-validator
+```
+
+## How Arcana Auth Works With Account Abstraction
+
+Arcana device registration currently verifies an EIP-712 ECDSA signature by
+recovering the signer address and requiring it to match `user_address`.
+
+That means Arcana auth must use the EOA or embedded signer that controls the
+smart account. Do not pass a Kernel/smart-account client as the Arcana auth
+signer. Use ZeroDev/Kernel for onchain account-abstraction transactions after
+Arcana auth is complete.
+
+The ZeroDev helpers in this package enforce that: they require
+`ownerWalletClient` or `signerWalletClient` and keep the smart-account address
+only as metadata for your app.
+
+## Privy
+
+Privy wallets expose an EIP-1193 provider through `wallet.getEthereumProvider()`.
+This package can use that directly.
+
+```typescript
+import { ArcanaClient } from '@arcanahq/sdk';
+import {
+  createPrivyArcanaWalletAdapter,
+  registerArcanaDeviceWithAdapter,
+} from '@arcanahq/sdk-integrations/privy';
+
+const client = new ArcanaClient({ apiUrl: 'http://localhost:3003' });
+await client.init();
+
+const adapter = await createPrivyArcanaWalletAdapter({
+  wallet: privyWallet,
+});
+
+await registerArcanaDeviceWithAdapter(client, adapter, {
+  deviceName: 'Privy wallet',
+});
+```
+
+If you already converted a Privy wallet to a Viem account with Privy's
+`toViemAccount`, pass it as `account`:
+
+```typescript
+const adapter = await createPrivyArcanaWalletAdapter({ account });
+await registerArcanaDeviceWithAdapter(client, adapter);
+```
+
+## Dynamic
+
+Dynamic's current JavaScript SDK exposes Viem wallet clients through
+`createWalletClientForWalletAccount` from `@dynamic-labs-sdk/evm/viem`.
+
+```typescript
+import { getPrimaryWalletAccount } from '@dynamic-labs-sdk/client';
+import { createWalletClientForWalletAccount } from '@dynamic-labs-sdk/evm/viem';
+import {
+  ensureArcanaSessionWithDynamic,
+} from '@arcanahq/sdk-integrations/dynamic';
+
+const walletAccount = getPrimaryWalletAccount();
+if (!walletAccount) {
+  throw new Error('No Dynamic wallet account is connected');
+}
+
+const walletClient = await createWalletClientForWalletAccount({
+  walletAccount,
+});
+
+const session = await ensureArcanaSessionWithDynamic({
+  client,
+  walletClient,
+  deviceName: 'Dynamic wallet',
+});
+console.log(`Arcana ${session.status} for ${session.address}`);
+```
+
+For Dynamic React projects using wallet objects that expose `getWalletClient()`
+or `getEthereumProvider()`, you can pass the wallet directly:
+
+```typescript
+const session = await ensureArcanaSessionWithDynamic({
+  client,
+  wallet: primaryWallet,
+  chainId: 57073,
+  deviceName: 'Dynamic wallet',
+});
+```
+
+Use `ensureArcanaSessionWithDynamic` from the sign-in button after Dynamic has a
+connected wallet. It restores an existing Arcana device session for that wallet
+or registers a new one. Keep action guards separate: submit actions only after
+this helper returns a `userId`.
+
+## Local Test Auth
+
+Use the test adapter for local automation and agentic E2E runs where OTP or
+hosted embedded-wallet flows would slow the loop down. It exposes the same
+`ArcanaWalletAdapter` shape as Privy and Dynamic, but signs with a deterministic
+local private key.
+
+```typescript
+import {
+  createTestArcanaWalletAdapter,
+  registerArcanaDeviceWithAdapter,
+} from '@arcanahq/sdk-integrations/test';
+
+const adapter = createTestArcanaWalletAdapter({
+  chainId: 31337,
+  privateKey: import.meta.env.VITE_ARCANA_TEST_PRIVATE_KEY,
+});
+
+await registerArcanaDeviceWithAdapter(client, adapter, {
+  deviceName: 'Arcana test user',
+});
+```
+
+The default private key is Anvil's first account. Only enable this in local or
+test environments.
+
+## Dynamic + ZeroDev
+
+Dynamic's ZeroDev extension can return the EOA signer for a smart wallet account
+with `getSignerForSmartWalletAccount`. Use that signer for Arcana auth, and use
+the Kernel client for onchain UserOps.
+
+```typescript
+import { getPrimaryWalletAccount } from '@dynamic-labs-sdk/client';
+import { createKernelClientForWalletAccount } from '@dynamic-labs-sdk/zerodev';
+import {
+  getSignerForSmartWalletAccount,
+} from '@dynamic-labs-sdk/zerodev';
+import {
+  createDynamicZeroDevArcanaWalletAdapter,
+  registerArcanaDeviceWithAdapter,
+} from '@arcanahq/sdk-integrations/dynamic-zerodev';
+
+const smartWalletAccount = getPrimaryWalletAccount();
+if (!smartWalletAccount) {
+  throw new Error('No Dynamic smart wallet account is connected');
+}
+
+const signerWalletClient = await getSignerForSmartWalletAccount({
+  smartWalletAccount,
+});
+
+const kernelClient = await createKernelClientForWalletAccount({
+  walletAccount: smartWalletAccount,
+});
+
+const adapter = createDynamicZeroDevArcanaWalletAdapter({
+  signerWalletClient,
+  smartAccountAddress: kernelClient.account.address,
+});
+
+await registerArcanaDeviceWithAdapter(client, adapter, {
+  deviceName: 'Dynamic + ZeroDev',
+});
+
+const smartAccountAddress = adapter.getSmartAccountAddress();
+```
+
+## Privy + ZeroDev
+
+Privy smart wallets are controlled by an embedded signer. Use the embedded
+wallet signer for Arcana auth, then use your ZeroDev Kernel client for onchain
+account-abstraction transactions.
+
+```typescript
+import {
+  createPrivyArcanaWalletAdapter,
+  registerArcanaDeviceWithAdapter,
+} from '@arcanahq/sdk-integrations/privy';
+
+const authAdapter = await createPrivyArcanaWalletAdapter({
+  wallet: privyEmbeddedWallet,
+});
+
+await registerArcanaDeviceWithAdapter(client, authAdapter, {
+  deviceName: 'Privy + ZeroDev',
+});
+```
+
+If you build Kernel manually, pass the same owner signer you used for
+`signerToEcdsaValidator` to Arcana:
+
+```typescript
+import {
+  createPrivyZeroDevArcanaWalletAdapter,
+  registerArcanaDeviceWithAdapter,
+} from '@arcanahq/sdk-integrations/privy-zerodev';
+
+const adapter = createPrivyZeroDevArcanaWalletAdapter({
+  ownerWalletClient,
+  smartAccountAddress: kernelClient.account.address,
+});
+
+await registerArcanaDeviceWithAdapter(client, adapter);
+```
+
+## ZeroDev
+
+ZeroDev Kernel accounts are smart accounts owned by a signer. Use the signer for
+Arcana auth:
+
+```typescript
+import {
+  createZeroDevArcanaWalletAdapter,
+  registerArcanaDeviceWithAdapter,
+} from '@arcanahq/sdk-integrations/zerodev';
+
+const adapter = createZeroDevArcanaWalletAdapter({
+  ownerWalletClient,
+  smartAccountAddress: kernelClient.account.address,
+});
+
+await registerArcanaDeviceWithAdapter(client, adapter, {
+  deviceName: 'ZeroDev owner signer',
+});
+```
+
+## Failure Behavior
+
+The adapters intentionally fail loudly when required integration pieces are
+missing:
+
+- invalid or missing EVM address
+- missing `signTypedData`
+- malformed `eth_accounts` or `eth_chainId` provider responses
+- missing Arcana `deviceAuth`
+- Kernel/smart-account client passed without an owner signer
+
+There is no silent fallback from a smart account to an EOA signer. The app must
+choose and pass the correct signer explicitly.

package/dist/authenticate.d.ts

@@ -0,0 +1,15 @@
+import type { ArcanaWalletAdapter, DeviceRegistrationResponse, DomainInfo } from '@arcanahq/sdk';
+export interface ArcanaClientForDeviceRegistration {
+    auth: {
+        getDomainInfo(): Promise<DomainInfo>;
+    };
+    deviceAuth?: {
+        registerDevice(wallet: ArcanaWalletAdapter, address: `0x${string}`, chainId: number, verifyingContract: `0x${string}`, deviceName?: string): Promise<DeviceRegistrationResponse>;
+    };
+}
+export interface RegisterArcanaDeviceOptions {
+    chainId?: number;
+    verifyingContract?: `0x${string}`;
+    deviceName?: string;
+}
+export declare function registerArcanaDeviceWithAdapter(client: ArcanaClientForDeviceRegistration, adapter: ArcanaWalletAdapter, options?: RegisterArcanaDeviceOptions): Promise<DeviceRegistrationResponse>;

package/dist/authenticate.js

@@ -0,0 +1,16 @@
+import { assertHexAddress } from './common.js';
+export async function registerArcanaDeviceWithAdapter(client, adapter, options = {}) {
+    if (!client.deviceAuth) {
+        throw new Error('Arcana device authentication is not enabled on this client');
+    }
+    const address = await adapter.getAddress();
+    const domainInfo = await client.auth.getDomainInfo();
+    const domainVerifyingContract = domainInfo.verifyingContract || domainInfo.verifying_contract;
+    const verifyingContract = assertHexAddress(options.verifyingContract ?? domainVerifyingContract, 'Arcana auth verifying contract');
+    const adapterChainId = adapter.getChainId ? await adapter.getChainId() : undefined;
+    const chainId = options.chainId ?? adapterChainId ?? domainInfo.chainId;
+    if (chainId === undefined || !Number.isInteger(chainId)) {
+        throw new Error('Arcana device registration requires a chainId');
+    }
+    return client.deviceAuth.registerDevice(adapter, address, chainId, verifyingContract, options.deviceName);
+}

package/dist/common.d.ts

@@ -0,0 +1,31 @@
+import type { ArcanaTypedDataRequest, ArcanaWalletAdapter } from '@arcanahq/sdk';
+export type HexAddress = `0x${string}`;
+export type HexSignature = `0x${string}`;
+export interface SignTypedDataCapable {
+    signTypedData(request: ArcanaTypedDataRequest & {
+        account?: HexAddress;
+    }): Promise<HexSignature>;
+}
+export interface ViemWalletClientLike extends SignTypedDataCapable {
+    account?: {
+        address?: string;
+    } | HexAddress | null;
+    getAddresses?: () => Promise<string[]>;
+    getChainId?: () => Promise<number>;
+}
+export interface Eip1193ProviderLike {
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+}
+export interface AdapterOptions {
+    address?: string;
+    chainId?: number;
+}
+export declare function assertHexAddress(address: string | undefined | null, label?: string): HexAddress;
+export declare function resolveAddress(provided: string | undefined, walletClient?: ViemWalletClientLike, provider?: Eip1193ProviderLike): Promise<HexAddress>;
+export declare function resolveChainId(provided: number | undefined, walletClient?: ViemWalletClientLike, provider?: Eip1193ProviderLike): Promise<number | undefined>;
+export declare function stringifyTypedData(request: ArcanaTypedDataRequest): string;
+export declare function createViemArcanaWalletAdapter(walletClient: ViemWalletClientLike, options?: AdapterOptions): ArcanaWalletAdapter;
+export declare function createEip1193ArcanaWalletAdapter(provider: Eip1193ProviderLike, options?: AdapterOptions): ArcanaWalletAdapter;

package/dist/common.js

@@ -0,0 +1,113 @@
+export function assertHexAddress(address, label = 'address') {
+    if (!address || !/^0x[a-fA-F0-9]{40}$/.test(address)) {
+        throw new Error(`Arcana integration requires a valid EVM ${label}`);
+    }
+    return address.toLowerCase();
+}
+export async function resolveAddress(provided, walletClient, provider) {
+    if (provided) {
+        return assertHexAddress(provided);
+    }
+    const account = walletClient?.account;
+    if (typeof account === 'string') {
+        return assertHexAddress(account);
+    }
+    if (account && typeof account === 'object' && account.address) {
+        return assertHexAddress(account.address);
+    }
+    if (walletClient?.getAddresses) {
+        const addresses = await walletClient.getAddresses();
+        return assertHexAddress(addresses[0], 'wallet address');
+    }
+    if (provider) {
+        const addresses = await provider.request({ method: 'eth_accounts' });
+        if (!Array.isArray(addresses)) {
+            throw new Error('Arcana integration expected eth_accounts to return an array');
+        }
+        return assertHexAddress(addresses[0], 'wallet address');
+    }
+    throw new Error('Arcana integration could not resolve a wallet address');
+}
+export async function resolveChainId(provided, walletClient, provider) {
+    if (provided !== undefined) {
+        return provided;
+    }
+    if (walletClient?.getChainId) {
+        return walletClient.getChainId();
+    }
+    if (provider) {
+        const chainId = await provider.request({ method: 'eth_chainId' });
+        if (typeof chainId === 'string') {
+            const parsed = chainId.startsWith('0x') ? parseInt(chainId, 16) : parseInt(chainId, 10);
+            if (!Number.isInteger(parsed)) {
+                throw new Error('Arcana integration expected eth_chainId to be parseable as an integer');
+            }
+            return parsed;
+        }
+        if (typeof chainId === 'number') {
+            return chainId;
+        }
+        throw new Error('Arcana integration expected eth_chainId to return a string or number');
+    }
+    return undefined;
+}
+export function stringifyTypedData(request) {
+    return JSON.stringify({
+        domain: request.domain,
+        types: request.types,
+        primaryType: request.primaryType,
+        message: request.message,
+    }, (_key, value) => typeof value === 'bigint' ? value.toString() : value);
+}
+export function createViemArcanaWalletAdapter(walletClient, options = {}) {
+    if (!walletClient || typeof walletClient.signTypedData !== 'function') {
+        throw new Error('Arcana integration requires a Viem-compatible signer with signTypedData');
+    }
+    return {
+        async getAddress() {
+            return resolveAddress(options.address, walletClient);
+        },
+        async getChainId() {
+            const chainId = await resolveChainId(options.chainId, walletClient);
+            if (chainId === undefined) {
+                throw new Error('Arcana integration could not resolve chainId from the Viem signer');
+            }
+            return chainId;
+        },
+        async signTypedData(request) {
+            const address = await resolveAddress(options.address, walletClient);
+            return walletClient.signTypedData({
+                ...request,
+                account: address,
+            });
+        },
+    };
+}
+export function createEip1193ArcanaWalletAdapter(provider, options = {}) {
+    if (!provider || typeof provider.request !== 'function') {
+        throw new Error('Arcana integration requires an EIP-1193 provider with request()');
+    }
+    return {
+        async getAddress() {
+            return resolveAddress(options.address, undefined, provider);
+        },
+        async getChainId() {
+            const chainId = await resolveChainId(options.chainId, undefined, provider);
+            if (chainId === undefined) {
+                throw new Error('Arcana integration could not resolve chainId from the EIP-1193 provider');
+            }
+            return chainId;
+        },
+        async signTypedData(request) {
+            const address = await resolveAddress(options.address, undefined, provider);
+            const signature = await provider.request({
+                method: 'eth_signTypedData_v4',
+                params: [address, stringifyTypedData(request)],
+            });
+            if (typeof signature !== 'string' || !signature.startsWith('0x')) {
+                throw new Error('Arcana integration expected eth_signTypedData_v4 to return a hex signature');
+            }
+            return signature;
+        },
+    };
+}

package/dist/dynamic-zerodev.d.ts

@@ -0,0 +1,8 @@
+import type { ZeroDevArcanaAdapterOptions, ZeroDevArcanaWalletAdapter } from './zerodev.js';
+export { registerArcanaDeviceWithAdapter } from './authenticate.js';
+export type { ArcanaClientForDeviceRegistration, RegisterArcanaDeviceOptions } from './authenticate.js';
+export { createDynamicArcanaWalletAdapter } from './dynamic.js';
+export type { DynamicArcanaAdapterOptions, DynamicWalletLike } from './dynamic.js';
+export { createZeroDevArcanaWalletAdapter } from './zerodev.js';
+export type { ZeroDevAccountLike, ZeroDevArcanaAdapterOptions, ZeroDevArcanaWalletAdapter, ZeroDevClientLike } from './zerodev.js';
+export declare function createDynamicZeroDevArcanaWalletAdapter(options: ZeroDevArcanaAdapterOptions): ZeroDevArcanaWalletAdapter;

package/dist/dynamic-zerodev.js

@@ -0,0 +1,7 @@
+import { createZeroDevArcanaWalletAdapter } from './zerodev.js';
+export { registerArcanaDeviceWithAdapter } from './authenticate.js';
+export { createDynamicArcanaWalletAdapter } from './dynamic.js';
+export { createZeroDevArcanaWalletAdapter } from './zerodev.js';
+export function createDynamicZeroDevArcanaWalletAdapter(options) {
+    return createZeroDevArcanaWalletAdapter(options);
+}

package/dist/dynamic.d.ts

@@ -0,0 +1,42 @@
+import type { ArcanaWalletAdapter } from '@arcanahq/sdk';
+import { AdapterOptions, Eip1193ProviderLike, ViemWalletClientLike } from './common.js';
+import { ArcanaClientForDeviceRegistration, RegisterArcanaDeviceOptions } from './authenticate.js';
+export { registerArcanaDeviceWithAdapter } from './authenticate.js';
+export type { ArcanaClientForDeviceRegistration, RegisterArcanaDeviceOptions } from './authenticate.js';
+export interface DynamicWalletLike {
+    address?: string;
+    getAddress?: () => string | Promise<string>;
+    getEthereumProvider?: () => Eip1193ProviderLike | Promise<Eip1193ProviderLike>;
+    getWalletClient?: () => ViemWalletClientLike | Promise<ViemWalletClientLike>;
+    connector?: {
+        getSigner?: () => unknown | Promise<unknown>;
+    };
+}
+export interface DynamicArcanaAdapterOptions extends AdapterOptions {
+    wallet?: DynamicWalletLike;
+    walletClient?: ViemWalletClientLike;
+}
+export interface DynamicArcanaAuthClient extends ArcanaClientForDeviceRegistration {
+    ensureAuthenticated?(): Promise<boolean>;
+    isAuthenticated?(): boolean;
+    deviceAuth?: ArcanaClientForDeviceRegistration['deviceAuth'] & {
+        activateWallet?(address: string | null): Promise<void>;
+        getUserId?(): string | null;
+        getWalletAddress?(): string | null;
+    };
+}
+export interface DynamicArcanaAuthOptions extends DynamicArcanaAdapterOptions, RegisterArcanaDeviceOptions {
+    client: DynamicArcanaAuthClient;
+    deviceName?: string;
+    ensureChain?: boolean;
+}
+export interface DynamicArcanaAuthResult {
+    adapter: ArcanaWalletAdapter;
+    address: `0x${string}`;
+    userId: string;
+    status: 'restored' | 'registered';
+    restored: boolean;
+}
+export declare function createDynamicArcanaWalletAdapter(options: DynamicArcanaAdapterOptions): Promise<ArcanaWalletAdapter>;
+export declare function ensureArcanaSessionWithDynamic(options: DynamicArcanaAuthOptions): Promise<DynamicArcanaAuthResult>;
+export declare function authenticateArcanaWithDynamic(options: DynamicArcanaAuthOptions): Promise<DynamicArcanaAuthResult>;

package/dist/dynamic.js

@@ -0,0 +1,64 @@
+import { createEip1193ArcanaWalletAdapter, createViemArcanaWalletAdapter, } from './common.js';
+import { registerArcanaDeviceWithAdapter, } from './authenticate.js';
+export { registerArcanaDeviceWithAdapter } from './authenticate.js';
+export async function createDynamicArcanaWalletAdapter(options) {
+    if (options.walletClient) {
+        return createViemArcanaWalletAdapter(options.walletClient, options);
+    }
+    if (!options.wallet) {
+        throw new Error('Dynamic Arcana integration requires a Dynamic wallet or Viem walletClient');
+    }
+    const walletAddress = options.address
+        ?? options.wallet.address
+        ?? (typeof options.wallet.getAddress === 'function' ? await options.wallet.getAddress() : undefined);
+    if (typeof options.wallet.getWalletClient === 'function') {
+        const walletClient = await options.wallet.getWalletClient();
+        return createViemArcanaWalletAdapter(walletClient, {
+            ...options,
+            address: walletAddress,
+        });
+    }
+    if (typeof options.wallet.getEthereumProvider === 'function') {
+        const provider = await options.wallet.getEthereumProvider();
+        return createEip1193ArcanaWalletAdapter(provider, {
+            ...options,
+            address: walletAddress,
+        });
+    }
+    throw new Error('Dynamic wallet does not expose getWalletClient() or getEthereumProvider(); pass a Dynamic Viem walletClient instead');
+}
+export async function ensureArcanaSessionWithDynamic(options) {
+    const { client, chainId, ensureChain = true } = options;
+    const adapter = await createDynamicArcanaWalletAdapter(options);
+    const address = await adapter.getAddress();
+    await client.deviceAuth?.activateWallet?.(address);
+    if (client.isAuthenticated?.()) {
+        const sessionWallet = client.deviceAuth?.getWalletAddress?.()?.toLowerCase() || '';
+        if (!sessionWallet || sessionWallet === address.toLowerCase()) {
+            const authenticated = await client.ensureAuthenticated?.();
+            const userId = client.deviceAuth?.getUserId?.() || '';
+            if (authenticated && userId) {
+                return { adapter, address, userId, status: 'restored', restored: true };
+            }
+        }
+    }
+    if (ensureChain && chainId !== undefined) {
+        const adapterChainId = await adapter.getChainId?.();
+        if (adapterChainId !== undefined && adapterChainId !== chainId) {
+            throw new Error(`Dynamic wallet is connected to chain ${adapterChainId}; switch to chain ${chainId} and retry`);
+        }
+    }
+    const registration = await registerArcanaDeviceWithAdapter(client, adapter, {
+        chainId,
+        verifyingContract: options.verifyingContract,
+        deviceName: options.deviceName,
+    });
+    const userId = registration.user_id || client.deviceAuth?.getUserId?.() || '';
+    if (!userId) {
+        throw new Error('Arcana Dynamic authentication did not return a user id');
+    }
+    return { adapter, address, userId, status: 'registered', restored: false };
+}
+export async function authenticateArcanaWithDynamic(options) {
+    return ensureArcanaSessionWithDynamic(options);
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { createEip1193ArcanaWalletAdapter, createViemArcanaWalletAdapter, } from './common.js';
+export type { AdapterOptions, Eip1193ProviderLike, HexAddress, HexSignature, SignTypedDataCapable, ViemWalletClientLike, } from './common.js';
+export { registerArcanaDeviceWithAdapter } from './authenticate.js';
+export type { ArcanaClientForDeviceRegistration, RegisterArcanaDeviceOptions, } from './authenticate.js';
+export { createPrivyArcanaWalletAdapter } from './privy.js';
+export type { PrivyArcanaAdapterOptions, PrivyWalletLike } from './privy.js';
+export { authenticateArcanaWithDynamic, createDynamicArcanaWalletAdapter, ensureArcanaSessionWithDynamic, } from './dynamic.js';
+export type { DynamicArcanaAdapterOptions, DynamicArcanaAuthClient, DynamicArcanaAuthOptions, DynamicArcanaAuthResult, DynamicWalletLike, } from './dynamic.js';
+export { DEFAULT_ARCANA_TEST_PRIVATE_KEY, createTestArcanaWalletAdapter, } from './test.js';
+export type { TestArcanaAdapterOptions } from './test.js';
+export { createZeroDevArcanaWalletAdapter } from './zerodev.js';
+export type { ZeroDevAccountLike, ZeroDevArcanaAdapterOptions, ZeroDevArcanaWalletAdapter, ZeroDevClientLike, } from './zerodev.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { createEip1193ArcanaWalletAdapter, createViemArcanaWalletAdapter, } from './common.js';
+export { registerArcanaDeviceWithAdapter } from './authenticate.js';
+export { createPrivyArcanaWalletAdapter } from './privy.js';
+export { authenticateArcanaWithDynamic, createDynamicArcanaWalletAdapter, ensureArcanaSessionWithDynamic, } from './dynamic.js';
+export { DEFAULT_ARCANA_TEST_PRIVATE_KEY, createTestArcanaWalletAdapter, } from './test.js';
+export { createZeroDevArcanaWalletAdapter } from './zerodev.js';

package/dist/privy-zerodev.d.ts

@@ -0,0 +1,8 @@
+import type { ZeroDevArcanaAdapterOptions, ZeroDevArcanaWalletAdapter } from './zerodev.js';
+export { registerArcanaDeviceWithAdapter } from './authenticate.js';
+export type { ArcanaClientForDeviceRegistration, RegisterArcanaDeviceOptions } from './authenticate.js';
+export { createPrivyArcanaWalletAdapter } from './privy.js';
+export type { PrivyArcanaAdapterOptions, PrivyWalletLike } from './privy.js';
+export { createZeroDevArcanaWalletAdapter } from './zerodev.js';
+export type { ZeroDevAccountLike, ZeroDevArcanaAdapterOptions, ZeroDevArcanaWalletAdapter, ZeroDevClientLike } from './zerodev.js';
+export declare function createPrivyZeroDevArcanaWalletAdapter(options: ZeroDevArcanaAdapterOptions): ZeroDevArcanaWalletAdapter;

package/dist/privy-zerodev.js

@@ -0,0 +1,7 @@
+import { createZeroDevArcanaWalletAdapter } from './zerodev.js';
+export { registerArcanaDeviceWithAdapter } from './authenticate.js';
+export { createPrivyArcanaWalletAdapter } from './privy.js';
+export { createZeroDevArcanaWalletAdapter } from './zerodev.js';
+export function createPrivyZeroDevArcanaWalletAdapter(options) {
+    return createZeroDevArcanaWalletAdapter(options);
+}

package/dist/privy.d.ts

@@ -0,0 +1,14 @@
+import type { ArcanaWalletAdapter } from '@arcanahq/sdk';
+import { AdapterOptions, Eip1193ProviderLike, ViemWalletClientLike } from './common.js';
+export { registerArcanaDeviceWithAdapter } from './authenticate.js';
+export type { ArcanaClientForDeviceRegistration, RegisterArcanaDeviceOptions } from './authenticate.js';
+export interface PrivyWalletLike {
+    address?: string;
+    getEthereumProvider?: () => Eip1193ProviderLike | Promise<Eip1193ProviderLike>;
+}
+export interface PrivyArcanaAdapterOptions extends AdapterOptions {
+    wallet?: PrivyWalletLike;
+    walletClient?: ViemWalletClientLike;
+    account?: ViemWalletClientLike;
+}
+export declare function createPrivyArcanaWalletAdapter(options: PrivyArcanaAdapterOptions): Promise<ArcanaWalletAdapter>;

package/dist/privy.js

@@ -0,0 +1,21 @@
+import { createEip1193ArcanaWalletAdapter, createViemArcanaWalletAdapter, } from './common.js';
+export { registerArcanaDeviceWithAdapter } from './authenticate.js';
+export async function createPrivyArcanaWalletAdapter(options) {
+    if (options.walletClient) {
+        return createViemArcanaWalletAdapter(options.walletClient, options);
+    }
+    if (options.account) {
+        return createViemArcanaWalletAdapter(options.account, options);
+    }
+    if (!options.wallet) {
+        throw new Error('Privy Arcana integration requires a Privy wallet, Viem walletClient, or Viem account');
+    }
+    if (typeof options.wallet.getEthereumProvider !== 'function') {
+        throw new Error('Privy wallet does not expose getEthereumProvider(); pass toViemAccount(wallet) as account instead');
+    }
+    const provider = await options.wallet.getEthereumProvider();
+    return createEip1193ArcanaWalletAdapter(provider, {
+        ...options,
+        address: options.address ?? options.wallet.address,
+    });
+}