Setup

import { configureStore } from '@reduxjs/toolkit';
import {
  bindReduxStateAdapter,
  createReduxStateAdapter,
} from '@arcanetech/privacy-sdk-state-redux';

export const privacySdkState = createReduxStateAdapter({
  reducerPath: 'privacySdkState',
});

export const store = configureStore({
  reducer: {
    [privacySdkState.reducerPath]: privacySdkState.reducer,
  },
  middleware: (getDefaultMiddleware) =>
    getDefaultMiddleware().concat(privacySdkState.middleware),
});

bindReduxStateAdapter(privacySdkState, store);

import type { StellarWalletAdapter } from '@arcanetech/privacy-sdk-stellar';

export const wallet: StellarWalletAdapter = {
  getAddress: async () => 'GDSENDER7EXAMPLEPUBLICKEYAAAAAAAAAAAAAAAAAAAA',
  authorizeMessage: async (message) =>
    new TextEncoder().encode(typeof message === 'string' ? message : ''),
  signTransactionPayload: async (payload) => ({ ...payload, signed: true }),
};

import {
  createStellarPolicyAdapterFromEnvironment,
  createStellarPrivacyClient,
  isStellarPrivacyClient,
  loadDefaultStellarBrowserAssets,
} from '@arcanetech/privacy-sdk-stellar';
import type { StellarTransactEnvironment } from '@arcanetech/privacy-sdk-stellar/transact';
import { privacySdkState } from './store';
import { wallet } from './wallet';

const transactEnvironment: StellarTransactEnvironment = {
  network: {
    id: 'stellar-testnet',
    rpcUrl: 'https://soroban-testnet.stellar.org',
    networkPassphrase: 'Test SDF Network ; September 2015',
    poolContract: 'CBVQTSTSIJ4UZMN5FQBFHPUIYSW3ATGSP57BZDJNKTOBNQODQTRGE4K5',
    registryContract: 'CCO5QRTS5HFVPR356FFC4NI62IMBQNDGMOAXR4K5UVTV3YMRWDZGKXGC',
    applicationId: '00000000-0000-0000-0000-000000000001',
  },
  kyt: {
    apiBaseUrl: 'https://example.invalid',
    kytPassageRegistryContract: 'CKYTEXAMPLECONTRACTIDAAAAAAAAAAAAAAAAAAAAAA',
  },
  signTransaction: async ({ xdr }) => ({ signedTxXdr: xdr }),
};

export async function bootstrapPrivacyClient() {
  const assets = await loadDefaultStellarBrowserAssets();
  const created = await createStellarPrivacyClient({
    network: transactEnvironment.network,
    wallet,
    state: privacySdkState.adapter,
    assets,
    auditPublicKeyHex:
      'a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2',
    transactEnvironment,
    policy: createStellarPolicyAdapterFromEnvironment(transactEnvironment),
  });
  if (!isStellarPrivacyClient(created)) {
    throw new Error('Privacy client rejected during initialization.');
  }
  return created;
}

import React, { createContext, useContext, useEffect, useMemo, useState } from 'react';
import type { StellarPrivacyClient } from '@arcanetech/privacy-sdk-stellar';
import { bootstrapPrivacyClient } from './bootstrap-privacy-client';

const PrivacySdkContext = createContext<{
  client: StellarPrivacyClient | undefined;
  ready: boolean;
}>({ client: undefined, ready: false });

export function usePrivacySdkClient() {
  return useContext(PrivacySdkContext);
}

export function PrivacySdkProvider({ children }: { children: React.ReactNode }) {
  const [client, setClient] = useState<StellarPrivacyClient>();
  const [ready, setReady] = useState(false);

  useEffect(() => {
    bootstrapPrivacyClient()
      .then((created) => {
        setClient(created);
        setReady(true);
      })
      .catch(() => setReady(false));
  }, []);

  const value = useMemo(() => ({ client, ready }), [client, ready]);
  return (
    <PrivacySdkContext.Provider value={value}>{children}</PrivacySdkContext.Provider>
  );
}

import { useEffect } from 'react';
import { hydrateReduxPrivacySdkState } from '@arcanetech/privacy-sdk-state-redux';
import { store } from './store';

const STORAGE_KEY = 'privacy-sdk-state:v1';

function loadSavedBranch(owner: string) {
  const raw = localStorage.getItem(`${STORAGE_KEY}:${owner}`);
  return raw ? (JSON.parse(raw) as Record<string, unknown>) : undefined;
}

function saveBranch(owner: string, branch: Record<string, unknown>) {
  localStorage.setItem(`${STORAGE_KEY}:${owner}`, JSON.stringify(branch));
}

export function usePrivacySdkPersistence(walletAddress: string | undefined) {
  useEffect(() => {
    const owner = walletAddress?.trim();
    if (!owner) return;

    const saved = loadSavedBranch(owner);
    if (saved && Object.keys(store.getState().privacySdkState).length === 0) {
      store.dispatch(hydrateReduxPrivacySdkState(saved));
    }

    return store.subscribe(() => {
      saveBranch(owner, store.getState().privacySdkState);
    });
  }, [walletAddress]);
}