@gvnrdao/dh-sdk 0.0.166 → 0.0.205

package/dist/server.js

@@ -0,0 +1,285 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  envLog: () => envLog,
+  getCurrentEnvironment: () => getCurrentEnvironment,
+  getEncryptedPriceProviders: () => getEncryptedPriceProviders,
+  loadEncryptedProviderRegistry: () => loadEncryptedProviderRegistry,
+  loadSDKConfig: () => loadSDKConfig,
+  resolveLitNetworkFromEnv: () => resolveLitNetworkFromEnv,
+  validateSDKEnvironment: () => validateSDKEnvironment
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/constants/chunks/environment.ts
+var import_fs = require("fs");
+var import_dotenv = require("dotenv");
+var path = __toESM(require("path"));
+
+// src/constants/chunks/sdk-config.ts
+var DEFAULT_LIT_NETWORKS = {
+  CHIPOTLE: "chipotle"
+};
+var DEFAULT_LIT_NETWORK = DEFAULT_LIT_NETWORKS.CHIPOTLE;
+var VALID_LIT_NETWORKS = [
+  DEFAULT_LIT_NETWORKS.CHIPOTLE
+];
+
+// src/constants/chunks/environment.ts
+var possibleEnvPaths = [
+  ".env",
+  path.join(__dirname, "../../.env"),
+  path.join(__dirname, "../../../.env")
+];
+var envPathsAttemptedAbs = [];
+var envPathsMergedAbs = [];
+for (const envPath of possibleEnvPaths) {
+  const abs = path.resolve(envPath);
+  envPathsAttemptedAbs.push(abs);
+  if (!(0, import_fs.existsSync)(abs)) {
+    continue;
+  }
+  try {
+    const result = (0, import_dotenv.config)({ path: abs });
+    if (!result.error) {
+      envPathsMergedAbs.push(abs);
+    }
+  } catch {
+  }
+}
+var envDiscoveryLogged = false;
+function logEnvDiscoveryOnce() {
+  if (envDiscoveryLogged) {
+    return;
+  }
+  envDiscoveryLogged = true;
+  if (process.env.DEBUG_SDK !== "true") {
+    return;
+  }
+  console.log("[SDK] .env multi-path load", {
+    attempted: envPathsAttemptedAbs,
+    mergedFromExistingFiles: envPathsMergedAbs,
+    note: "later paths override earlier (dotenv)"
+  });
+}
+logEnvDiscoveryOnce();
+function environmentNameFromLitNetwork(_network) {
+  return "chipotle";
+}
+function resolveLitNetworkFromEnv() {
+  const env = process.env;
+  const raw = env["LIT_NETWORK"];
+  if (raw === void 0 || raw === "") {
+    return DEFAULT_LIT_NETWORK;
+  }
+  const network = raw;
+  if (!VALID_LIT_NETWORKS.includes(network)) {
+    throw new Error(
+      `Invalid LIT_NETWORK: "${raw}". Must be one of: ${VALID_LIT_NETWORKS.join(
+        ", "
+      )}. Omit or leave empty for default "${DEFAULT_LIT_NETWORK}" (production Chipotle).`
+    );
+  }
+  return network;
+}
+function getCurrentEnvironment() {
+  return environmentNameFromLitNetwork(resolveLitNetworkFromEnv());
+}
+function loadSDKConfig() {
+  const env = process.env;
+  const litNetwork = resolveLitNetworkFromEnv();
+  const environment = environmentNameFromLitNetwork(litNetwork);
+  const realLitTesting = env["REAL_LIT_TESTING"] === "true";
+  const debugMode = env["DEBUG_SDK"] === "true";
+  const runRealIntegrationTests = env["RUN_REAL_INTEGRATION_TESTS"] === "true";
+  const litRelayUrl = env["LIT_RELAY_URL"];
+  const ethRpcUrl = env["ETH_RPC_URL"];
+  const polygonRpcUrl = env["POLYGON_RPC_URL"];
+  if (!ethRpcUrl) {
+    throw new Error(
+      "ETH_RPC_URL environment variable is required for SDK configuration"
+    );
+  }
+  if (!polygonRpcUrl) {
+    throw new Error(
+      "POLYGON_RPC_URL environment variable is required for SDK configuration"
+    );
+  }
+  const pkpMintPrivateKey = env["PKP_MINT_PRIVATE_KEY"];
+  const config2 = {
+    environment,
+    litNetwork,
+    realLitTesting,
+    debugMode,
+    runRealIntegrationTests,
+    ethRpcUrl,
+    polygonRpcUrl
+  };
+  if (litRelayUrl)
+    config2.litRelayUrl = litRelayUrl;
+  if (pkpMintPrivateKey)
+    config2.pkpMintPrivateKey = pkpMintPrivateKey;
+  return config2;
+}
+function envLog(message, ...args) {
+  const config2 = loadSDKConfig();
+  if (config2.debugMode) {
+    console.log(
+      `[SDK:${config2.environment.toUpperCase()}] ${message}`,
+      ...args
+    );
+  }
+}
+function validateSDKEnvironment(requirements) {
+  const config2 = loadSDKConfig();
+  if (requirements.requiresRealLitTesting && !config2.realLitTesting) {
+    throw new Error("REAL_LIT_TESTING=true is required for this operation");
+  }
+  if (requirements.requiresPrivateKey && !config2.pkpMintPrivateKey) {
+    throw new Error(
+      "PKP_MINT_PRIVATE_KEY environment variable is required for this operation"
+    );
+  }
+  return config2;
+}
+
+// src/constants/chunks/encrypted-provider-params.ts
+var fs = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var DEFAULT_REGISTRY_PATH = path2.resolve(
+  __dirname,
+  "../../../config/encrypted-params.sepolia.json"
+);
+function assertNonEmptyString(value, fieldName, providerName) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    const prefix = providerName ? `provider "${providerName}"` : "registry";
+    throw new Error(
+      `Invalid encrypted params ${prefix}: "${fieldName}" must be a non-empty string`
+    );
+  }
+  return value.trim();
+}
+function parseRegistry(raw, registryPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to parse encrypted params registry at ${registryPath}: ${message}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error(
+      `Invalid encrypted params registry at ${registryPath}: expected JSON object`
+    );
+  }
+  const candidate = parsed;
+  const network = assertNonEmptyString(candidate.network, "network");
+  if (!Array.isArray(candidate.providers) || candidate.providers.length === 0) {
+    throw new Error(
+      `Invalid encrypted params registry at ${registryPath}: "providers" must be a non-empty array`
+    );
+  }
+  const providers = candidate.providers.map((provider, index) => {
+    const p = provider;
+    const name = assertNonEmptyString(
+      p.name,
+      "name",
+      `index ${index.toString()}`
+    ).toLowerCase();
+    const pkpId = assertNonEmptyString(p.pkpId, "pkpId", name);
+    const apiKeyEncrypted = assertNonEmptyString(
+      p.apiKeyEncrypted,
+      "apiKeyEncrypted",
+      name
+    );
+    if (typeof p.version !== "number" || !Number.isFinite(p.version) || p.version < 1) {
+      throw new Error(
+        `Invalid encrypted params provider "${name}": "version" must be a positive number`
+      );
+    }
+    const updatedAt = assertNonEmptyString(p.updatedAt, "updatedAt", name);
+    const normalized = {
+      name,
+      pkpId,
+      apiKeyEncrypted,
+      version: p.version,
+      updatedAt
+    };
+    if (p.apiSecretEncrypted !== void 0) {
+      normalized.apiSecretEncrypted = assertNonEmptyString(
+        p.apiSecretEncrypted,
+        "apiSecretEncrypted",
+        name
+      );
+    }
+    return normalized;
+  });
+  return { network, providers };
+}
+function loadEncryptedProviderRegistry(registryPath = DEFAULT_REGISTRY_PATH) {
+  if (!fs.existsSync(registryPath)) {
+    throw new Error(`Encrypted params registry file not found: ${registryPath}`);
+  }
+  const raw = fs.readFileSync(registryPath, "utf8");
+  return parseRegistry(raw, registryPath);
+}
+function getEncryptedPriceProviders(providerNames = ["coinbase", "coinmarketcap", "binance"], registryPath = DEFAULT_REGISTRY_PATH) {
+  const registry = loadEncryptedProviderRegistry(registryPath);
+  const desiredNames = providerNames.map((name) => name.trim().toLowerCase());
+  const selected = desiredNames.map((name) => {
+    const found = registry.providers.find((provider) => provider.name === name);
+    if (!found) {
+      throw new Error(
+        `Encrypted params registry missing provider "${name}" for network "${registry.network}"`
+      );
+    }
+    return {
+      name: found.name,
+      pkpId: found.pkpId,
+      apiKey: found.apiKeyEncrypted,
+      apiSecret: found.apiSecretEncrypted
+    };
+  });
+  return selected;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  envLog,
+  getCurrentEnvironment,
+  getEncryptedPriceProviders,
+  loadEncryptedProviderRegistry,
+  loadSDKConfig,
+  resolveLitNetworkFromEnv,
+  validateSDKEnvironment
+});

