Mobile SDK v1

npm install @sparkvault/sdk-mobile

import * as FileSystem from 'expo-file-system/legacy';
import { createSparkVaultMobileClient } from '@sparkvault/sdk-mobile';

const client = createSparkVaultMobileClient({
  tokenStorage,                                   // your SecureStore-backed adapter
  identityAccountId: 'acc_YOUR_ACCOUNT_ID',
  userAgent: 'YourApp/1.0.0 (Mobile)',
  fetch: xhrFetch,                                // your fetch wrapper

  fileReader: {
    readAsBase64: (fileUri, { position, length }) =>
      FileSystem.readAsStringAsync(fileUri, {
        encoding: 'base64',
        position,
        length,
      }),
  },

  fileDownloader: {
    download: async (url, fileUri, options) => {
      const resumable = FileSystem.createDownloadResumable(
        url,
        fileUri,
        {},
        progress => options?.onProgress?.({
          bytesWritten: progress.totalBytesWritten,
          bytesTotal: progress.totalBytesExpectedToWrite || undefined,
        })
      );
      const result = await resumable.downloadAsync();
      return result ? { uri: result.uri, status: result.status, headers: result.headers } : null;
    },
    getInfo: async (fileUri) => {
      const info = await FileSystem.getInfoAsync(fileUri);
      return { exists: info.exists, sizeBytes: info.exists ? info.size : undefined };
    },
    delete: (fileUri) => FileSystem.deleteAsync(fileUri, { idempotent: true }),
  },
});

import * as Passkey from 'react-native-passkeys';
import {
  SparkVaultIdentityDialog,
  type MobilePasskeyProvider,
} from '@sparkvault/sdk-mobile/identity-dialog';

const passkeyProvider: MobilePasskeyProvider = {
  isSupported: () => Passkey.isSupported(),
  authenticate: async (options) => {
    const credential = await Passkey.get({
      challenge: options.challenge,
      timeout: options.timeout,
      rpId: options.rpId,
      userVerification: options.userVerification,
    });
    return credential
      ? {
          id: credential.id,
          rawId: credential.rawId,
          type: 'public-key',
          response: {
            clientDataJSON: credential.response.clientDataJSON,
            authenticatorData: credential.response.authenticatorData,
            signature: credential.response.signature,
            userHandle: credential.response.userHandle,
          },
        }
      : null;
  },
};

<SparkVaultIdentityDialog
  client={client}
  visible={visible}
  passkeyProvider={passkeyProvider}
  onCancel={() => setVisible(false)}
  onSuccess={async (result) => {
    await client.products.identity.verifyIdentityToken(result.token, { jwks: result.jwks });
    const session = await client.account.exchangeIdentityToken(result.token);

    if ('needs_signup_info' in session) {
      await client.account.completeSignup(session.signup_token, {
        organization_name: 'Acme',
      });
    }
  }}
/>

const session = await client.vaults.unseal(vaultId, { vmk });

// Upload from a local file URI
await client.ingots.uploadFromUri({
  vaultId,
  vat: session.vat,
  fileUri,
  fileSize,
  name: 'photo.jpg',
  contentType: 'image/jpeg',
  folder: 'Trips/2026',  // optional vault path; missing segments are find-or-created
  onProgress: (uploaded, total) => console.log(uploaded / total),
});

// Replace an existing ingot's data
await client.ingots.replaceFromUri({
  vaultId,
  ingotId,
  vat: session.vat,
  fileUri,
  fileSize,
  name: 'photo.jpg',
  contentType: 'image/jpeg',
});

// Download to a file URI: single OS-streaming path, retries with fresh URLs
const result = await client.ingots.downloadToFile({
  vaultId,
  ingotId,
  vat: session.vat,
  fileUri: `${FileSystem.cacheDirectory}photo.jpg`,
  expectedSizeBytes,
  onProgress: (written, total) => console.log(written / total),
});

// List, get, create, update, delete
const vaults = await client.vaults.list();
const vault = await client.vaults.get(vaultId);
const created = await client.vaults.create({ name: 'My Vault' });
await client.vaults.update(vaultId, { name: 'Renamed' });
await client.vaults.delete(vaultId);

// Unseal / seal
const session = await client.vaults.unseal(vaultId, { vmk });
await client.vaults.seal(vaultId);

// Sharing
await client.vaults.enableSharing(vaultId, vmk, { all_ingots_public: false });
await client.vaults.disableSharing(vaultId);

// Folders + ingots inside a vault
const folders = await client.folders.list(vaultId, session.vat);
const ingots = await client.ingots.list(vaultId, session.vat);

const status = await client.health.check();
// status.online: true when the API returns 2xx
// status.status: 'healthy' | 'unhealthy' | 'unreachable'
// status.httpStatus: HTTP status when a response was received
// status.checkedAt: Unix timestamp
// status.error: network/timeout message when unreachable

const online = await client.health.isOnline();