> ## Documentation Index
> Fetch the complete documentation index at: https://sdk.umbraprivacy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Dependency Injection

> Dependency injection: args (required params) vs deps (injectable RPC, blockhash, tx forwarding, master seed). Client-level defaults with per-call commitment overrides on any factory function.

## Client-Level Defaults

`getUmbraClient` accepts its own `deps` object that sets the **default** for every downstream function. Any function-level `deps` override takes precedence.

```typescript theme={null}
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,
    },
  },
);
```

```typescript theme={null}
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;
  };
}
```

***

## Infrastructure Providers

These appear as optional overrides across virtually every function's `deps` type.

### `accountInfoProvider`

Fetches raw on-chain account data. Used by every function that reads on-chain state.

```typescript theme={null}
type AccountInfoProviderFunction = (
  addresses: readonly Address[],
) => Promise<Map<Address, MaybeEncodedAccount>>;
```

Default: RPC batch fetch via `rpcUrl`.

Override for: unit tests (no live node), custom RPC middleware, account caching, or simulated state.

### `blockhashProvider` / `getLatestBlockhash`

Returns the latest confirmed [blockhash](https://solana.com/docs/terminology#blockhash) and last valid block height for transaction construction.

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

Default: RPC call via `rpcUrl`.

Override for: deterministic transaction snapshots in tests, or to fetch from an alternative source.

### `transactionForwarder`

Handles transaction broadcast and confirmation. Used by every function that submits on-chain transactions.

```typescript theme={null}
interface TransactionForwarder {
  forwardSequentially(txs: readonly SignedTransaction[]): Promise<TransactionSignature[]>;
  forwardInParallel(txs: readonly SignedTransaction[]): Promise<TransactionSignature[]>;
}
```

Default: [WebSocket](https://solana.com/docs/rpc/websocket/signaturesubscribe)-based forwarder using `signatureSubscribe` for confirmation.

Override for [Jito](https://www.jito.network/) bundle submission, priority fee management, dry-run recording in tests, or custom retry logic:

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

### `epochInfoProvider`

Returns current Solana epoch information. Used for [Token-2022 transfer fee](/advanced/token-2022) schedule selection.

```typescript theme={null}
type GetEpochInfo = () => Promise<EpochInfoResult>;
```

Default: RPC call via `rpcUrl`.

***

## Master Seed Storage

Controls how the master seed is persisted and derived between sessions. Provided at the client level only.

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

Default: re-derive from `signer.signMessage(UMBRA_MESSAGE_TO_SIGN)` on every client construction. No persistence across page loads.

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

<Warning>
  Never persist the master seed in plaintext `localStorage` / `IndexedDB`. The seed is equivalent in sensitivity to a private key. Production persistence requires encrypted-at-rest storage keyed by a user-controlled secret (WebAuthn-derived, password-derived via Argon2id, or wallet-signed challenge) **and** scoped per-wallet (key includes the wallet pubkey). The scaffold defaults to re-derive every session.
</Warning>

See [Key Derivation](/sdk/advanced/key-derivation) for how the master seed is structured and derived from the wallet signature.