package/dist/server.mjs

@@ -0,0 +1,242 @@
+// src/constants/chunks/environment.ts
+import { existsSync } from "fs";
+import { config } from "dotenv";
+import * as path from "path";
+
+// src/constants/chunks/sdk-config.ts
+var DEFAULT_LIT_NETWORKS = {
+  CHIPOTLE: "chipotle"
+};
+var DEFAULT_LIT_NETWORK = DEFAULT_LIT_NETWORKS.CHIPOTLE;
+var VALID_LIT_NETWORKS = [
+  DEFAULT_LIT_NETWORKS.CHIPOTLE
+];
+
+// src/constants/chunks/environment.ts
+var possibleEnvPaths = [
+  ".env",
+  path.join(__dirname, "../../.env"),
+  path.join(__dirname, "../../../.env")
+];
+var envPathsAttemptedAbs = [];
+var envPathsMergedAbs = [];
+for (const envPath of possibleEnvPaths) {
+  const abs = path.resolve(envPath);
+  envPathsAttemptedAbs.push(abs);
+  if (!existsSync(abs)) {
+    continue;
+  }
+  try {
+    const result = config({ path: abs });
+    if (!result.error) {
+      envPathsMergedAbs.push(abs);
+    }
+  } catch {
+  }
+}
+var envDiscoveryLogged = false;
+function logEnvDiscoveryOnce() {
+  if (envDiscoveryLogged) {
+    return;
+  }
+  envDiscoveryLogged = true;
+  if (process.env.DEBUG_SDK !== "true") {
+    return;
+  }
+  console.log("[SDK] .env multi-path load", {
+    attempted: envPathsAttemptedAbs,
+    mergedFromExistingFiles: envPathsMergedAbs,
+    note: "later paths override earlier (dotenv)"
+  });
+}
+logEnvDiscoveryOnce();
+function environmentNameFromLitNetwork(_network) {
+  return "chipotle";
+}
+function resolveLitNetworkFromEnv() {
+  const env = process.env;
+  const raw = env["LIT_NETWORK"];
+  if (raw === void 0 || raw === "") {
+    return DEFAULT_LIT_NETWORK;
+  }
+  const network = raw;
+  if (!VALID_LIT_NETWORKS.includes(network)) {
+    throw new Error(
+      `Invalid LIT_NETWORK: "${raw}". Must be one of: ${VALID_LIT_NETWORKS.join(
+        ", "
+      )}. Omit or leave empty for default "${DEFAULT_LIT_NETWORK}" (production Chipotle).`
+    );
+  }
+  return network;
+}
+function getCurrentEnvironment() {
+  return environmentNameFromLitNetwork(resolveLitNetworkFromEnv());
+}
+function loadSDKConfig() {
+  const env = process.env;
+  const litNetwork = resolveLitNetworkFromEnv();
+  const environment = environmentNameFromLitNetwork(litNetwork);
+  const realLitTesting = env["REAL_LIT_TESTING"] === "true";
+  const debugMode = env["DEBUG_SDK"] === "true";
+  const runRealIntegrationTests = env["RUN_REAL_INTEGRATION_TESTS"] === "true";
+  const litRelayUrl = env["LIT_RELAY_URL"];
+  const ethRpcUrl = env["ETH_RPC_URL"];
+  const polygonRpcUrl = env["POLYGON_RPC_URL"];
+  if (!ethRpcUrl) {
+    throw new Error(
+      "ETH_RPC_URL environment variable is required for SDK configuration"
+    );
+  }
+  if (!polygonRpcUrl) {
+    throw new Error(
+      "POLYGON_RPC_URL environment variable is required for SDK configuration"
+    );
+  }
+  const pkpMintPrivateKey = env["PKP_MINT_PRIVATE_KEY"];
+  const config2 = {
+    environment,
+    litNetwork,
+    realLitTesting,
+    debugMode,
+    runRealIntegrationTests,
+    ethRpcUrl,
+    polygonRpcUrl
+  };
+  if (litRelayUrl)
+    config2.litRelayUrl = litRelayUrl;
+  if (pkpMintPrivateKey)
+    config2.pkpMintPrivateKey = pkpMintPrivateKey;
+  return config2;
+}
+function envLog(message, ...args) {
+  const config2 = loadSDKConfig();
+  if (config2.debugMode) {
+    console.log(
+      `[SDK:${config2.environment.toUpperCase()}] ${message}`,
+      ...args
+    );
+  }
+}
+function validateSDKEnvironment(requirements) {
+  const config2 = loadSDKConfig();
+  if (requirements.requiresRealLitTesting && !config2.realLitTesting) {
+    throw new Error("REAL_LIT_TESTING=true is required for this operation");
+  }
+  if (requirements.requiresPrivateKey && !config2.pkpMintPrivateKey) {
+    throw new Error(
+      "PKP_MINT_PRIVATE_KEY environment variable is required for this operation"
+    );
+  }
+  return config2;
+}
+
+// src/constants/chunks/encrypted-provider-params.ts
+import * as fs from "fs";
+import * as path2 from "path";
+var DEFAULT_REGISTRY_PATH = path2.resolve(
+  __dirname,
+  "../../../config/encrypted-params.sepolia.json"
+);
+function assertNonEmptyString(value, fieldName, providerName) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    const prefix = providerName ? `provider "${providerName}"` : "registry";
+    throw new Error(
+      `Invalid encrypted params ${prefix}: "${fieldName}" must be a non-empty string`
+    );
+  }
+  return value.trim();
+}
+function parseRegistry(raw, registryPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to parse encrypted params registry at ${registryPath}: ${message}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error(
+      `Invalid encrypted params registry at ${registryPath}: expected JSON object`
+    );
+  }
+  const candidate = parsed;
+  const network = assertNonEmptyString(candidate.network, "network");
+  if (!Array.isArray(candidate.providers) || candidate.providers.length === 0) {
+    throw new Error(
+      `Invalid encrypted params registry at ${registryPath}: "providers" must be a non-empty array`
+    );
+  }
+  const providers = candidate.providers.map((provider, index) => {
+    const p = provider;
+    const name = assertNonEmptyString(
+      p.name,
+      "name",
+      `index ${index.toString()}`
+    ).toLowerCase();
+    const pkpId = assertNonEmptyString(p.pkpId, "pkpId", name);
+    const apiKeyEncrypted = assertNonEmptyString(
+      p.apiKeyEncrypted,
+      "apiKeyEncrypted",
+      name
+    );
+    if (typeof p.version !== "number" || !Number.isFinite(p.version) || p.version < 1) {
+      throw new Error(
+        `Invalid encrypted params provider "${name}": "version" must be a positive number`
+      );
+    }
+    const updatedAt = assertNonEmptyString(p.updatedAt, "updatedAt", name);
+    const normalized = {
+      name,
+      pkpId,
+      apiKeyEncrypted,
+      version: p.version,
+      updatedAt
+    };
+    if (p.apiSecretEncrypted !== void 0) {
+      normalized.apiSecretEncrypted = assertNonEmptyString(
+        p.apiSecretEncrypted,
+        "apiSecretEncrypted",
+        name
+      );
+    }
+    return normalized;
+  });
+  return { network, providers };
+}
+function loadEncryptedProviderRegistry(registryPath = DEFAULT_REGISTRY_PATH) {
+  if (!fs.existsSync(registryPath)) {
+    throw new Error(`Encrypted params registry file not found: ${registryPath}`);
+  }
+  const raw = fs.readFileSync(registryPath, "utf8");
+  return parseRegistry(raw, registryPath);
+}
+function getEncryptedPriceProviders(providerNames = ["coinbase", "coinmarketcap", "binance"], registryPath = DEFAULT_REGISTRY_PATH) {
+  const registry = loadEncryptedProviderRegistry(registryPath);
+  const desiredNames = providerNames.map((name) => name.trim().toLowerCase());
+  const selected = desiredNames.map((name) => {
+    const found = registry.providers.find((provider) => provider.name === name);
+    if (!found) {
+      throw new Error(
+        `Encrypted params registry missing provider "${name}" for network "${registry.network}"`
+      );
+    }
+    return {
+      name: found.name,
+      pkpId: found.pkpId,
+      apiKey: found.apiKeyEncrypted,
+      apiSecret: found.apiSecretEncrypted
+    };
+  });
+  return selected;
+}
+export {
+  envLog,
+  getCurrentEnvironment,
+  getEncryptedPriceProviders,
+  loadEncryptedProviderRegistry,
+  loadSDKConfig,
+  resolveLitNetworkFromEnv,
+  validateSDKEnvironment
+};

