TypeScript Types

Complete type definitions for SDK interfaces, parameters, and return values.

Configuration Types

Source: packages/sdk/src/config/types.ts


interface CreateConfigOptions {
  env: Env;
  providers?: ProviderGetters;
  modules?: readonly AnyModule[];
  partner?: PartnerConfig;
}
 
interface PartnerConfig {
  partnerId: string;
}
 
interface ProviderGetters {
  evm?: ProviderGetter<EvmProvider>;
  bitcoin?: ProviderGetter<BtcProvider>;
  solana?: ProviderGetter<SolanaProvider>;
  sui?: ProviderGetter<SuiProvider>;
  starknet?: ProviderGetter<StarknetProvider>;
}
 
type ProviderGetter<TProvider> = (chain?: Chain) => TProvider | Promise<TProvider>;

Environment

Source: packages/sdk-common/src/env.ts


const Env = {
  prod: 'prod',
  testnet: 'testnet',
  stage: 'stage',
  dev: 'dev',
  ibc: 'ibc',
} as const;
 
type Env = (typeof Env)[keyof typeof Env];

Status Types

Source: packages/sdk/src/shared/constants/statusConstants.ts

BtcActionStatus


const BtcActionStatus = {
  IDLE: 'idle',
  NEEDS_FEE_AUTHORIZATION: 'needs_fee_authorization',
  NEEDS_ADDRESS_CONFIRMATION: 'needs_address_confirmation',
  NEEDS_DEPLOY_AUTHORIZATION: 'needs_deploy_authorization',
  READY: 'ready',
  ADDRESS_READY: 'address_ready',
  AWAITING_DEPOSIT: 'awaiting_deposit',
} as const;

EvmOperationStatus


const EvmOperationStatus = {
  IDLE: 'idle',
  NEEDS_APPROVAL: 'needs-approval',
  READY: 'ready',
  CONFIRMING: 'confirming',
  COMPLETED: 'completed',
} as const;

NonEvmUnstakeStatus


const NonEvmUnstakeStatus = {
  IDLE: 'idle',
  READY: 'ready',
  CONFIRMING: 'confirming',
  COMPLETED: 'completed',
} as const;

Error Types

Source: packages/sdk/src/shared/errors.ts

LombardError


class LombardError extends Error {
  readonly code: AnyErrorCode;
  readonly metadata?: Record<string, unknown>;
 
  constructor(
    code: AnyErrorCode,
    message: string,
    metadata?: Record<string, unknown>
  );
 
  toJSON(): Record<string, unknown>;
}

Error Code Enums


enum ErrorCode {
  UNKNOWN_ERROR = 'unknown-error',
  INVALID_CONFIGURATION = 'invalid-configuration',
  OPERATION_TIMEOUT = 'operation-timeout',
  OPERATION_CANCELLED = 'operation-cancelled',
}
 
enum ProviderErrorCode {
  PROVIDER_MISSING = 'provider-missing',
  PROVIDER_INITIALIZATION_FAILED = 'provider-initialization-failed',
  PROVIDER_CALL_FAILED = 'provider-call-failed',
  SIGNER_MISSING = 'signer-missing',
  USER_REJECTED = 'user-rejected',
  NETWORK_MISMATCH = 'network-mismatch',
}
 
enum ValidationErrorCode {
  INVALID_ADDRESS = 'invalid-address',
  INVALID_AMOUNT = 'invalid-amount',
  AMOUNT_TOO_SMALL = 'amount-too-small',
  AMOUNT_TOO_LARGE = 'amount-too-large',
  INSUFFICIENT_BALANCE = 'insufficient-balance',
  INVALID_PARAMETER = 'invalid-parameter',
  MISSING_REQUIRED_PARAMETER = 'missing-required-parameter',
  INVALID_CHAIN = 'invalid-chain',
  INVALID_STATE = 'invalid-state',
  INVALID_ASSET = 'invalid-asset',
}
 
enum ContractErrorCode {
  CONTRACT_CALL_FAILED = 'contract-call-failed',
  TRANSACTION_FAILED = 'transaction-failed',
  TRANSACTION_REVERTED = 'transaction-reverted',
  APPROVAL_FAILED = 'approval-failed',
  INSUFFICIENT_ALLOWANCE = 'insufficient-allowance',
  GAS_ESTIMATION_FAILED = 'gas-estimation-failed',
}
 
enum RegistryErrorCode {
  ROUTE_NOT_FOUND = 'route-not-found',
  INVALID_ROUTE_DEFINITION = 'invalid-route-definition',
  UNSUPPORTED_CHAIN = 'unsupported-chain',
  UNSUPPORTED_ASSET = 'unsupported-asset',
  INCOMPATIBLE_ROUTE = 'incompatible-route',
  ENVIRONMENT_MISMATCH = 'environment-mismatch',
}

Action Types

BTC Stake

Source: packages/sdk/src/chains/btc/actions/stake/types.ts


interface BtcStakeParams {
  assetOut: AssetId;
  destChain: Chain;
  sourceChain?: typeof Chain.BITCOIN_MAINNET | typeof Chain.BITCOIN_SIGNET;
}
 
interface BtcStkePrepareParams {
  amount: string;
  recipient: string;
  referralCode?: string;
}

EVM Unstake

Source: packages/sdk/src/chains/evm/actions/unstake/types.ts


interface EvmUnstakeParams {
  assetIn: AssetId;
  assetOut: AssetId;
  sourceChain: Chain;
  destChain: Chain;
}
 
interface EvmUnstakePrepareParams {
  amount: string;
  recipient: string;
}

Progress Types

Source: packages/sdk/src/core/types.ts


interface StrategyProgress<TStatus extends string> {
  status: TStatus;
  steps: Record<string, StepStatus>;
  confirmations?: number;
  requiredConfirmations?: number;
  metadata?: Record<string, unknown>;
}
 
const StepStatus = {
  IDLE: 'idle',
  PENDING: 'pending',
  COMPLETE: 'complete',
  FAILED: 'failed',
} as const;