Conversion

function getNetworkEncryptionToSharedEncryptionConverterFunction(
  args: GetConvertToSharedEncryptionFunctionArgs,
  deps?: GetConvertToSharedEncryptionFunctionDeps,
): ConvertToSharedEncryptionFunction

type ConvertToSharedEncryptionFunction = (
  mints: readonly Address[],
  optionalData?: OptionalData32,
  hooks?: ConvertToSharedHooks,
  microLamportsPerAcu?: MicroLamportsPerAcu,
) => Promise<ConvertToSharedEncryptionResult>;

interface ConvertToSharedEncryptionResult {
  readonly signatures: readonly TransactionSignature[];   // from OperationOutcome
  readonly converted: Map<Address, TransactionSignature>;
  readonly skipped:   Map<Address, ConvertToSharedEncryptionSkipReason>;
}

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

const convert = getNetworkEncryptionToSharedEncryptionConverterFunction({ client });
const result = await convert([usdcMint, solMint]);

for (const [mint, sig] of result.converted) {
  console.log(`Converted ${mint}:`, sig);
}
for (const [mint, reason] of result.skipped) {
  console.log(`Skipped ${mint}: ${reason}`);
}

function getMintEncryptionKeyRotatorFunction(
  args: GetRotateMintX25519EncryptionKeyFunctionArgs,
  deps?: GetRotateMintX25519EncryptionKeyFunctionDeps,
): RotateMintX25519EncryptionKeyFunction

type RotateMintX25519EncryptionKeyFunction = (
  mint: Address,
  optionalData?: OptionalData32,
  hooks?: RotateMintKeyHooks,
  microLamportsPerAcu?: MicroLamportsPerAcu,
  options?: RotateMintKeyOptions,
) => Promise<TransactionSignature>

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

const rotateMintKey = getMintEncryptionKeyRotatorFunction({ client });
const signature = await rotateMintKey(usdcMint);