hypay-adapter/dist/index.mjs

Provides an XRPL payment adapter.

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);

// src/types/xrpl.ts
var NETWORKS = {
  LOCALNET: "ws://localhost:6006/",
  TESTNET: "wss://s.altnet.rippletest.net:51233",
  DEVNET: "wss://s.devnet.rippletest.net:51233",
  MAINNET: "wss://s1.ripple.com"
};

// src/types/wallet.ts
import { Client } from "xrpl";
var AbstractWallet = class {
  constructor(network = "TESTNET") {
    __publicField(this, "networkType");
    __publicField(this, "networkAddress");
    this.networkType = network;
    this.networkAddress = NETWORKS[network];
  }
  async getCurrentFee() {
    const client = new Client(this.networkType);
    await client.connect();
    const feeResponse = await client.request({ command: "fee" });
    const { base_fee: _, median_fee: medianFee, minimum_fee: __, open_ledger_fee: ___ } = feeResponse.result.drops;
    await client.disconnect();
    return {
      medianFee
    };
  }
};

// src/controllers/wallet/xaman.ts
import { Xumm } from "xumm";
var XamanWallet = class extends AbstractWallet {
  constructor(destination, apiCredentials) {
    super();
    __publicField(this, "destinationAddress");
    __publicField(this, "connectedAddress");
    __publicField(this, "xumm");
    __publicField(this, "txidTopayloadUuidMapper");
    __publicField(this, "apiKey", "85df3ccf-63cc-402e-b2fa-0ceb8fcf2669");
    __publicField(this, "apiSecret", "07168ac9-1b02-4b62-91c9-028881330f05");
    this.destinationAddress = destination;
    this.apiKey = apiCredentials?.key || "85df3ccf-63cc-402e-b2fa-0ceb8fcf2669";
    this.apiSecret = apiCredentials?.secret || "07168ac9-1b02-4b62-91c9-028881330f05";
    this.xumm = new Xumm(this.apiKey, this.apiSecret);
    this.txidTopayloadUuidMapper = /* @__PURE__ */ new Map();
  }
  async init() {
  }
  async connect() {
    await this.xumm.authorize();
    this.connectedAddress = await this.xumm.user.account;
    return {
      address: this.connectedAddress ?? "",
      providerName: "XAMAN"
    };
  }
  async createPaymentTx({ amount, meta_data }) {
    if (!this.xumm) {
      throw new Error("Xaman Wallet SDK is not available.");
    }
    const draftTransaction = {
      TransactionType: "Payment",
      Destination: this.destinationAddress,
      Amount: amount,
      options: {
        force_network: this.networkType
      },
      custom_meta: {
        identifier: meta_data?.identifier,
        instruction: meta_data?.instruction,
        blob: meta_data?.blob
      }
    };
    const payload = await this.xumm.payload?.create({ txjson: draftTransaction });
    if (!payload) throw new Error("Error");
    return payload.uuid;
  }
  async signAndSubmit({ payloadUuid }) {
    if (!this.xumm) {
      throw new Error("Xaman Wallet SDK is not available.");
    }
    try {
      const isReady = await this.xumm.xapp?.ready();
      if (!isReady) throw new Error("Xapp can not loaded. please load screen for debuging.");
    } catch (e) {
      return "Can not connect to Xaman Apps";
    }
    await this.xumm.xapp?.openSignRequest({ uuid: payloadUuid });
    return "Sign request opened";
  }
  async getSubmittedTxResult(payloadUuid) {
    const payload = await this.xumm.payload?.get(payloadUuid);
    if (!payload) throw new Error("Error");
    if (payload.response.txid) this.txidTopayloadUuidMapper.set(payload.response.txid, payloadUuid);
    const isSuccess = payload.response.dispatched_result === "tesSUCCESS";
    const isSubmitted = payload.response.txid !== null;
    const isResolved = payload.response.resolved_at !== null;
    return {
      success: isSuccess,
      submitted: isSubmitted,
      resolved: isResolved,
      validated: isSuccess && isSubmitted && isResolved,
      txid: payload.response.txid,
      createdAt: payload.payload.created_at,
      expiresAt: payload.payload.expires_at,
      raw: payload.response
    };
  }
  async request({ method, params }) {
    if (!this.xumm) {
      throw new Error("Xaman Wallet SDK is not available.");
    }
    const draftTransaction = {
      TransactionType: method,
      ...params
    };
    const payload = await this.xumm.payload?.create({ txjson: draftTransaction });
    if (!payload) throw new Error("Error");
    return payload.uuid;
  }
  async respond(_) {
  }
  async ping() {
    if (!this.xumm) {
      throw new Error("Xaman Wallet SDK is not available.");
    }
    const ping = await this.xumm.ping();
    if (ping) return { pong: ping.jwtData?.pong ?? false };
    return { pong: false };
  }
  async disconnect() {
    if (!this.xumm) {
      throw new Error("Xaman Wallet SDK is not available.");
    }
    await this.xumm.logout();
    this.connectedAddress = void 0;
  }
  formatAuthMessage(params) {
    return `Sign in request from ${params.origin}

Payload:
${params.payload}`;
  }
};

// src/index.ts
var XamanWallet2 = XamanWallet;
export {
  XamanWallet2 as XamanWallet
};