Dependency Injection

import { getUmbraClient } from "@umbra-privacy/sdk";

const client = await getUmbraClient(
  {
    signer,
    network: "mainnet",
    rpcUrl,
    rpcSubscriptionsUrl,
    indexerApiEndpoint,   // optional but required for scanning + burning
    relayerApiEndpoint,   // optional but required for burning
    utxoDataStore,        // optional but strongly recommended on browser
    nullifierStore,       // optional but strongly recommended on browser
  },
  {
    accountInfoProvider,    // override RPC account fetching
    blockhashProvider,      // override blockhash source
    transactionForwarder,   // override broadcast + confirmation
    epochInfoProvider,      // override epoch info
    masterSeedStorage: {    // control seed persistence
      load,
      store,
      generate,
    },
  },
);

interface GetUmbraClientFromSignerDeps {
  readonly accountInfoProvider?: AccountInfoProviderFunction;
  readonly blockhashProvider?: GetLatestBlockhash;
  readonly transactionForwarder?: TransactionForwarder;
  readonly epochInfoProvider?: GetEpochInfo;
  readonly masterSeedStorage?: {
    readonly load?: MasterSeedLoaderFunction;
    readonly store?: MasterSeedStorerFunction;
    readonly generate?: MasterSeedGeneratorFunction;
  };
}

type AccountInfoProviderFunction = (
  addresses: readonly Address[],
) => Promise<Map<Address, MaybeEncodedAccount>>;

type GetLatestBlockhash = () => Promise<{
  blockhash: string;
  lastValidBlockHeight: number;
}>;

interface TransactionForwarder {
  forwardSequentially(txs: readonly SignedTransaction[]): Promise<TransactionSignature[]>;
  forwardInParallel(txs: readonly SignedTransaction[]): Promise<TransactionSignature[]>;
}

const jitoForwarder: TransactionForwarder = {
  forwardSequentially: async (txs) => submitToJitoBundleEndpoint(txs),
  forwardInParallel: async (txs) => submitToJitoBundleEndpoint(txs),
};

type GetEpochInfo = () => Promise<EpochInfoResult>;

interface MasterSeedStorage {
  load: () => Promise<{ exists: true; seed: MasterSeed } | { exists: false }>;
  store: (seed: MasterSeed) => Promise<void>;
  generate: () => Promise<MasterSeed>; // called when load returns exists: false
}

// CI — fixed deterministic seed, no wallet prompt.
const client = await getUmbraClient(args, {
  masterSeedStorage: {
    generate: async () => FIXED_TEST_SEED,
  },
});