Type Definitions

We have released v1.0.0 of Elements with an improved UX and developer API. We recommend you to use v1.x. Here's the migration guide for v0.x users.

SwapProps

type SwapsProps = {
  className?: string
  title?: string
  showPoweredByBanner?: boolean
  defaultValues?: Partial<SwapsValues>
  defaultSettings?: Partial<SwapsSettings>
  txnLifecycleHooks?: Partial<TxnLifecycleHooks<SwapsCompletionSummary>>
  allowedSourceChains?: AllowedSourceChainConfig[]
  allowedDestinationChains?: AllowedDestinationChainConfig[]
  onValuesChange?: (values: SwapsValues) => void
  onSettingsChange?: (settings: SwapsSettings) => void
}

SwapModalProps

type SwapsModalProps = SwapsProps & {
  isOpen: boolean
  setIsOpen: (v: boolean) => void
}

IBCSwapsProps

type IBCSwapsProps = {
  className?: string
  title?: string
  showPoweredByBanner?: boolean
  defaultValues?: DefaultIBCSwapValuesType
  defaultSettings?: Partial<IBCSwapsSettings>
  txnLifecycleHooks?: Partial<TxnLifecycleHooks<IBCSwapsCompletionSummary>>
  allowedSourceChains?: AllowedSourceChainConfig[]
  allowedDestinationChains?: AllowedDestinationChainConfig[]
  onValuesChange?: (values: IBCSwapsValues) => void
  onSettingsChange?: (settings: IBCSwapsSettings) => void
}

IBCSwapsModalProps

type IBCSwapsModalProps = IBCSwapsProps & {
    isOpen: boolean
    setIsOpen: (v: boolean) => void
  }

Account

interface Account {
  pubKey: Uint8Array
  bech32Address: string
  isNanoLedger: boolean
}

Tabs

enum Tabs {
  SWAP = 'swap',
  CROSS_CHAIN_SWAPS = 'cross-chain-swaps',
  FIAT_ON_RAMP = 'fiat-on-ramp',
  TRANSFER = 'transfer',
  BRIDGE_USDC = 'bridge-usdc'
}

ChainBaseData

interface ChainBaseData {
    chainName: string;
    icon: string;
    rpcUrl: string;
    chainId: string | number;
    chainType: 'cosmos' | 'evm';
}

CosmosChainData

 interface CosmosChainData extends ChainBaseData {
    chainId: string;
    restUrl: string;
    addressPrefix: string;
    baseDenom: string;
    chainType: 'cosmos';
    coinType: string;
    chainRegistryPath: string;
    txExplorer: {
        mainnet: {
            name: string;
            txUrl: string;
        };
        testnet?: {
            name: string;
            txUrl: string;
        };
    };
}

EVMChainData

interface EVMChainData extends ChainBaseData {
    chainId: number;
    chainType: 'evm';
}

ChainData

type ChainData = CosmosChainData | EVMChainData;

Asset

type Asset = {
    denom: string;
    symbol: string;
    logoUri: string;
    originDenom: string;
    decimals: number;
    denomTracePath?: string;
};

Currency

type Currency = {
    name: string;
    symbol: string;
    countryCode: string;
    priority: number;
};

TXN_STATUS

enum TXN_STATUS {
    INIT = "INIT",
    PENDING = "PENDING",
    SUCCESS = "SUCCESS",
    FAILED = "FAILED",
    SIGNED = "SIGNED"
}

TxnStatus

type TxnStatus = {
  status: TXN_STATUS
  responses: ActionResponse[]
  isComplete: boolean
}[]

ActionResponse

type ActionResponse = {
  status: TRANSFER_STATE
  data: any
}

TRANSFER_STATE

enum TRANSFER_STATE {
    TRANSFER_UNKNOWN = "TRANSFER_UNKNOWN",
    TRANSFER_PENDING = "TRANSFER_PENDING",
    TRANSFER_RECEIVED = "TRANSFER_RECEIVED",
    TRANSFER_SUCCESS = "TRANSFER_SUCCESS",
    TRANSFER_FAILURE = "TRANSFER_FAILURE"
}

OrderStatusResponse

type OrderStatusResponse = {
  transferStatus: TRANSFER_STATUS;
  humanStatusField: string;
  paymentStatus: string;
  allPossibleTxHashes: {
    originalTxHashFromProvider: {
      txHash: string;
      txLink: string;
    };
  };
  txHash: string;
};

TRANSFER_REQUEST

 enum TRANSFER_STATUS {
    UNINITIATED = "uninitiated",
    PENDING = "pending",
    FAILED = "failed",
    SETTLED = "settled",
    UNKNOWN = "unknown"
}

Prettify

This is a custom utility helper type. Read more about it here.

IBCSwapTxnInfo

type IBCSwapTxnInfo = {
  type: 'ibc-swap-data'
  fromChain: CosmosChainData
  toChain: CosmosChainData
  fromToken: Asset | string
  toToken: Asset | string
  hops: number
}

Signer

interface SignDirectResponse {
  signature: Uint8Array;
  signed: SignDoc;
}

interface SignAminoResponse {
  readonly signed: StdSignDoc;
  readonly signature: Uint8Array;
}

interface Signer {
  signDirect: (address: string, signDoc: SignDoc) => Promise<SignDirectResponse | TxRaw>
  signAmino: (address: string, signDoc: StdSignDoc) => Promise<SignAminoResponse>
}

You can find definitions for SignDoc and StdSignDoc in cosmjs-types package.

TxnSignBaseArgs

type TxnSignBaseArgs =
  | {
      chainType: 'cosmos'
      chainId: string
      chainName: string
      signMode: 'amino' | 'direct'
      transactionTypes: MsgTypeUrl[]
      messages: MessageWithInfo[]
    }
  | {
      chainType: 'evm'
      chainId: number
      chainName: string
    }

onTxnSignInit

type TxnSignInitArgs = TxnSignBaseArgs

type OnTxnSignInit = (txn: TxnSignInitArgs) => void

onTxnSignApproved

type BroadcastedTxInfo =
  | {
      chainType: 'evm'
      txHash: `0x${string}`
    }
  | {
      chainType: 'cosmos'
      txHash: string
      fees: readonly Coin[]
      data?: IBCSwapTxnInfo
    }

type TxnSignApprovedArgs = Prettify<TxnSignBaseArgs & BroadcastedTxInfo>

onTxnSignFailed

type TxnSignInitArgs = TxnSignBaseArgs

type OnTxnSignFailed = (txn: TxnSignFailedArgs, err: Error) => void

onTxnInProgress

// the return value of this callback is a function which is 
// called when the said transaction is completed
type OnTxnInProgress = (tab: Tabs) => () => void