@idos-network/kwil-infra 1.1.0

package/dist/xrp/utils.d.mts

@@ -0,0 +1,1165 @@
+/// <reference types="node" />
+import { AccountSetAsfFlags, AccountSetFlagsInterface, NFTokenCreateOfferFlagsInterface, NFTokenMintFlagsInterface, OfferCreateFlagsInterface, Path, PaymentFlagsInterface, SubmittableTransaction, TrustSetFlagsInterface } from "xrpl";
+import { Amount, Amount as Amount$1, IssuedCurrencyAmount } from "xrpl/dist/npm/models/common/index.js";
+import { w3cwebsocket } from "websocket";
+import { EventEmitter } from "events";
+
+//#region \0rolldown/runtime.js
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/_constants/network/network.constant.d.ts
+declare enum XRPLNetwork {
+  MAINNET = "Mainnet",
+  TESTNET = "Testnet",
+  DEVNET = "Devnet",
+  CUSTOM = "Custom"
+}
+declare enum XahauNetwork {
+  XAHAU_MAINNET = "Mainnet",
+  XAHAU_TESTNET = "Testnet",
+  CUSTOM = "Custom"
+}
+type Network = XRPLNetwork | XahauNetwork;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/_constants/xrpl/hooks.types.d.ts
+interface Hook {
+  Hook: {
+    CreateCode: string;
+    Flags: number;
+    HookApiVersion: number;
+    HookOn: string;
+    HookNamespace: string;
+    HookParameters?: HookParameter[];
+    HookGrants?: HookGrant[];
+  };
+}
+interface HookParameter {
+  HookParameter: {
+    HookParameterName: string;
+    HookParameterValue: string;
+  };
+}
+interface HookGrant {
+  HookGrant: {
+    HookHash: string;
+    Authorize?: string;
+  };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/_constants/xrpl/basic.types.d.ts
+interface Memo {
+  memo: {
+    memoType?: string;
+    memoData?: string;
+    memoFormat?: string;
+  };
+}
+interface Signer {
+  signer: {
+    account: string;
+    txnSignature: string;
+    signingPubKey: string;
+  };
+}
+type TrustSetFlags = TrustSetFlagsInterface | number;
+type PaymentFlags = PaymentFlagsInterface | number;
+type MintNFTFlags = NFTokenMintFlagsInterface | number;
+type CreateNFTOfferFlags = NFTokenCreateOfferFlagsInterface | number;
+type SetAccountFlags = AccountSetFlagsInterface | number;
+type CreateOfferFlags = OfferCreateFlagsInterface | number;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/_constants/xrpl/nft.types.d.ts
+interface AccountNFToken {
+  Flags: number;
+  Issuer: string;
+  NFTokenID: string;
+  NFTokenTaxon: number;
+  URI?: string;
+  nft_serial: number;
+}
+interface AccountNFTokenResponse {
+  account_nfts: AccountNFToken[];
+  marker?: unknown;
+}
+interface NFTokenIDResponse {
+  hash: string;
+  NFTokenID: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/_constants/payload/payload.types.d.ts
+interface GetNetworkRequest {
+  id: number | undefined;
+}
+interface BaseTransactionRequest {
+  fee?: string;
+  sequence?: number;
+  accountTxnID?: string;
+  lastLedgerSequence?: number;
+  memos?: Memo[];
+  networkID?: number;
+  signers?: Signer[];
+  sourceTag?: number;
+  signingPubKey?: string;
+  ticketSequence?: number;
+  txnSignature?: string;
+}
+interface SendPaymentRequest extends BaseTransactionRequest {
+  amount: Amount;
+  destination: string;
+  destinationTag?: number;
+  invoiceID?: string;
+  paths?: Path[];
+  sendMax?: Amount;
+  deliverMin?: Amount;
+  flags?: PaymentFlags;
+}
+interface SetTrustlineRequest extends BaseTransactionRequest {
+  limitAmount: IssuedCurrencyAmount;
+  qualityIn?: number;
+  qualityOut?: number;
+  flags?: TrustSetFlags;
+}
+interface MintNFTRequest extends BaseTransactionRequest {
+  flags?: MintNFTFlags;
+  issuer?: string;
+  NFTokenTaxon: number;
+  transferFee?: number;
+  URI?: string;
+}
+interface CreateNFTOfferRequest extends BaseTransactionRequest {
+  NFTokenID: string;
+  amount: Amount;
+  owner?: string;
+  expiration?: number;
+  destination?: string;
+  flags?: CreateNFTOfferFlags;
+}
+interface CancelNFTOfferRequest extends BaseTransactionRequest {
+  NFTokenOffers: string[];
+}
+interface AcceptNFTOfferRequest extends BaseTransactionRequest {
+  NFTokenSellOffer?: string;
+  NFTokenBuyOffer?: string;
+  NFTokenBrokerFee?: Amount;
+}
+interface BurnNFTRequest extends BaseTransactionRequest {
+  NFTokenID: string;
+  owner?: string;
+}
+interface GetNFTRequest {
+  limit?: number;
+  marker?: unknown;
+}
+interface SignMessageRequest {
+  url: string;
+  title: string;
+  favicon: string | null | undefined;
+  message: string;
+  isHex?: boolean;
+}
+interface SetAccountRequest extends BaseTransactionRequest {
+  flags?: SetAccountFlags;
+  clearFlag?: number;
+  domain?: string;
+  emailHash?: string;
+  messageKey?: string;
+  NFTokenMinter?: string;
+  setFlag?: AccountSetAsfFlags;
+  transferRate?: number;
+  tickSize?: number;
+}
+interface SetRegularKeyRequest extends BaseTransactionRequest {
+  regularKey?: string;
+}
+interface CreateOfferRequest extends BaseTransactionRequest {
+  flags?: CreateOfferFlags;
+  expiration?: number;
+  offerSequence?: number;
+  takerGets: Amount;
+  takerPays: Amount;
+}
+interface CancelOfferRequest extends BaseTransactionRequest {
+  offerSequence: number;
+}
+interface SubmitTransactionRequest {
+  transaction: SubmittableTransaction;
+}
+interface SignTransactionRequest {
+  transaction: SubmittableTransaction;
+}
+type TransactionWithID = SubmittableTransaction & {
+  ID?: string;
+};
+type TransactionErrorHandling = 'abort' | 'continue';
+interface BaseBulkTransactionsRequest {
+  waitForHashes?: boolean;
+  onError?: TransactionErrorHandling;
+}
+interface SubmitBulkTransactionsRequest extends BaseBulkTransactionsRequest {
+  transactions: TransactionWithID[];
+}
+interface SetHookRequest extends BaseTransactionRequest {
+  hooks: Hook[];
+}
+declare const enum ResponseType {
+  Response = "response",
+  Reject = "reject"
+}
+interface BaseResponse<T> {
+  type: ResponseType;
+  result?: T;
+}
+interface GetNetworkResponse extends BaseResponse<{
+  chain: string;
+  network: Network;
+  websocket: string;
+}> {}
+interface GetAddressResponse extends BaseResponse<{
+  address: string;
+}> {}
+interface GetPublicKeyResponse extends BaseResponse<{
+  address: string;
+  publicKey: string;
+}> {}
+interface SignMessageResponse extends BaseResponse<{
+  signedMessage: string;
+}> {}
+interface SubmitTransactionResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface SignTransactionResponse extends BaseResponse<{
+  signature: string | null | undefined;
+}> {}
+type TransactionBulkResponse = {
+  id?: string;
+  accepted?: boolean;
+  hash?: string;
+  error?: string;
+};
+interface SubmitBulkTransactionsResponse extends BaseResponse<{
+  transactions: TransactionBulkResponse[];
+}> {}
+interface IsInstalledResponse {
+  result: {
+    isInstalled: boolean;
+  };
+}
+interface SendPaymentResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface SetTrustlineResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface GetNFTResponse extends BaseResponse<AccountNFTokenResponse> {}
+interface MintNFTResponse extends BaseResponse<NFTokenIDResponse> {}
+interface CreateNFTOfferResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface CancelNFTOfferResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface AcceptNFTOfferResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface BurnNFTResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface SetAccountResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface SetRegularKeyResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface CreateOfferResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface CancelOfferResponse extends BaseResponse<{
+  hash: string;
+}> {}
+interface SetHookResponse extends BaseResponse<{
+  hash: string;
+}> {}
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/acceptNFTOffer/acceptNFTOffer.d.ts
+declare const acceptNFTOffer: (payload: AcceptNFTOfferRequest) => Promise<AcceptNFTOfferResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/burnNFT/burnNFT.d.ts
+declare const burnNFT: (payload: BurnNFTRequest) => Promise<BurnNFTResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/cancelNFTOffer/cancelNFTOffer.d.ts
+declare const cancelNFTOffer: (payload: CancelNFTOfferRequest) => Promise<CancelNFTOfferResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/cancelOffer/cancelOffer.d.ts
+declare const cancelOffer: (payload: CancelOfferRequest) => Promise<CancelOfferResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/createNFTOffer/createNFTOffer.d.ts
+declare const createNFTOffer: (payload: CreateNFTOfferRequest) => Promise<CreateNFTOfferResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/createOffer/createOffer.d.ts
+declare const createOffer: (payload: CreateOfferRequest) => Promise<CreateOfferResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/on/on.d.ts
+declare const on: (eventType: string, callback: (payload: any) => void) => void;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/getAddress/getAddress.d.ts
+declare const getAddress: () => Promise<GetAddressResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/getNetwork/getNetwork.d.ts
+declare const getNetwork: () => Promise<GetNetworkResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/getNFT/getNFT.d.ts
+declare const getNFT: (payload?: GetNFTRequest) => Promise<GetNFTResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/getPublicKey/getPublicKey.d.ts
+declare const getPublicKey: () => Promise<GetPublicKeyResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/isInstalled/isInstalled.d.ts
+declare const isInstalled: () => Promise<IsInstalledResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/mintNFT/mintNFT.d.ts
+declare const mintNFT: (payload: MintNFTRequest) => Promise<MintNFTResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/sendPayment/sendPayment.d.ts
+declare const sendPayment: (paymentPayload: SendPaymentRequest) => Promise<SendPaymentResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/setAccount/setAccount.d.ts
+declare const setAccount: (payload: SetAccountRequest) => Promise<SetAccountResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/setHook/setHook.d.ts
+declare const setHook: (payload: SetHookRequest) => Promise<SetHookResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/setRegularKey/setRegularKey.d.ts
+declare const setRegularKey: (payload: SetRegularKeyRequest) => Promise<SetRegularKeyResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/setTrustline/setTrustline.d.ts
+declare const setTrustline: (payload: SetTrustlineRequest) => Promise<SetTrustlineResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/signMessage/signMessage.d.ts
+declare const signMessage: (message: string, isHex?: boolean) => Promise<SignMessageResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/signTransaction/signTransaction.d.ts
+declare const signTransaction: (payload: SignTransactionRequest) => Promise<SignTransactionResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/submitTransaction/submitTransaction.d.ts
+declare const submitTransaction: (payload: SubmitTransactionRequest) => Promise<SubmitTransactionResponse>;
+//#endregion
+//#region ../../node_modules/.pnpm/@gemwallet+api@3.8.0/node_modules/@gemwallet/api/submitBulkTransactions/submitBulkTransactions.d.ts
+declare const submitBulkTransactions: (payload: SubmitBulkTransactionsRequest) => Promise<SubmitBulkTransactionsResponse>;
+declare namespace index_d_exports {
+  export { AcceptNFTOfferRequest, AcceptNFTOfferResponse, AccountNFToken, Amount$1 as Amount, BurnNFTRequest, BurnNFTResponse, CancelNFTOfferRequest, CancelNFTOfferResponse, CancelOfferRequest, CancelOfferResponse, CreateNFTOfferRequest, CreateNFTOfferResponse, CreateOfferRequest, CreateOfferResponse, GetAddressResponse, GetNFTRequest, GetNFTResponse, GetNetworkRequest, GetNetworkResponse, GetPublicKeyResponse, Hook, HookGrant, HookParameter, IsInstalledResponse, Memo, MintNFTRequest, MintNFTResponse, Network, PaymentFlags, SendPaymentRequest, SendPaymentResponse, SetAccountRequest, SetAccountResponse, SetHookRequest, SetHookResponse, SetRegularKeyRequest, SetRegularKeyResponse, SetTrustlineRequest, SetTrustlineResponse, SignMessageRequest, SignMessageResponse, SignTransactionRequest, SignTransactionResponse, SubmitBulkTransactionsRequest, SubmitBulkTransactionsResponse, SubmitTransactionRequest, SubmitTransactionResponse, TransactionBulkResponse, TrustSetFlags, acceptNFTOffer, burnNFT, cancelNFTOffer, cancelOffer, createNFTOffer, createOffer, getAddress, getNFT, getNetwork, getPublicKey, isInstalled, mintNFT, on, sendPayment, setAccount, setHook, setRegularKey, setTrustline, signMessage, signTransaction, submitBulkTransactions, submitTransaction };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/xumm-api/index.d.ts
+declare const XummTxTypes: readonly ["SignIn", "PaymentChannelAuthorize"];
+declare const XrplTxTypes: readonly ["AccountDelete", "AccountSet", "CheckCancel", "CheckCash", "CheckCreate", "ClaimReward", "DepositPreauth", "EscrowCancel", "EscrowCreate", "EscrowFinish", "Import", "Invoke", "NFTokenAcceptOffer", "NFTokenBurn", "NFTokenCancelOffer", "NFTokenCreateOffer", "NFTokenMint", "OfferCancel", "OfferCreate", "Payment", "PaymentChannelClaim", "PaymentChannelCreate", "PaymentChannelFund", "Remit", "SetHook", "SetRegularKey", "SignerListSet", "TicketCreate", "TrustSet", "URITokenBurn", "URITokenBuy", "URITokenCancelSellOffer", "URITokenCreateSellOffer", "URITokenMint"];
+declare type XummTransactionType = typeof XummTxTypes[number];
+declare type XrplTransactionType = typeof XrplTxTypes[number];
+declare type XummCancelReason = 'OK' | 'ALREADY_CANCELLED' | 'ALREADY_RESOLVED' | 'ALREADY_OPENED' | 'ALREADY_EXPIRED';
+declare type XummTransactionApprovalType = 'PIN' | 'BIOMETRIC' | 'PASSPHRASE' | 'OTHER';
+declare type XummQrQuality = 'm' | 'q' | 'h';
+interface XummJsonTransaction extends Record<string, unknown> {
+  TransactionType: XummTransactionType | XrplTransactionType;
+}
+interface XummCustomMeta {
+  identifier?: string | null;
+  blob?: Record<string, unknown> | null;
+  instruction?: string | null;
+}
+interface XummPayloadMeta {
+  exists: boolean;
+  uuid: string;
+  multisign: boolean;
+  submit: boolean;
+  pathfinding: boolean;
+  pathfinding_fallback: boolean;
+  force_network?: string;
+  destination: string;
+  resolved_destination: string;
+  resolved: boolean;
+  signed: boolean;
+  cancelled: boolean;
+  expired: boolean;
+  pushed: boolean;
+  app_opened: boolean;
+  opened_by_deeplink: boolean | null;
+  immutable?: boolean;
+  forceAccount?: boolean;
+  return_url_app: string | null;
+  return_url_web: string | null;
+  is_xapp: boolean;
+  signers: string[] | null;
+}
+interface XummPayloadBodyBase {
+  options?: {
+    submit?: boolean;
+    pathfinding?: boolean;
+    pathfinding_fallback?: boolean;
+    multisign?: boolean;
+    expire?: number;
+    signers?: string[];
+    force_network?: string;
+    return_url?: {
+      app?: string;
+      web?: string;
+    };
+  };
+  custom_meta?: XummCustomMeta;
+  user_token?: string;
+}
+interface XummPostPayloadBodyJson extends XummPayloadBodyBase {
+  txjson: XummJsonTransaction;
+}
+interface XummPostPayloadBodyBlob extends XummPayloadBodyBase {
+  txblob: string;
+}
+declare type CreatePayload = XummPostPayloadBodyJson | XummPostPayloadBodyBlob;
+interface XummPostPayloadResponse {
+  uuid: string;
+  next: {
+    always: string;
+    no_push_msg_received?: string;
+  };
+  refs: {
+    qr_png: string;
+    qr_matrix: string;
+    qr_uri_quality_opts: XummQrQuality[];
+    websocket_status: string;
+  };
+  pushed: boolean;
+}
+interface XummGetPayloadResponse {
+  meta: XummPayloadMeta;
+  application: {
+    name: string;
+    description: string;
+    disabled: 0 | 1;
+    uuidv4: string;
+    icon_url: string;
+    issued_user_token: string | null;
+  };
+  payload: {
+    tx_type: XummTransactionType | XrplTransactionType;
+    tx_destination: string;
+    tx_destination_tag: number | null;
+    request_json: XummJsonTransaction;
+    origintype: string | null;
+    signmethod: string | null;
+    created_at: string;
+    expires_at: string;
+    expires_in_seconds: number;
+    computed?: Record<string, unknown>;
+  };
+  response: {
+    signer_pubkey?: string;
+    hex: string | null;
+    txid: string | null;
+    resolved_at: string | null;
+    dispatched_nodetype: string | null;
+    dispatched_to: string | null;
+    dispatched_result: string | null;
+    dispatched_to_node: boolean | null;
+    environment_nodeuri: string | null;
+    environment_nodetype: string | null;
+    environment_networkid: number | null;
+    multisign_account: string | null;
+    account: string | null;
+    signer: string | null;
+    approved_with?: XummTransactionApprovalType;
+    user: string | null;
+  };
+  custom_meta: XummCustomMeta;
+}
+interface XummDeletePayloadResponse {
+  result: {
+    cancelled: boolean;
+    reason: XummCancelReason;
+  };
+  meta: XummPayloadMeta;
+  custom_meta: XummCustomMeta;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/AnyJson.d.ts
+declare type AnyJson$1 = Record<string, any>;
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/ApplicationDetails.d.ts
+interface ApplicationDetails {
+  quota?: Record<string, unknown>;
+  application: {
+    uuidv4: string;
+    name: string;
+    webhookurl?: string;
+    disabled?: number;
+  };
+  call?: {
+    uuidv4: string;
+  };
+  jwtData?: xAppJwtPong | JwtPong;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/CuratedAssetsResponse.d.ts
+interface CuratedAssetsResponse {
+  issuers: string[];
+  currencies: string[];
+  details: {
+    [issuer: string]: {
+      id: number;
+      name: string;
+      domain?: string;
+      avatar?: string;
+      shortlist: number;
+      currencies: {
+        [currencyCode: string]: {
+          id: number;
+          issuer_id: number;
+          currency: string;
+          name: string;
+          avatar?: string;
+          shortlist: number;
+        };
+      };
+    };
+  };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/KycStatusResponse.d.ts
+interface PossibleKycStatuses {
+  NONE: string;
+  IN_PROGRESS: string;
+  REJECTED: string;
+  SUCCESSFUL: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/XrplTransaction.d.ts
+interface XrplTransaction {
+  txid: string;
+  balanceChanges: {
+    [account: string]: {
+      counterparty: string;
+      currency: string;
+      value: string;
+    }[];
+  };
+  node: string;
+  transaction: AnyJson$1;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/NftokenDetail.d.ts
+interface NftokenDetail {
+  issuer?: string;
+  token?: string;
+  owner?: string;
+  name?: string;
+  image?: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/RatesResponse.d.ts
+interface RatesResponse {
+  USD: number;
+  XRP: number;
+  __meta: {
+    currency: {
+      en: string;
+      code: string;
+      symbol?: string;
+    };
+  };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/UserTokens.d.ts
+interface UserTokenValidity {
+  'user_token': string;
+  active: boolean;
+  issued?: number;
+  expires?: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/JwtPong.d.ts
+interface JwtPong {
+  pong: boolean;
+  'client_id': string;
+  state?: string;
+  scope?: string;
+  nonce?: string;
+  aud: string;
+  sub: string;
+  'app_uuidv4': string;
+  'app_name': string;
+  'payload_uuidv4': string;
+  'usertoken_uuidv4': string;
+  iat: number;
+  exp: number;
+  iss: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/HookHash.d.ts
+interface HookHash {
+  name: string;
+  description: string;
+  creator?: {
+    name?: string;
+    mail?: string;
+    site?: string;
+  };
+  xapp?: string;
+  appuuid?: string;
+  icon?: string;
+  verifiedAccounts?: string[];
+  audits?: string[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/HookHashes.d.ts
+interface HookHashes {
+  [hash: string]: HookHash;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Meta/Rails.d.ts
+interface Endpoint {
+  name: string;
+  url: string;
+}
+interface Explorer {
+  name: string;
+  'url_tx': string;
+  'url_account'?: string;
+  'url_ctid'?: string;
+}
+interface Rails {
+  [networkKey: string]: {
+    chain_id: number;
+    color: string;
+    name: string;
+    is_livenet: boolean;
+    native_asset: string;
+    endpoints: Endpoint[];
+    explorers: Explorer[];
+    rpc?: string;
+    definitions?: string;
+    icons: {
+      icon_square: string;
+      icon_asset: string;
+    };
+  };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Payload/SubscriptionCallbackParams.d.ts
+interface SubscriptionCallbackParams {
+  uuid: string;
+  data: AnyJson$1;
+  resolve: (resolveData?: unknown) => void;
+  payload: XummGetPayloadResponse;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Payload/onPayloadEvent.d.ts
+declare type onPayloadEvent = (subscriptionCallback: SubscriptionCallbackParams) => unknown | Promise<unknown> | void;
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Payload/PayloadAndSubscription.d.ts
+interface PayloadAndSubscription extends PayloadSubscription {
+  created: XummPostPayloadResponse;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Payload/PayloadSubscription.d.ts
+interface PayloadSubscription {
+  payload: XummGetPayloadResponse;
+  resolved: Promise<unknown> | undefined;
+  resolve: (resolveData?: unknown) => void;
+  websocket: w3cwebsocket;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Push/EventResponse.d.ts
+interface EventResponse {
+  pushed: boolean;
+  uuid: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Push/PushResponse.d.ts
+interface PushResponse {
+  pushed: boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/Push/EventPushPostBody.d.ts
+interface EventPushPostBody extends AnyJson$1 {
+  'user_token'?: string;
+  'user_uuid'?: string;
+  'user_account'?: string;
+  subtitle?: string;
+  body?: string;
+  data?: AnyJson$1;
+  silent?: boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/xApp/xAppOttData.d.ts
+interface xAppUserDeviceData extends AnyJson$1 {
+  currency: string;
+  platform: string;
+}
+interface xAppOriginData extends AnyJson$1 {
+  payload?: string;
+}
+interface xAppOrigin extends AnyJson$1 {
+  type?: string;
+  data?: xAppOriginData;
+}
+interface xAppAccountInfo extends AnyJson$1 {
+  account: string;
+  name?: string;
+  domain?: string;
+  blocked: boolean;
+  source: string;
+  kycApproved: boolean;
+  proSubscription: boolean;
+  profile?: {
+    slug: string | null;
+    profileUrl: string | null;
+    accountSlug: string | null;
+    payString: string | null;
+  };
+}
+interface xAppOttData extends AnyJson$1 {
+  locale?: string;
+  version?: string;
+  account?: string;
+  accountaccess?: string;
+  accounttype?: string;
+  style?: string;
+  origin?: xAppOrigin;
+  user: string;
+  user_device?: xAppUserDeviceData;
+  account_info: xAppAccountInfo;
+  nodetype?: string;
+  nodewss?: string;
+  networkid?: number;
+  currency?: string;
+  subscriptions?: string[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/xApp/xAppJwtOtt.d.ts
+interface xAppJwtOttApp extends AnyJson$1 {
+  name: string;
+}
+interface xAppJwtOtt {
+  ott: xAppOttData;
+  app: xAppJwtOttApp;
+  jwt: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/types/xApp/xAppJwtPong.d.ts
+interface xAppJwtPong extends AnyJson$1 {
+  pong: boolean;
+  ott_uuidv4: string;
+  app_uuidv4: string;
+  app_name: string;
+  iat: number;
+  exp: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/Meta.d.ts
+declare class Meta {
+  private apiKey;
+  private apiSecret;
+  private isBrowser;
+  private jwtFlow;
+  private jwt?;
+  private injected;
+  private invoker?;
+  private authPromise?;
+  private authPromiseResolve?;
+  endpoint: string;
+  constructor(apiKey: string, apiSecret: string);
+  setEndpoint(endpoint: string): boolean;
+  private authorize;
+  call<T>(endpoint: string, httpMethod?: string, data?: CreatePayload | AnyJson$1): Promise<T> | never;
+  ping(): Promise<ApplicationDetails>;
+  getCuratedAssets(): Promise<CuratedAssetsResponse>;
+  getRates(currencyCode: string): Promise<RatesResponse>;
+  getKycStatus(userTokenOrAccount: string): Promise<keyof PossibleKycStatuses>;
+  getRails(): Promise<Rails>;
+  getHookHash(hookHash: string): Promise<HookHash>;
+  getHookHashes(): Promise<HookHashes>;
+  getTransaction(txHash: string): Promise<XrplTransaction>;
+  getNftokenDetail(tokenId: string): Promise<NftokenDetail> | never;
+  verifyUserTokens(userTokens: string[]): Promise<UserTokenValidity[]>;
+  _inject(Invoker: XummSdk): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/Storage.d.ts
+declare class Storage$1 {
+  private Meta;
+  constructor(MetaObject: Meta);
+  get(): Promise<AnyJson$1 | null>;
+  set(data?: AnyJson$1): Promise<boolean>;
+  delete(): Promise<boolean>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/Payload.d.ts
+declare class Payload {
+  private Meta;
+  constructor(MetaObject: Meta);
+  resolvePayload(payload: string | XummGetPayloadResponse | XummPostPayloadResponse): Promise<XummGetPayloadResponse | null>;
+  create(payload: XummPostPayloadBodyJson | XummPostPayloadBodyBlob | XummJsonTransaction, returnErrors?: boolean): Promise<XummPostPayloadResponse | null>;
+  get(payload: string | XummPostPayloadResponse, returnErrors?: boolean): Promise<XummGetPayloadResponse | null>;
+  subscribe(payload: string | XummGetPayloadResponse | XummPostPayloadResponse, callback?: onPayloadEvent): Promise<PayloadSubscription>;
+  cancel(payload: string | XummGetPayloadResponse | XummPostPayloadResponse, returnErrors?: boolean): Promise<XummDeletePayloadResponse | null>;
+  createAndSubscribe(payload: XummPostPayloadBodyJson | XummPostPayloadBodyBlob | XummJsonTransaction, callback?: onPayloadEvent): Promise<PayloadAndSubscription>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/xApp.d.ts
+declare class xApp$1 {
+  private Meta;
+  private userdata;
+  constructor(MetaObject: Meta);
+  get(ott: string): Promise<xAppOttData | null>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/Push.d.ts
+declare class Push {
+  private Meta;
+  private userdata;
+  constructor(MetaObject: Meta);
+  event(data: EventPushPostBody): Promise<EventResponse>;
+  notification(data: EventPushPostBody): Promise<PushResponse>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/JwtUserdata.d.ts
+declare class JwtUserdata {
+  private Meta;
+  constructor(MetaObject: Meta);
+  list(): Promise<string[]>;
+  get(key: string | string[]): Promise<AnyJson$1>;
+  delete(key: string): Promise<boolean>;
+  set(key: string, data: AnyJson$1): Promise<boolean>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-sdk@1.11.2/node_modules/xumm-sdk/dist/src/index.d.ts
+declare class XummSdk {
+  private Meta;
+  storage: Storage$1;
+  payload: Payload;
+  jwtUserdata: JwtUserdata;
+  Push: Push;
+  xApp: xApp$1;
+  constructor(apiKey?: string, apiSecret?: string);
+  private getEnv;
+  /**
+   * Proxy methods to Meta class below
+   */
+  ping(): Promise<ApplicationDetails>;
+  getCuratedAssets(): Promise<CuratedAssetsResponse>;
+  getRails(): Promise<Rails>;
+  getHookHashes(): Promise<HookHashes>;
+  getHookHash(hookHash: string): Promise<HookHash>;
+  getRates(currencyCode: string): Promise<RatesResponse>;
+  getKycStatus(userTokenOrAccount: string): Promise<"NONE" | "IN_PROGRESS" | "REJECTED" | "SUCCESSFUL">;
+  getTransaction(txHash: string): Promise<XrplTransaction>;
+  getNftokenDetail(tokenId: string): Promise<NftokenDetail>;
+  verifyUserTokens(userTokens: string[]): Promise<UserTokenValidity[]>;
+  verifyUserToken(token: string): Promise<UserTokenValidity | null>;
+  setEndpoint(endpoint: string): boolean;
+  caught(error: Error): void;
+}
+interface XummJwtOptionsStore {
+  get: (ott: string) => xAppJwtOtt | void;
+  set: (ott: string, ottData: xAppJwtOtt) => void;
+}
+interface XummSdkJwtOptions {
+  store?: XummJwtOptionsStore;
+  fatalHandler?: (error: Error) => void;
+  noAutoRetrieve?: boolean;
+}
+declare class XummSdkJwt extends XummSdk {
+  private ottResolved;
+  private jwt?;
+  private resolve;
+  private reject;
+  fatalHandler?: (error: Error) => void;
+  private store;
+  constructor(apiKeyOrJwt: string, ott?: string, options?: XummSdkJwtOptions);
+  _jwtStore(invoker: Meta, persistJwt: (jwt: string) => void): XummJwtOptionsStore;
+  getOttData(): Promise<xAppOttData>;
+  getJwt(): Promise<string | undefined>;
+  caught(error: Error): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-oauth2-pkce@2.8.7/node_modules/xumm-oauth2-pkce/dist/index.d.ts
+interface XummProfile {
+  slug: string;
+  profileUrl: string;
+  accountSlug: string | null;
+  payString: string | null;
+}
+interface ResolvedFlow {
+  sdk: XummSdkJwt;
+  jwt: string;
+  me: {
+    sub: string;
+    picture: string;
+    account: string;
+    name?: string | null;
+    domain?: string | null;
+    blocked: boolean;
+    source: string;
+    kycApproved: boolean;
+    proSubscription: boolean;
+    profile?: XummProfile;
+    networkType?: string;
+    networkId?: number;
+    networkEndpoint?: string;
+    email?: string;
+  };
+}
+interface XummPkceEvent {
+  retrieved: () => void;
+  error: (error: Error) => void;
+  success: () => void;
+  loggedout: () => void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-xapp-sdk@1.7.2/node_modules/xumm-xapp-sdk/dist/types.d.ts
+declare type AnyJson = Record<string, any>;
+interface qrEventData {
+  qrContents?: null;
+  reason: "USER_CLOSE" | "INVALID_QR" | "SCANNED";
+}
+interface payloadEventData {
+  reason: "DECLINED" | "SIGNED";
+  uuid: string;
+}
+interface destinationEventData {
+  destination?: {
+    address: string;
+    tag?: number;
+    name?: string;
+  };
+  info?: {
+    blackHole: boolean;
+    disallowIncomingXRP: false;
+    exist: boolean;
+    possibleExchange: false;
+    requireDestinationTag: boolean;
+    risk: "ERROR" | "UNKNOWS" | "PROBABLE" | "HIGH_PROBABILITY" | "CONFIRMED";
+  };
+  reason: "SELECTED" | "USER_CLOSE";
+}
+interface xAppEvent {
+  qr: (data: qrEventData) => void;
+  payload: (data: payloadEventData) => void;
+  destination: (data: destinationEventData) => void;
+  networkswitch: (data: xAppNetworkSwitch) => void;
+}
+interface xAppActionNavigate extends AnyJson {
+  xApp: string;
+}
+interface xAppActionOpenSignRequest extends AnyJson {
+  uuid: string;
+}
+interface xAppActionOpenBrowser extends AnyJson {
+  url: string;
+}
+interface xAppActionShare {
+  text?: string;
+}
+interface xAppActionClose {
+  refreshEvents?: boolean;
+}
+interface xAppActionTxDetails {
+  tx: string;
+  account: string;
+}
+interface xAppActionSelectDestination {
+  ignoreDestinationTag?: boolean;
+}
+interface xAppNetworkSwitch {
+  network?: string;
+}
+interface xAppEnvironment {
+  version: string;
+  ott: string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm-xapp-sdk@1.7.2/node_modules/xumm-xapp-sdk/dist/index.d.ts
+declare interface xApp {
+  on<U extends keyof xAppEvent>(event: U, listener: xAppEvent[U]): this;
+  off<U extends keyof xAppEvent>(event: U, listener: xAppEvent[U]): this;
+}
+declare class xApp {
+  private xummEnvironment;
+  constructor();
+  getEnvironment(): xAppEnvironment;
+  navigate(navigateOptions: xAppActionNavigate): Promise<boolean | Error> | void;
+  openSignRequest(openSignRequestOptions: xAppActionOpenSignRequest | null | undefined): Promise<boolean | Error> | void;
+  selectDestination(selectDestinationOptions?: xAppActionSelectDestination): Promise<boolean | Error> | void;
+  openBrowser(openBrowserOptions: xAppActionOpenBrowser): Promise<boolean | Error> | void;
+  share(shareOptions: xAppActionShare): Promise<boolean | Error> | void;
+  scanQr(): Promise<boolean | Error> | void;
+  tx(txOptions: xAppActionTxDetails): Promise<boolean | Error> | void;
+  close(closeOptions?: xAppActionClose): Promise<boolean | Error> | void;
+  ready(): Promise<boolean | Error> | void;
+  customCommand(customCommand: string, customCommandOptions?: AnyJson): Promise<boolean | Error> | void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xumm@1.8.0/node_modules/xumm/dist/index.d.ts
+interface UniversalSdkEvent {
+  logout: () => void;
+  ready: () => void;
+  retrieving: () => void;
+}
+/**
+ * Development?
+ *   npm run watch (tsc in watch mode)
+ *   npm run browserify-watch (watch, browserify tsc output)
+ *   npm run serve (webserver, :3001)
+ *   npm run dev (watch, nodemon dist/samples/index.js)
+ *   ngrok start dev (local :3001 to https:// dev URL)
+ *     > https://.../sample/
+ */
+declare enum Runtimes {
+  cli = "cli",
+  browser = "browser",
+  xapp = "xapp"
+}
+type Runtime = Record<Runtimes, boolean>;
+declare interface Xumm {
+  on<U extends keyof UniversalSdkEvent>(event: U, listener: UniversalSdkEvent[U]): this;
+  on<U extends keyof xAppEvent>(event: U, listener: xAppEvent[U]): this;
+  on<U extends keyof XummPkceEvent>(event: U, listener: XummPkceEvent[U]): this;
+  off<U extends keyof UniversalSdkEvent>(event: U, listener: UniversalSdkEvent[U]): this;
+  off<U extends keyof xAppEvent>(event: U, listener: xAppEvent[U]): this;
+  off<U extends keyof XummPkceEvent>(event: U, listener: XummPkceEvent[U]): this;
+}
+/**
+ * The Promisified type takes an entire class and expects all methods
+ * to return a Promise of their method's native return values
+ */
+type Promisified<T> = { [K in keyof T]: T[K] extends ((...args: infer A) => infer R) ? (...args: A) => Promise<R> : T[K] };
+interface Environment {
+  ott?: Promise<xAppOttData | undefined>;
+  jwt?: Promise<{
+    client_id: string;
+    scope?: string;
+    state?: string;
+    aud: string;
+    sub: string;
+    email?: string;
+    app_uuidv4: string;
+    app_name: string;
+    payload_uuidv4?: string;
+    usertoken_uuidv4?: string;
+    network_type?: string;
+    network_endpoint?: string;
+    network_id?: number;
+    iat: number;
+    exp: number;
+    iss: string;
+    usr?: string;
+    net?: string;
+    [key: string]: any;
+  } | undefined>;
+  openid?: Promise<{
+    sub: string;
+    email: string;
+    picture: string;
+    account: string;
+    name: string;
+    domain?: string;
+    blocked: boolean;
+    source?: string;
+    kycApproved: boolean;
+    proSubscription: boolean;
+    networkType: string;
+    networkEndpoint: string;
+    networkId?: number;
+    profile?: XummProfile;
+    [key: string]: any;
+  } | undefined>;
+  bearer?: Promise<string>;
+  retrieving: Promise<void>;
+  ready: Promise<void>;
+  success: Promise<void>;
+  retrieved: Promise<void>;
+}
+declare class UnifiedUserData {
+  account: Promise<string | undefined>;
+  picture: Promise<string | undefined>;
+  name: Promise<string | undefined>;
+  domain: Promise<string | undefined>;
+  source: Promise<string | undefined>;
+  networkType: Promise<string | undefined>;
+  networkEndpoint: Promise<string | undefined>;
+  networkId: Promise<number | undefined>;
+  blocked: Promise<boolean | undefined>;
+  kycApproved: Promise<boolean | undefined>;
+  proSubscription: Promise<boolean | undefined>;
+  profile: Promise<XummProfile | undefined>;
+  token: Promise<string | null>;
+}
+/**
+ * This is where the magic happens
+ */
+declare class Xumm extends EventEmitter {
+  private instance;
+  private jwtCredential;
+  runtime: Runtime;
+  state: {
+    account: string;
+    signedIn: boolean;
+  };
+  user: UnifiedUserData;
+  environment: Environment;
+  payload?: Promisified<Payload>;
+  xapp?: xApp;
+  userstore?: Promisified<JwtUserdata>;
+  backendstore?: Promisified<Storage$1>;
+  helpers?: Promisified<Pick<XummSdkJwt, "ping" | "getCuratedAssets" | "getKycStatus" | "getTransaction" | "verifyUserTokens" | "getRates" | "getNftokenDetail">>;
+  push?: Promisified<Push>;
+  private apiKeyOrJwt;
+  private apiSecretOrOtt?;
+  constructor(apiKeyOrJwt: string, apiSecretOrOtt?: string);
+  private initialize;
+  /**
+   * PKCE
+   */
+  authorize(): Promise<ResolvedFlow | undefined | Error>;
+  /**
+   * TODO: CHECK IF EVENTS ARE NOT REGISTERED AND FIRING TWICE
+   */
+  private handlePkceEvents;
+  logout(): Promise<void>;
+  /**
+   * SDK
+   */
+  ping(): Promise<ReturnType<XummSdk["ping"]> | undefined>;
+}
+//#endregion
+//#region src/xrp/utils.d.ts
+type WalletName = "XAMAN" | "GEM";
+interface WalletConfig {
+  name: WalletName;
+  instance: Xumm | typeof index_d_exports;
+}
+type XamanConfig = {
+  name: "XAMAN";
+  instance: Xumm;
+};
+type GemConfig = {
+  name: "GEM";
+  instance: typeof index_d_exports;
+};
+type WalletInitConfig = XamanConfig | GemConfig;
+type XrpWallet = "Xumm" | "GemWallet";
+declare function createXummPayload(message: string): Record<string, unknown>;
+declare function signXummTx(xummInstance: Xumm, payload: Record<string, unknown>): Promise<string>;
+declare function getXummPublicKey(wallet: Xumm): Promise<string | undefined>;
+declare function signGemWalletTx(gemWalletInstance: typeof index_d_exports, message: string): Promise<string | undefined>;
+declare function getGemWalletPublicKey(wallet: typeof index_d_exports): Promise<{
+  address: string;
+  publicKey: string;
+} | undefined>;
+declare function getXrpAddress(wallet: Xumm | typeof index_d_exports): Promise<string | undefined>;
+declare function looksLikeXrpWallet(wallet: unknown): wallet is Xumm | typeof index_d_exports;
+declare function getXrpWalletType(object: Record<string, unknown>): Promise<XrpWallet>;
+declare function getXrpTxHash(message: string | Uint8Array, wallet: Xumm | typeof index_d_exports): Promise<string | undefined>;
+declare function getXrpPublicKey(wallet: Xumm | typeof index_d_exports): Promise<{
+  address: string;
+  publicKey: string;
+} | undefined>;
+//#endregion
+export { GemConfig, WalletConfig, WalletInitConfig, WalletName, XamanConfig, createXummPayload, getGemWalletPublicKey, getXrpAddress, getXrpPublicKey, getXrpTxHash, getXrpWalletType, getXummPublicKey, looksLikeXrpWallet, signGemWalletTx, signXummTx };
+//# sourceMappingURL=utils.d.mts.map