Expo / React Native

pnpm add @arkade-os/sdk @scure/bip39
pnpm dlx expo install expo-crypto expo-sqlite

// App.tsx or index.js - MUST be first import
import * as Crypto from 'expo-crypto'

if (!global.crypto) global.crypto = {} as any
global.crypto.getRandomValues = Crypto.getRandomValues

// Now import the SDK
import { Wallet, MnemonicIdentity } from '@arkade-os/sdk'
import { ExpoArkProvider, ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo'

import { MnemonicIdentity, Wallet } from '@arkade-os/sdk'
import { ExpoArkProvider, ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo'
import {
  SQLiteContractRepository,
  SQLiteWalletRepository,
  type SQLExecutor,
} from '@arkade-os/sdk/repositories/sqlite'
import * as SQLite from 'expo-sqlite'

// Connect the SDK to an SQLite database
const db = SQLite.openDatabaseSync('wallet.db')
const bind = (params?: unknown[]) => (params ?? []) as SQLite.SQLiteBindValue[]

const executor: SQLExecutor = {
  run: async (sql, params) => { await db.runAsync(sql, bind(params)) },
  get: async (sql, params) => (await db.getFirstAsync(sql, bind(params))) ?? undefined,
  all: (sql, params) => db.getAllAsync(sql, bind(params)),
}

// Call with the mnemonic from your secure storage
export async function openWallet(mnemonic: string) {
  return Wallet.create({
    identity: MnemonicIdentity.fromMnemonic(mnemonic),
    arkProvider: new ExpoArkProvider(),
    indexerProvider: new ExpoIndexerProvider(),
    storage: {
      walletRepository: new SQLiteWalletRepository(executor),
      contractRepository: new SQLiteContractRepository(executor),
    },
  })
}

pnpm dlx expo install expo-task-manager expo-background-task @react-native-async-storage/async-storage

// arkade.ts
import { MnemonicIdentity } from '@arkade-os/sdk'
import { ExpoArkProvider, ExpoIndexerProvider } from '@arkade-os/sdk/adapters/expo'
import {
  SQLiteContractRepository,
  SQLiteWalletRepository,
  type SQLExecutor,
} from '@arkade-os/sdk/repositories/sqlite'
import { ExpoWallet } from '@arkade-os/sdk/wallet/expo'
import {
  defineExpoBackgroundTask,
  registerExpoBackgroundTask,
  unregisterExpoBackgroundTask,
} from '@arkade-os/sdk/wallet/expo/background'
import { AsyncStorageTaskQueue } from '@arkade-os/sdk/worker/expo'
import AsyncStorage from '@react-native-async-storage/async-storage'
import * as SQLite from 'expo-sqlite'

const TASK_NAME = 'ark-background-poll'

const db = SQLite.openDatabaseSync('wallet.db')
const bind = (params?: unknown[]) => (params ?? []) as SQLite.SQLiteBindValue[]

const executor: SQLExecutor = {
  run: async (sql, params) => { await db.runAsync(sql, bind(params)) },
  get: async (sql, params) => (await db.getFirstAsync(sql, bind(params))) ?? undefined,
  all: (sql, params) => db.getAllAsync(sql, bind(params)),
}

const storage = {
  walletRepository: new SQLiteWalletRepository(executor),
  contractRepository: new SQLiteContractRepository(executor),
}
const taskQueue = new AsyncStorageTaskQueue(AsyncStorage)

// Module scope: runs when the app starts, before React mounts
defineExpoBackgroundTask(TASK_NAME, { taskQueue, ...storage })

// Call with the mnemonic from your secure storage
export async function openWallet(mnemonic: string) {
  const wallet = await ExpoWallet.setup({
    identity: MnemonicIdentity.fromMnemonic(mnemonic),
    arkProvider: new ExpoArkProvider(),
    indexerProvider: new ExpoIndexerProvider(),
    storage,
    background: { taskQueue, foregroundIntervalMs: 20_000 },
  })
  await registerExpoBackgroundTask(TASK_NAME)
  return wallet
}

// Call when the user logs out
export async function closeWallet(wallet: ExpoWallet) {
  await wallet.dispose()
  // dispose() doesn't unregister the background task
  await unregisterExpoBackgroundTask(TASK_NAME)
}