package/dist/types/authorization-params.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Typed Authorization Parameters using Discriminated Unions
+ *
+ * This file defines type-safe authorization parameter types that replace
+ * the generic `Record<string, any>` previously used in AuthorizationRequest.
+ *
+ * Each authorization action has its own specific parameter type, ensuring
+ * compile-time safety and better IDE support.
+ */
+import { UCD, Satoshis, UnixTimestamp } from "./branded/domain-values";
+/**
+ * Base authorization parameters shared by all authorization types
+ */
+interface BaseAuthParams {
+    /** Unix timestamp when the authorization request was created */
+    timestamp: UnixTimestamp;
+    /** Chain ID where the operation will be executed */
+    chainId: number;
+}
+/**
+ * Parameters for creating a new loan/position
+ */
+export interface CreateLoanAuthParams extends BaseAuthParams {
+    type: "create";
+    /** Selected loan term in months (e.g., 12, 24, 36) */
+    selectedTerm: number;
+    /** Borrower's Ethereum address */
+    borrower: string;
+    /** PKP public key for Bitcoin custody */
+    publicKey: string;
+}
+/**
+ * Parameters for minting UCD against existing collateral
+ */
+export interface MintUCDAuthParams extends BaseAuthParams {
+    type: "mint";
+    /** Position/loan identifier */
+    positionId: string;
+    /** Amount of UCD to mint (in wei, 18 decimals) */
+    amount: UCD;
+    /** PKP public key (optional - validator PKP is passed separately to authorizeMintUCD) */
+    publicKey?: string;
+    /** Bitcoin provider URL for balance verification */
+    bitcoinProviderUrl?: string;
+    /** Selected term in months (override when contract state is zero) */
+    selectedTerm?: number;
+}
+/**
+ * Parameters for withdrawing Bitcoin from vault
+ */
+export interface WithdrawBTCAuthParams extends BaseAuthParams {
+    type: "withdraw";
+    /** Position/loan identifier */
+    positionId: string;
+    /** Destination Bitcoin address */
+    destinationAddress: string;
+    /** Amount to withdraw in satoshis */
+    amount: Satoshis;
+    /** PKP public key */
+    publicKey: string;
+}
+/**
+ * Parameters for repaying UCD debt
+ */
+export interface RepayDebtAuthParams extends BaseAuthParams {
+    type: "repay";
+    /** Position/loan identifier */
+    positionId: string;
+    /** Amount of UCD to repay (in wei, 18 decimals) */
+    amount: UCD;
+    /** Whether this is a full repayment closing the position */
+    closeLoan: boolean;
+}
+/**
+ * Parameters for extending loan term
+ */
+export interface ExtendTermAuthParams extends BaseAuthParams {
+    type: "extend";
+    /** Position/loan identifier */
+    positionId: string;
+    /** New term length in months */
+    newTerm: number;
+    /** Expected extension fee in UCD */
+    extensionFee: UCD;
+}
+/**
+ * Parameters for closing a position
+ */
+export interface ClosePositionAuthParams extends BaseAuthParams {
+    type: "close";
+    /** Position/loan identifier */
+    positionId: string;
+    /** Final debt amount being repaid */
+    finalDebt: UCD;
+}
+/**
+ * Union type of all possible authorization parameters
+ *
+ * This is a discriminated union keyed by the 'type' field.
+ * TypeScript can narrow the type based on the 'type' value.
+ *
+ * @example
+ * ```typescript
+ * function handleAuth(params: AuthorizationParams) {
+ *   switch (params.type) {
+ *     case 'mint':
+ *       // TypeScript knows params has positionId, amount, publicKey
+ *       return handleMint(params.positionId, params.amount);
+ *     case 'withdraw':
+ *       // TypeScript knows params has destinationAddress
+ *       return handleWithdraw(params.destinationAddress, params.amount);
+ *   }
+ * }
+ * ```
+ */
+export type AuthorizationParams = CreateLoanAuthParams | MintUCDAuthParams | WithdrawBTCAuthParams | RepayDebtAuthParams | ExtendTermAuthParams | ClosePositionAuthParams;
+/**
+ * Type guard to check if params are for loan creation
+ */
+export declare function isCreateLoanAuth(params: AuthorizationParams): params is CreateLoanAuthParams;
+/**
+ * Type guard to check if params are for UCD minting
+ */
+export declare function isMintUCDAuth(params: AuthorizationParams): params is MintUCDAuthParams;
+/**
+ * Type guard to check if params are for BTC withdrawal
+ */
+export declare function isWithdrawBTCAuth(params: AuthorizationParams): params is WithdrawBTCAuthParams;
+/**
+ * Type guard to check if params are for debt repayment
+ */
+export declare function isRepayDebtAuth(params: AuthorizationParams): params is RepayDebtAuthParams;
+/**
+ * Type guard to check if params are for term extension
+ */
+export declare function isExtendTermAuth(params: AuthorizationParams): params is ExtendTermAuthParams;
+/**
+ * Type guard to check if params are for position closure
+ */
+export declare function isClosePositionAuth(params: AuthorizationParams): params is ClosePositionAuthParams;
+/**
+ * Helper to extract the action type from authorization params
+ */
+export declare function getAuthActionType(params: AuthorizationParams): string;
+/**
+ * Validation helpers for authorization parameters
+ */
+export declare namespace AuthParamsValidation {
+    function validateCreateLoan(params: CreateLoanAuthParams): string[];
+    function validateMintUCD(params: MintUCDAuthParams): string[];
+    function validateWithdrawBTC(params: WithdrawBTCAuthParams): string[];
+    function validateRepayDebt(params: RepayDebtAuthParams): string[];
+    function validateExtendTerm(params: ExtendTermAuthParams): string[];
+    function validateClosePosition(params: ClosePositionAuthParams): string[];
+    /**
+     * Validates authorization params based on their type
+     */
+    function validate(params: AuthorizationParams): string[];
+}
+export {};