@umbra-privacy/sdk 1.0.0

package/dist/chunk-HOEXDXRC.cjs

@@ -0,0 +1,792 @@
+'use strict';
+
+var chunkPK6SKIKE_cjs = require('./chunk-PK6SKIKE.cjs');
+
+// src/common/errors.ts
+var UmbraError = class _UmbraError extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "UmbraError");
+  }
+  /**
+   * A machine-readable error code for programmatic error handling.
+   *
+   * @remarks
+   * Defaults to `"UMBRA_ERROR"` when no code is supplied in the constructor options.
+   * Sub-classes or specific throw sites should supply a more specific code to allow
+   * callers to branch on error identity without string-matching `message`.
+   *
+   * @readonly
+   */
+  code;
+  /**
+   * Additional context about the error.
+   *
+   * @remarks
+   * A free-form key-value map of diagnostic data attached to the error at the throw site.
+   * Useful for logging and debugging — consumers should not rely on specific keys for
+   * control flow; use `code` for programmatic branching instead.
+   *
+   * Will be `undefined` when no context was provided to the constructor.
+   *
+   * @readonly
+   */
+  context;
+  /**
+   * The original error that caused this error, if any.
+   *
+   * @remarks
+   * When an SDK function wraps a lower-level error (e.g., a failed RPC call or a
+   * cryptographic library error), it sets `cause` to the original thrown value so
+   * callers can inspect the full error chain.
+   *
+   * Will be `undefined` when there is no underlying cause.
+   *
+   * @readonly
+   */
+  cause;
+  /**
+   * Creates a new UmbraError.
+   *
+   * @param message - Human-readable description of what went wrong. Should be
+   *   actionable and specific enough for a developer to understand the failure
+   *   without reading source code.
+   * @param options - Optional structured metadata attached to the error.
+   * @param options.code - Machine-readable error code for programmatic branching.
+   *   Defaults to `"UMBRA_ERROR"` if omitted.
+   * @param options.context - Free-form diagnostic key-value pairs. Omit or set to
+   *   `undefined` to leave the `context` property unset.
+   * @param options.cause - The original error that triggered this one. Enables
+   *   full error-chain inspection. Omit or set to `undefined` when there is no
+   *   underlying cause.
+   *
+   * @defaultValue `options` — `undefined` (all options optional)
+   * @defaultValue `options.code` — `"UMBRA_ERROR"`
+   */
+  constructor(message, options) {
+    super(message);
+    this.name = "UmbraError";
+    this.code = options?.code ?? "UMBRA_ERROR";
+    if (options?.context !== void 0) {
+      this.context = options.context;
+    }
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    Error.captureStackTrace(this, _UmbraError);
+  }
+};
+function isUmbraError(error) {
+  return error instanceof UmbraError;
+}
+chunkPK6SKIKE_cjs.__name(isUmbraError, "isUmbraError");
+var MathematicsAssertionError = class _MathematicsAssertionError extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "MathematicsAssertionError");
+  }
+  /**
+   * The actual value that failed the assertion.
+   *
+   * @remarks
+   * The runtime type reflects what was actually passed to the assertion function:
+   * - `bigint` for integer assertions (`assertU8`, `assertU256`, etc.)
+   * - `Uint8Array` for byte-array assertions (`assertU256LeBytes`, `assertU32LeBytes`, etc.)
+   * - Any other type when a non-numeric value was passed unexpectedly
+   *
+   * @readonly
+   */
+  value;
+  /**
+   * The type that was expected.
+   *
+   * @remarks
+   * Contains the branded type name exactly as it appears in the SDK type system,
+   * e.g., `"U8"`, `"U256"`, `"U32LeBytes"`. Use this for structured logging or
+   * to build user-facing error messages without parsing the `message` string.
+   *
+   * @readonly
+   */
+  expectedType;
+  /**
+   * Description of the constraint that was violated.
+   *
+   * @remarks
+   * Is `undefined` when only a type check failed (e.g., a `string` was passed where a
+   * `bigint` was expected). Contains a human-readable inequality or length rule when a
+   * value of the correct type was out of the allowed range.
+   *
+   * @example
+   * - `"0 <= value <= 255"` — U8 range violation
+   * - `"length === 32"` — U256LeBytes length violation
+   * - `"value >= 0"` — negative value passed to an unsigned integer assertion
+   *
+   * @readonly
+   */
+  constraint;
+  /**
+   * Creates a new MathematicsAssertionError.
+   *
+   * @param message - Human-readable description of the assertion failure. Should name
+   *   the assertion function, the expected type, and the constraint that was violated.
+   * @param options - Structured diagnostic details attached to the error.
+   * @param options.value - The actual value that was supplied and failed the assertion.
+   * @param options.expectedType - The name of the branded type that was expected
+   *   (e.g., `"U8"`, `"U256LeBytes"`).
+   * @param options.constraint - Optional human-readable constraint description
+   *   (e.g., `"0 <= value <= 255"`). Omit when the failure is a type mismatch rather
+   *   than a range violation.
+   */
+  constructor(message, options) {
+    super(message);
+    this.name = "MathematicsAssertionError";
+    this.value = options.value;
+    this.expectedType = options.expectedType;
+    this.constraint = options.constraint;
+    Error.captureStackTrace(this, _MathematicsAssertionError);
+    Object.setPrototypeOf(this, _MathematicsAssertionError.prototype);
+  }
+};
+var CryptographyAssertionError = class _CryptographyAssertionError extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "CryptographyAssertionError");
+  }
+  /**
+   * The actual value that failed the assertion.
+   *
+   * @remarks
+   * The runtime type reflects what was actually passed to the assertion function:
+   * - `bigint` for field element assertions (`assertBn254FieldElement`, etc.)
+   * - `Uint8Array` for byte-array assertions (`assertAesKey`, `assertX25519PrivateKey`, etc.)
+   * - Any other type when an entirely wrong value type was supplied
+   *
+   * @readonly
+   */
+  value;
+  /**
+   * The type that was expected (e.g., `"Bn254FieldElement"`, `"PoseidonKey"`, `"AesKey"`).
+   *
+   * @remarks
+   * Contains the branded type name exactly as it appears in the SDK type system.
+   * Use this property for structured logging without parsing the `message` string.
+   *
+   * @readonly
+   */
+  expectedType;
+  /**
+   * Description of the constraint that was violated.
+   *
+   * @remarks
+   * Is `undefined` for pure type-mismatch failures (e.g., `string` instead of `bigint`).
+   * Contains a human-readable constraint description for range and length violations
+   * (e.g., `"value < BN254_FIELD_PRIME"`, `"length === 32"`).
+   *
+   * @readonly
+   */
+  constraint;
+  /**
+   * Creates a new CryptographyAssertionError.
+   *
+   * @param message - Human-readable description of the assertion failure. Should name
+   *   the assertion function, the expected type, and the constraint that was violated.
+   * @param options - Structured diagnostic details attached to the error.
+   * @param options.value - The actual value that was supplied and failed the assertion.
+   * @param options.expectedType - The name of the branded cryptographic type that was
+   *   expected (e.g., `"Bn254FieldElement"`, `"AesKey"`).
+   * @param options.constraint - Optional human-readable constraint description.
+   *   Omit when the failure is a type mismatch rather than a range or length violation.
+   */
+  constructor(message, options) {
+    super(message);
+    this.name = "CryptographyAssertionError";
+    this.value = options.value;
+    this.expectedType = options.expectedType;
+    this.constraint = options.constraint;
+    Error.captureStackTrace(this, _CryptographyAssertionError);
+    Object.setPrototypeOf(this, _CryptographyAssertionError.prototype);
+  }
+};
+var SolanaAssertionError = class _SolanaAssertionError extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "SolanaAssertionError");
+  }
+  /**
+   * The actual value that failed the assertion.
+   *
+   * @remarks
+   * The runtime type reflects what was actually passed to the assertion function:
+   * - `string` for Base58-encoded assertions (`assertTransactionSignature`, etc.)
+   * - `Uint8Array` for byte-array assertions (`assertSignatureBytes`, etc.)
+   * - Any other type when a completely wrong value type was supplied
+   *
+   * @readonly
+   */
+  value;
+  /**
+   * The type that was expected (e.g., `"TransactionSignature"`, `"SignatureBytes"`).
+   *
+   * @remarks
+   * Contains the branded type name exactly as it appears in the SDK type system.
+   * Use this for structured logging without parsing the `message` string.
+   *
+   * @readonly
+   */
+  expectedType;
+  /**
+   * Description of the constraint that was violated.
+   *
+   * @remarks
+   * Is `undefined` for pure type-mismatch failures. Contains a human-readable rule
+   * for encoding or length violations (e.g., `"valid Base58"`, `"length === 64"`).
+   *
+   * @readonly
+   */
+  constraint;
+  /**
+   * Creates a new SolanaAssertionError.
+   *
+   * @param message - Human-readable description of the assertion failure. Should name
+   *   the assertion function, the expected type, and the constraint that was violated.
+   * @param options - Structured diagnostic details attached to the error.
+   * @param options.value - The actual value that was supplied and failed the assertion.
+   * @param options.expectedType - The name of the branded Solana type that was expected
+   *   (e.g., `"TransactionSignature"`, `"SignatureBytes"`).
+   * @param options.constraint - Optional human-readable constraint description.
+   *   Omit when the failure is a type mismatch rather than an encoding or length violation.
+   */
+  constructor(message, options) {
+    super(message);
+    this.name = "SolanaAssertionError";
+    this.value = options.value;
+    this.expectedType = options.expectedType;
+    this.constraint = options.constraint;
+    Error.captureStackTrace(this, _SolanaAssertionError);
+    Object.setPrototypeOf(this, _SolanaAssertionError.prototype);
+  }
+};
+var TemporalAssertionError = class extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "TemporalAssertionError");
+  }
+  /**
+   * The actual value that failed the assertion.
+   *
+   * @remarks
+   * Will be a `bigint` for all temporal assertions since the temporal types are
+   * BigInt-backed branded types (e.g., `Year`, `Month`, `Day`). May also be any
+   * other type when a non-bigint value was supplied unexpectedly.
+   *
+   * @readonly
+   */
+  value;
+  /**
+   * The type that was expected (e.g., `"Year"`, `"Month"`, `"Hour"`).
+   *
+   * @remarks
+   * Contains the branded temporal type name exactly as it appears in the SDK type system.
+   * Use this for structured logging without parsing the `message` string.
+   *
+   * @readonly
+   */
+  expectedType;
+  /**
+   * Description of the constraint that was violated.
+   *
+   * @remarks
+   * Contains a human-readable range rule for out-of-range values
+   * (e.g., `"1 <= value <= 12"` for a month violation). Is `undefined` only for
+   * pure type-mismatch failures (e.g., a `string` passed where a `bigint` was expected),
+   * which should not occur in normal usage.
+   *
+   * @readonly
+   */
+  constraint;
+  /**
+   * Creates a new TemporalAssertionError.
+   *
+   * @param message - Human-readable description of the assertion failure. Should name
+   *   the assertion function, the expected type, and the violated range constraint.
+   * @param details - Structured diagnostic details attached to the error.
+   * @param details.value - The actual `bigint` value (or other type) that was supplied
+   *   and failed the temporal assertion.
+   * @param details.expectedType - The name of the branded temporal type that was expected
+   *   (e.g., `"Year"`, `"Month"`, `"Hour"`).
+   * @param details.constraint - Optional human-readable range description
+   *   (e.g., `"1 <= value <= 12"`). Omit when the failure is a type mismatch.
+   */
+  constructor(message, details) {
+    super(message);
+    this.name = "TemporalAssertionError";
+    this.value = details.value;
+    this.expectedType = details.expectedType;
+    this.constraint = details.constraint;
+  }
+};
+
+// src/crypto/errors.ts
+var CryptographyError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "CryptographyError");
+  }
+  /**
+   * The cryptographic operation that failed.
+   */
+  operation;
+  constructor(message, options) {
+    super(message, {
+      code: options?.code ?? "CRYPTOGRAPHY_ERROR",
+      ...options?.context !== void 0 && {
+        context: options.context
+      },
+      ...options?.cause !== void 0 && {
+        cause: options.cause
+      }
+    });
+    this.name = "CryptographyError";
+    if (options?.operation !== void 0) {
+      this.operation = options.operation;
+    }
+  }
+};
+function isCryptographyError(error) {
+  return error instanceof CryptographyError;
+}
+chunkPK6SKIKE_cjs.__name(isCryptographyError, "isCryptographyError");
+
+// src/solana/errors.ts
+var InstructionError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "InstructionError");
+  }
+  /**
+   * The name of the instruction that failed during construction or validation.
+   *
+   * @remarks
+   * Matches the Anchor instruction name (camelCase), e.g. `"encryptedDeposit"`,
+   * `"initUserAccount"`. May be `undefined` if the failing instruction could
+   * not be identified at the throw site.
+   */
+  instructionName;
+  /**
+   * Creates a new `InstructionError`.
+   *
+   * @param message - Human-readable description of the instruction failure.
+   * @param options - Optional structured metadata.
+   * @param options.code - Error code string. Defaults to `"INSTRUCTION_ERROR"`.
+   * @param options.instructionName - The name of the failing instruction.
+   * @param options.context - Arbitrary key-value pairs for diagnostic context.
+   * @param options.cause - The underlying error that caused this failure, if any.
+   */
+  constructor(message, options) {
+    super(message, {
+      code: options?.code ?? "INSTRUCTION_ERROR",
+      ...options?.context !== void 0 && {
+        context: options.context
+      },
+      ...options?.cause !== void 0 && {
+        cause: options.cause
+      }
+    });
+    this.name = "InstructionError";
+    if (options?.instructionName !== void 0) {
+      this.instructionName = options.instructionName;
+    }
+  }
+};
+var RpcError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "RpcError");
+  }
+  /**
+   * The RPC endpoint URL that was called when the error occurred.
+   *
+   * @remarks
+   * May be `undefined` if the endpoint was not known at the throw site (e.g.,
+   * when the error originates deep within `@solana/kit` internals).
+   */
+  endpoint;
+  /**
+   * The HTTP status code returned by the RPC node, if applicable.
+   *
+   * @remarks
+   * `undefined` for network-level failures (e.g., DNS resolution failure,
+   * connection refused) where no HTTP response was received.
+   */
+  statusCode;
+  /**
+   * The JSON-RPC error code from the response body, if any.
+   *
+   * @remarks
+   * Set when the RPC node returns a well-formed JSON-RPC error object with a
+   * numeric `code` field. `undefined` for HTTP-level failures or when the node
+   * returns a malformed response body.
+   */
+  rpcErrorCode;
+  /**
+   * Creates a new `RpcError`.
+   *
+   * @param message - Human-readable description of the RPC failure.
+   * @param options - Optional structured metadata.
+   * @param options.code - Error code string. Defaults to `"RPC_ERROR"`.
+   * @param options.endpoint - The RPC endpoint URL that was called.
+   * @param options.statusCode - HTTP status code from the response, if any.
+   * @param options.rpcErrorCode - JSON-RPC error code from the response, if any.
+   * @param options.context - Arbitrary key-value pairs for diagnostic context.
+   * @param options.cause - The underlying error that caused this failure, if any.
+   */
+  constructor(message, options) {
+    super(message, {
+      code: options?.code ?? "RPC_ERROR",
+      ...options?.context !== void 0 && {
+        context: options.context
+      },
+      ...options?.cause !== void 0 && {
+        cause: options.cause
+      }
+    });
+    this.name = "RpcError";
+    if (options?.endpoint !== void 0) {
+      this.endpoint = options.endpoint;
+    }
+    if (options?.statusCode !== void 0) {
+      this.statusCode = options.statusCode;
+    }
+    if (options?.rpcErrorCode !== void 0) {
+      this.rpcErrorCode = options.rpcErrorCode;
+    }
+  }
+};
+var TransactionError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "TransactionError");
+  }
+  /**
+   * The transaction signature, if available.
+   *
+   * @remarks
+   * Base58-encoded signature string. Present when the transaction was submitted
+   * to the network but failed during execution. Use this to look up the failed
+   * transaction in a block explorer.
+   */
+  signature;
+  /**
+   * Simulation log output from the transaction preflight, if available.
+   *
+   * @remarks
+   * Each entry in the array is one line of program log output (e.g.,
+   * `"Program log: ..."` or `"Program <address> failed: ..."`). Anchor programs
+   * emit error codes and names here when constraints are violated.
+   */
+  simulationLogs;
+  /**
+   * Creates a new `TransactionError`.
+   *
+   * @param message - Human-readable description of the transaction failure.
+   * @param options - Optional structured metadata.
+   * @param options.code - Error code string. Defaults to `"TRANSACTION_ERROR"`.
+   * @param options.signature - Base58-encoded transaction signature, if available.
+   * @param options.simulationLogs - Program log output from preflight simulation.
+   * @param options.context - Arbitrary key-value pairs for diagnostic context.
+   * @param options.cause - The underlying error that caused this failure, if any.
+   */
+  constructor(message, options) {
+    super(message, {
+      code: options?.code ?? "TRANSACTION_ERROR",
+      ...options?.context !== void 0 && {
+        context: options.context
+      },
+      ...options?.cause !== void 0 && {
+        cause: options.cause
+      }
+    });
+    this.name = "TransactionError";
+    if (options?.signature !== void 0) {
+      this.signature = options.signature;
+    }
+    if (options?.simulationLogs !== void 0) {
+      this.simulationLogs = options.simulationLogs;
+    }
+  }
+};
+var TransactionSigningError = class extends TransactionError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "TransactionSigningError");
+  }
+  /**
+   * Whether the signing was explicitly rejected by the user.
+   *
+   * @remarks
+   * `true` when the wallet UI presented a sign request and the user actively
+   * clicked "Reject" or equivalent. `false` when the failure was due to a
+   * technical issue (disconnected device, timeout, missing key).
+   *
+   * @defaultValue `false`
+   */
+  wasRejected;
+  /**
+   * The address of the signer that failed to produce a signature.
+   *
+   * @remarks
+   * Base58-encoded public key string. May be `undefined` if the failing signer
+   * could not be identified at the throw site.
+   */
+  signerAddress;
+  /**
+   * Creates a new `TransactionSigningError`.
+   *
+   * @param message - Human-readable description of the signing failure.
+   * @param options - Optional structured metadata.
+   * @param options.code - Error code string. Defaults to `"TRANSACTION_SIGNING_ERROR"`.
+   * @param options.wasRejected - Whether the user deliberately rejected. Defaults to `false`.
+   * @param options.signerAddress - Base58 address of the signer that failed.
+   * @param options.signature - Transaction signature, if the transaction was partially signed.
+   * @param options.context - Arbitrary key-value pairs for diagnostic context.
+   * @param options.cause - The underlying error that caused this failure, if any.
+   */
+  constructor(message, options) {
+    super(message, {
+      code: options?.code ?? "TRANSACTION_SIGNING_ERROR",
+      ...options?.signature !== void 0 && {
+        signature: options.signature
+      },
+      ...options?.context !== void 0 && {
+        context: options.context
+      },
+      ...options?.cause !== void 0 && {
+        cause: options.cause
+      }
+    });
+    this.name = "TransactionSigningError";
+    this.wasRejected = options?.wasRejected ?? false;
+    if (options?.signerAddress !== void 0) {
+      this.signerAddress = options.signerAddress;
+    }
+  }
+};
+var MasterSeedSigningRejectedError = class extends TransactionSigningError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "MasterSeedSigningRejectedError");
+  }
+  /**
+   * Creates a new `MasterSeedSigningRejectedError`.
+   *
+   * @param message - Human-readable description. Defaults to a standard rejection
+   *   message explaining that the user declined the required derivation signature.
+   * @param options - Optional structured metadata.
+   * @param options.signerAddress - Base58 address of the wallet that rejected.
+   * @param options.context - Arbitrary key-value pairs for diagnostic context.
+   * @param options.cause - The underlying error that caused this failure, if any.
+   */
+  constructor(message = "Master seed derivation was rejected. The user declined to sign the required message.", options) {
+    super(message, {
+      code: "MASTER_SEED_SIGNING_REJECTED",
+      wasRejected: true,
+      ...options?.signerAddress !== void 0 && {
+        signerAddress: options.signerAddress
+      },
+      ...options?.context !== void 0 && {
+        context: options.context
+      },
+      ...options?.cause !== void 0 && {
+        cause: options.cause
+      }
+    });
+    this.name = "MasterSeedSigningRejectedError";
+  }
+};
+function isInstructionError(error) {
+  return error instanceof InstructionError;
+}
+chunkPK6SKIKE_cjs.__name(isInstructionError, "isInstructionError");
+function isRpcError(error) {
+  return error instanceof RpcError;
+}
+chunkPK6SKIKE_cjs.__name(isRpcError, "isRpcError");
+function isTransactionError(error) {
+  return error instanceof TransactionError;
+}
+chunkPK6SKIKE_cjs.__name(isTransactionError, "isTransactionError");
+function isTransactionSigningError(error) {
+  return error instanceof TransactionSigningError;
+}
+chunkPK6SKIKE_cjs.__name(isTransactionSigningError, "isTransactionSigningError");
+
+// src/umbra/errors.ts
+var EncryptedDepositError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "EncryptedDepositError");
+  }
+  stage;
+  constructor(stage, message, cause) {
+    super(message, {
+      code: `ENCRYPTED_DEPOSIT_${stage.toUpperCase().replaceAll("-", "_")}`,
+      cause
+    });
+    this.name = "EncryptedDepositError";
+    this.stage = stage;
+  }
+};
+function isEncryptedDepositError(error) {
+  return error instanceof EncryptedDepositError;
+}
+chunkPK6SKIKE_cjs.__name(isEncryptedDepositError, "isEncryptedDepositError");
+var EncryptedWithdrawalError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "EncryptedWithdrawalError");
+  }
+  stage;
+  constructor(stage, message, cause) {
+    super(message, {
+      code: `ENCRYPTED_WITHDRAWAL_${stage.toUpperCase().replaceAll("-", "_")}`,
+      cause
+    });
+    this.name = "EncryptedWithdrawalError";
+    this.stage = stage;
+  }
+};
+function isEncryptedWithdrawalError(error) {
+  return error instanceof EncryptedWithdrawalError;
+}
+chunkPK6SKIKE_cjs.__name(isEncryptedWithdrawalError, "isEncryptedWithdrawalError");
+var RegistrationError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "RegistrationError");
+  }
+  stage;
+  constructor(stage, message, cause) {
+    super(message, {
+      code: `REGISTRATION_${stage.toUpperCase().replaceAll("-", "_")}`,
+      cause
+    });
+    this.name = "RegistrationError";
+    this.stage = stage;
+  }
+};
+function isRegistrationError(error) {
+  return error instanceof RegistrationError;
+}
+chunkPK6SKIKE_cjs.__name(isRegistrationError, "isRegistrationError");
+var ConversionError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "ConversionError");
+  }
+  stage;
+  constructor(stage, message, cause) {
+    super(message, {
+      code: `CONVERSION_${stage.toUpperCase().replaceAll("-", "_")}`,
+      cause
+    });
+    this.name = "ConversionError";
+    this.stage = stage;
+  }
+};
+function isConversionError(error) {
+  return error instanceof ConversionError;
+}
+chunkPK6SKIKE_cjs.__name(isConversionError, "isConversionError");
+var CreateUtxoError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "CreateUtxoError");
+  }
+  stage;
+  constructor(stage, message, cause) {
+    super(message, {
+      code: `CREATE_UTXO_${stage.toUpperCase().replaceAll("-", "_")}`,
+      cause
+    });
+    this.name = "CreateUtxoError";
+    this.stage = stage;
+  }
+};
+function isCreateUtxoError(error) {
+  return error instanceof CreateUtxoError;
+}
+chunkPK6SKIKE_cjs.__name(isCreateUtxoError, "isCreateUtxoError");
+var FetchUtxosError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "FetchUtxosError");
+  }
+  stage;
+  constructor(stage, message, cause) {
+    super(message, {
+      code: `FETCH_UTXOS_${stage.toUpperCase().replaceAll("-", "_")}`,
+      cause
+    });
+    this.name = "FetchUtxosError";
+    this.stage = stage;
+  }
+};
+function isFetchUtxosError(error) {
+  return error instanceof FetchUtxosError;
+}
+chunkPK6SKIKE_cjs.__name(isFetchUtxosError, "isFetchUtxosError");
+var ClaimUtxoError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "ClaimUtxoError");
+  }
+  stage;
+  constructor(stage, message, cause) {
+    super(message, {
+      code: `CLAIM_UTXO_${stage.toUpperCase().replaceAll("-", "_")}`,
+      cause
+    });
+    this.name = "ClaimUtxoError";
+    this.stage = stage;
+  }
+};
+function isClaimUtxoError(error) {
+  return error instanceof ClaimUtxoError;
+}
+chunkPK6SKIKE_cjs.__name(isClaimUtxoError, "isClaimUtxoError");
+var QueryError = class extends UmbraError {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "QueryError");
+  }
+  stage;
+  constructor(stage, message, cause) {
+    super(message, {
+      code: `QUERY_${stage.toUpperCase().replaceAll("-", "_")}`,
+      cause
+    });
+    this.name = "QueryError";
+    this.stage = stage;
+  }
+};
+function isQueryError(error) {
+  return error instanceof QueryError;
+}
+chunkPK6SKIKE_cjs.__name(isQueryError, "isQueryError");
+
+exports.ClaimUtxoError = ClaimUtxoError;
+exports.ConversionError = ConversionError;
+exports.CreateUtxoError = CreateUtxoError;
+exports.CryptographyAssertionError = CryptographyAssertionError;
+exports.CryptographyError = CryptographyError;
+exports.EncryptedDepositError = EncryptedDepositError;
+exports.EncryptedWithdrawalError = EncryptedWithdrawalError;
+exports.FetchUtxosError = FetchUtxosError;
+exports.InstructionError = InstructionError;
+exports.MasterSeedSigningRejectedError = MasterSeedSigningRejectedError;
+exports.MathematicsAssertionError = MathematicsAssertionError;
+exports.QueryError = QueryError;
+exports.RegistrationError = RegistrationError;
+exports.RpcError = RpcError;
+exports.SolanaAssertionError = SolanaAssertionError;
+exports.TemporalAssertionError = TemporalAssertionError;
+exports.TransactionError = TransactionError;
+exports.TransactionSigningError = TransactionSigningError;
+exports.UmbraError = UmbraError;
+exports.isClaimUtxoError = isClaimUtxoError;
+exports.isConversionError = isConversionError;
+exports.isCreateUtxoError = isCreateUtxoError;
+exports.isCryptographyError = isCryptographyError;
+exports.isEncryptedDepositError = isEncryptedDepositError;
+exports.isEncryptedWithdrawalError = isEncryptedWithdrawalError;
+exports.isFetchUtxosError = isFetchUtxosError;
+exports.isInstructionError = isInstructionError;
+exports.isQueryError = isQueryError;
+exports.isRegistrationError = isRegistrationError;
+exports.isRpcError = isRpcError;
+exports.isTransactionError = isTransactionError;
+exports.isTransactionSigningError = isTransactionSigningError;
+exports.isUmbraError = isUmbraError;
+//# sourceMappingURL=chunk-HOEXDXRC.cjs.map
+//# sourceMappingURL=chunk-HOEXDXRC.cjs.map