@ibearua/bitmask-core-dev 1.0.0-beta.11 → 1.0.0-beta.13

package/bp.ts

@@ -0,0 +1,72 @@
+
+// BP
+import * as BMC from "./bitmask_core";
+import {FundVaultDetails, TransactionDataDetails, WalletTransaction} from "./bitcoin";
+
+export const transferBtc = async (
+    nostrHexSk: string,
+    address: string,
+    sats: bigint,
+    feeRate: number,
+    secrets: string[],
+): Promise<TransactionData> => JSON.parse(await BMC.transfer_sats(nostrHexSk,address, sats, feeRate, secrets));
+
+export const fundRgbVault = async (
+    nostrHexSk: string,
+    feeRate: number,
+    secrets: string[],
+    broadcast: boolean,
+    fundValue?: bigint | null,
+    coordinatorFee?: boolean | null,
+): Promise<FundVaultDetails> => JSON.parse(await BMC.fund_rgb_vault(
+    nostrHexSk,
+    feeRate,
+    secrets,
+    broadcast,
+    fundValue || null,
+    coordinatorFee || false,
+));
+
+export const backupBtcWallet = async (
+    nostrHexSk: string,
+): Promise<boolean> => JSON.parse(await BMC.backup_btc_data(nostrHexSk));
+
+export const restoreBtcWallet = async (
+    nostrHexSk: string,
+): Promise<boolean> => JSON.parse(await BMC.restore_btc_data(nostrHexSk));
+
+export const recoverFundsFromBadWallets = async (
+    seed: string,
+    passPhrase: string,
+    recoverAddress: string,
+): Promise<RecoverVaultDetails> => JSON.parse(await BMC.recover_funds_from_bad_wallets(seed, passPhrase, recoverAddress));
+
+export const getBtcWallet = async (
+    nostrHexSk: string,
+): Promise<WalletData> => JSON.parse(await BMC.get_btc_wallet(nostrHexSk));
+
+
+export interface TransactionData {
+    details: TransactionDataDetails;
+    vsize: number;
+    feeRate: number;
+}
+
+export interface WalletBalance {
+    confirmed: number;
+}
+
+
+export interface WalletData {
+    wallet?: string;
+    name: string;
+    address: string;
+    balance: WalletBalance;
+    transactions: WalletTransaction[];
+    utxos: string[];
+}
+
+export interface RecoverVaultDetails {
+    txid: string;
+    fee: number;
+}

package/carbonado.d.ts

@@ -0,0 +1,12 @@
+export declare const store: (nostrHexSk: string, data: Uint8Array, force: boolean, name?: string, meta?: Uint8Array) => Promise<void>;
+export declare const retrieve: (nostrHexSk: string, lookup: string) => Promise<Uint8Array>;
+export declare const retrieveMetadata: (nostrHexSk: string, lookup: string) => Promise<FileMetadata>;
+export declare const encodeHex: (bytes: Uint8Array) => string;
+export declare const encodeBase64: (bytes: Uint8Array) => string;
+export declare const decodeHex: (str: string) => Uint8Array;
+export declare const decodeBase64: (str: string) => Uint8Array;
+export interface FileMetadata {
+    filename: string;
+    metadata: Uint8Array;
+}
+//# sourceMappingURL=carbonado.d.ts.map

package/carbonado.js

@@ -0,0 +1,52 @@
+"use strict";
+// Methods meant to work with Carbonado storage defined within the web::carbonado module from bitmask-core:
+// https://github.com/diba-io/bitmask-core/blob/development/src/web.rs
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase64 = exports.decodeHex = exports.encodeBase64 = exports.encodeHex = exports.retrieveMetadata = exports.retrieve = exports.store = void 0;
+const BMC = __importStar(require("./bitmask_core"));
+const store = (nostrHexSk, data, force, name, meta) => __awaiter(void 0, void 0, void 0, function* () { return BMC.store(nostrHexSk, name || "", data, force, meta); });
+exports.store = store;
+const retrieve = (nostrHexSk, lookup) => BMC.retrieve(nostrHexSk, lookup);
+exports.retrieve = retrieve;
+const retrieveMetadata = (nostrHexSk, lookup) => BMC.retrieve_metadata(nostrHexSk, lookup);
+exports.retrieveMetadata = retrieveMetadata;
+const encodeHex = (bytes) => BMC.encode_hex(bytes);
+exports.encodeHex = encodeHex;
+const encodeBase64 = (bytes) => BMC.encode_base64(bytes);
+exports.encodeBase64 = encodeBase64;
+const decodeHex = (str) => BMC.decode_hex(str);
+exports.decodeHex = decodeHex;
+const decodeBase64 = (str) => BMC.decode_base64(str);
+exports.decodeBase64 = decodeBase64;

package/carbonado.ts

@@ -0,0 +1,34 @@
+// Methods meant to work with Carbonado storage defined within the web::carbonado module from bitmask-core:
+// https://github.com/diba-io/bitmask-core/blob/development/src/web.rs
+
+import * as BMC from "./bitmask_core";
+
+export const store = async (
+  nostrHexSk: string,
+  data: Uint8Array,
+  force: boolean,
+  name?: string,
+  meta?: Uint8Array
+): Promise<void> => BMC.store(nostrHexSk, name || "", data, force, meta);
+
+export const retrieve = (
+  nostrHexSk: string,
+  lookup: string
+): Promise<Uint8Array> => BMC.retrieve(nostrHexSk, lookup);
+
+export const retrieveMetadata = (
+  nostrHexSk: string,
+  lookup: string
+): Promise<FileMetadata> => BMC.retrieve_metadata(nostrHexSk, lookup);
+
+export const encodeHex = (bytes: Uint8Array): string => BMC.encode_hex(bytes);
+export const encodeBase64 = (bytes: Uint8Array): string =>
+  BMC.encode_base64(bytes);
+
+export const decodeHex = (str: string): Uint8Array => BMC.decode_hex(str);
+export const decodeBase64 = (str: string): Uint8Array => BMC.decode_base64(str);
+
+export interface FileMetadata {
+  filename: string;
+  metadata: Uint8Array;
+}

package/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const getNetwork: () => Promise<string>;
+export declare const switchNetwork: (network: Network) => Promise<void>;
+export declare const getEnv: (key: string) => Promise<string>;
+export declare const setEnv: (key: string, value: string) => Promise<void>;
+export declare enum Network {
+    bitcoin = "bitcoin",
+    testnet = "testnet",
+    signet = "signet",
+    regtest = "regtest"
+}
+export declare const DISABLE_LN: string | boolean;
+export declare let LNDHUBX: boolean;
+export declare let CARBONADO: boolean;
+export declare let BITMASK: boolean;
+export declare const init: (networkOverride?: string) => Promise<void>;
+//# sourceMappingURL=constants.d.ts.map

package/constants.js

@@ -0,0 +1,133 @@
+"use strict";
+// Methods meant to work with bitmask-core constants defined within the web::constants module from bitmask-core:
+// https://github.com/diba-io/bitmask-core/blob/development/src/web.rs
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = exports.BITMASK = exports.CARBONADO = exports.LNDHUBX = exports.DISABLE_LN = exports.Network = exports.setEnv = exports.getEnv = exports.switchNetwork = exports.getNetwork = void 0;
+const bitmask_core_1 = __importStar(require("./bitmask_core")), BMC = bitmask_core_1;
+const getNetwork = () => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(yield BMC.get_network()); });
+exports.getNetwork = getNetwork;
+const switchNetwork = (network) => __awaiter(void 0, void 0, void 0, function* () { return BMC.switch_network(network.toString()); });
+exports.switchNetwork = switchNetwork;
+const getEnv = (key) => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(yield BMC.get_env(key)); });
+exports.getEnv = getEnv;
+const setEnv = (key, value) => __awaiter(void 0, void 0, void 0, function* () { return BMC.set_env(key, value); });
+exports.setEnv = setEnv;
+var Network;
+(function (Network) {
+    Network["bitcoin"] = "bitcoin";
+    Network["testnet"] = "testnet";
+    Network["signet"] = "signet";
+    Network["regtest"] = "regtest";
+})(Network || (exports.Network = Network = {}));
+exports.DISABLE_LN = ((_a = process.env) === null || _a === void 0 ? void 0 : _a.DISABLE_LN) === "true" ? true : false || "";
+exports.LNDHUBX = false;
+exports.CARBONADO = false;
+exports.BITMASK = false;
+const init = (networkOverride) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (networkOverride) {
+            yield (0, exports.switchNetwork)(Network[networkOverride]);
+        }
+        yield (0, bitmask_core_1.default)();
+        const network = yield (0, exports.getNetwork)();
+        if (network === "bitcoin" && process.env.PROD_LNDHUB_ENDPOINT) {
+            yield (0, exports.setEnv)("LNDHUB_ENDPOINT", process.env.PROD_LNDHUB_ENDPOINT);
+        }
+        else if (process.env.TEST_LNDHUB_ENDPOINT) {
+            yield (0, exports.setEnv)("LNDHUB_ENDPOINT", process.env.TEST_LNDHUB_ENDPOINT);
+        }
+        if (process.env.CARBONADO_ENDPOINT) {
+            yield (0, exports.setEnv)("CARBONADO_ENDPOINT", process.env.CARBONADO_ENDPOINT);
+        }
+        if (process.env.BITMASK_ENDPOINT) {
+            yield (0, exports.setEnv)("BITMASK_ENDPOINT", process.env.BITMASK_ENDPOINT);
+        }
+        if (process.env.BITCOIN_EXPLORER_API_MAINNET) {
+            yield (0, exports.setEnv)("BITCOIN_EXPLORER_API_MAINNET", process.env.BITCOIN_EXPLORER_API_MAINNET);
+        }
+        if (process.env.BITCOIN_EXPLORER_API_TESTNET) {
+            yield (0, exports.setEnv)("BITCOIN_EXPLORER_API_TESTNET", process.env.BITCOIN_EXPLORER_API_TESTNET);
+        }
+    }
+    catch (err) {
+        console.error("Error in setEnv", err);
+    }
+    const lndhubx = yield (0, exports.getEnv)("LNDHUB_ENDPOINT");
+    const carbonado = yield (0, exports.getEnv)("CARBONADO_ENDPOINT");
+    const bitmask = yield (0, exports.getEnv)("BITMASK_ENDPOINT");
+    try {
+        if (!exports.DISABLE_LN) {
+            yield fetch(`${lndhubx}/nodeinfo`);
+            exports.LNDHUBX = true;
+            console.debug(`${lndhubx}/nodeinfo successfully reached`);
+        }
+    }
+    catch (e) {
+        exports.LNDHUBX = false;
+        console.warn("Could not reach lndhubx", lndhubx, e);
+    }
+    try {
+        yield fetch(`${carbonado}/status`);
+        exports.CARBONADO = true;
+        console.debug(`${carbonado}/status successfully reached`);
+    }
+    catch (e) {
+        exports.CARBONADO = false;
+        console.warn("Could not reach carbonado", carbonado, e);
+    }
+    try {
+        yield fetch(`${bitmask}/carbonado/status`);
+        exports.BITMASK = true;
+        console.debug(`${bitmask}/status successfully reached`);
+    }
+    catch (e) {
+        exports.BITMASK = false;
+        console.warn("Could not reach bitmask", bitmask, e);
+    }
+    console.debug(BMC.version(), "initialized");
+    console.debug("Using LNDHubX endpoint:", lndhubx);
+    console.debug("Using Carbonado endpoint:", carbonado);
+    console.debug("Using bitmaskd endpoint:", bitmask);
+});
+exports.init = init;
+const networkOverride = process.env.NETWORK_OVERRIDE;
+if (networkOverride) {
+    const network = Network[networkOverride.toLowerCase()];
+    (0, exports.init)(network);
+}
+else {
+    (0, exports.init)();
+}

package/constants.ts

@@ -0,0 +1,112 @@
+// Methods meant to work with bitmask-core constants defined within the web::constants module from bitmask-core:
+// https://github.com/diba-io/bitmask-core/blob/development/src/web.rs
+
+import initBMC, * as BMC from "./bitmask_core";
+
+export const getNetwork = async (): Promise<string> =>
+  JSON.parse(await BMC.get_network());
+
+export const switchNetwork = async (network: Network): Promise<void> =>
+  BMC.switch_network(network.toString());
+
+export const getEnv = async (key: string): Promise<string> =>
+  JSON.parse(await BMC.get_env(key));
+
+export const setEnv = async (key: string, value: string): Promise<void> =>
+  BMC.set_env(key, value);
+
+export enum Network {
+  bitcoin = "bitcoin",
+  testnet = "testnet",
+  signet = "signet",
+  regtest = "regtest",
+}
+type NetworkType = typeof Network;
+type NetworkKeyType = keyof NetworkType;
+
+export const DISABLE_LN =
+  process.env?.DISABLE_LN === "true" ? true : false || "";
+export let LNDHUBX = false;
+export let CARBONADO = false;
+export let BITMASK = false;
+
+export const init = async (networkOverride?: string) => {
+  try {
+    if (networkOverride) {
+      await switchNetwork(Network[networkOverride as NetworkKeyType]);
+    }
+    await initBMC();
+
+    const network = await getNetwork();
+    if (network === "bitcoin" && process.env.PROD_LNDHUB_ENDPOINT) {
+      await setEnv("LNDHUB_ENDPOINT", process.env.PROD_LNDHUB_ENDPOINT);
+    } else if (process.env.TEST_LNDHUB_ENDPOINT) {
+      await setEnv("LNDHUB_ENDPOINT", process.env.TEST_LNDHUB_ENDPOINT);
+    }
+    if (process.env.CARBONADO_ENDPOINT) {
+      await setEnv("CARBONADO_ENDPOINT", process.env.CARBONADO_ENDPOINT);
+    }
+    if (process.env.BITMASK_ENDPOINT) {
+      await setEnv("BITMASK_ENDPOINT", process.env.BITMASK_ENDPOINT);
+    }
+    if (process.env.BITCOIN_EXPLORER_API_MAINNET) {
+      await setEnv(
+        "BITCOIN_EXPLORER_API_MAINNET",
+        process.env.BITCOIN_EXPLORER_API_MAINNET
+      );
+    }
+    if (process.env.BITCOIN_EXPLORER_API_TESTNET) {
+      await setEnv(
+        "BITCOIN_EXPLORER_API_TESTNET",
+        process.env.BITCOIN_EXPLORER_API_TESTNET
+      );
+    }
+  } catch (err) {
+    console.error("Error in setEnv", err);
+  }
+
+  const lndhubx = await getEnv("LNDHUB_ENDPOINT");
+  const carbonado = await getEnv("CARBONADO_ENDPOINT");
+  const bitmask = await getEnv("BITMASK_ENDPOINT");
+
+  try {
+    if (!DISABLE_LN) {
+      await fetch(`${lndhubx}/nodeinfo`);
+      LNDHUBX = true;
+      console.debug(`${lndhubx}/nodeinfo successfully reached`);
+    }
+  } catch (e) {
+    LNDHUBX = false;
+    console.warn("Could not reach lndhubx", lndhubx, e);
+  }
+  try {
+    await fetch(`${carbonado}/status`);
+    CARBONADO = true;
+    console.debug(`${carbonado}/status successfully reached`);
+  } catch (e) {
+    CARBONADO = false;
+    console.warn("Could not reach carbonado", carbonado, e);
+  }
+  try {
+    await fetch(`${bitmask}/carbonado/status`);
+    BITMASK = true;
+    console.debug(`${bitmask}/status successfully reached`);
+  } catch (e) {
+    BITMASK = false;
+    console.warn("Could not reach bitmask", bitmask, e);
+  }
+
+  console.debug(BMC.version(), "initialized");
+  console.debug("Using LNDHubX endpoint:", lndhubx);
+  console.debug("Using Carbonado endpoint:", carbonado);
+  console.debug("Using bitmaskd endpoint:", bitmask);
+};
+
+const networkOverride = process.env.NETWORK_OVERRIDE;
+
+if (networkOverride) {
+  const network = Network[networkOverride.toLowerCase() as keyof typeof Network];
+  init(network);
+} else {
+  init();
+}

package/index.d.ts

@@ -0,0 +1,30 @@
+import * as BMC from "./bitmask_core";
+export * from "./bitmask_core";
+import * as bitcoin from "./bitcoin";
+import * as carbonado from "./carbonado";
+import * as constants from "./constants";
+import * as lightning from "./lightning";
+import * as nostr from "./nostr";
+import * as rgb from "./rgb";
+import * as wallet from "./wallet";
+export * as bitcoin from "./bitcoin";
+export * as carbonado from "./carbonado";
+export * as constants from "./constants";
+export * as lightning from "./lightning";
+export * as nostr from "./nostr";
+export * as rgb from "./rgb";
+export * as wallet from "./wallet";
+export * as bp from "./bp";
+export type { WalletData } from "./bp";
+declare const _default: {
+    BMC: typeof BMC;
+    bitcoin: typeof bitcoin;
+    carbonado: typeof carbonado;
+    constants: typeof constants;
+    lightning: typeof lightning;
+    nostr: typeof nostr;
+    rgb: typeof rgb;
+    wallet: typeof wallet;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bp = exports.wallet = exports.rgb = exports.nostr = exports.lightning = exports.constants = exports.carbonado = exports.bitcoin = void 0;
+const BMC = __importStar(require("./bitmask_core"));
+__exportStar(require("./bitmask_core"), exports); // kludge :c
+const bitcoin = __importStar(require("./bitcoin"));
+const carbonado = __importStar(require("./carbonado"));
+const constants = __importStar(require("./constants"));
+const lightning = __importStar(require("./lightning"));
+const nostr = __importStar(require("./nostr"));
+const rgb = __importStar(require("./rgb"));
+const wallet = __importStar(require("./wallet"));
+exports.bitcoin = __importStar(require("./bitcoin"));
+exports.carbonado = __importStar(require("./carbonado"));
+exports.constants = __importStar(require("./constants"));
+exports.lightning = __importStar(require("./lightning"));
+exports.nostr = __importStar(require("./nostr"));
+exports.rgb = __importStar(require("./rgb"));
+exports.wallet = __importStar(require("./wallet"));
+exports.bp = __importStar(require("./bp"));
+exports.default = {
+    BMC,
+    bitcoin,
+    carbonado,
+    constants,
+    lightning,
+    nostr,
+    rgb,
+    wallet,
+};

package/index.ts

@@ -0,0 +1,33 @@
+import * as BMC from "./bitmask_core";
+export * from "./bitmask_core"; // kludge :c
+
+import * as bitcoin from "./bitcoin";
+import * as carbonado from "./carbonado";
+import * as constants from "./constants";
+import * as lightning from "./lightning";
+import * as nostr from "./nostr";
+import * as rgb from "./rgb";
+import * as wallet from "./wallet";
+import * as bp from "./bp";
+
+export * as bitcoin from "./bitcoin";
+export * as carbonado from "./carbonado";
+export * as constants from "./constants";
+export * as lightning from "./lightning";
+export * as nostr from "./nostr";
+export * as rgb from "./rgb";
+export * as wallet from "./wallet";
+export * as bp from "./bp";
+
+export type { WalletData } from "./bp";
+
+export default {
+  BMC,
+  bitcoin,
+  carbonado,
+  constants,
+  lightning,
+  nostr,
+  rgb,
+  wallet,
+};

package/lightning.d.ts

@@ -0,0 +1,101 @@
+export declare const createWallet: (username: string, password: string) => Promise<CreateWalletResponse>;
+export declare const auth: (username: string, password: string) => Promise<AuthResponse>;
+export declare const createInvoice: (description: string, amount: number, token: string) => Promise<AddInvoiceResponse>;
+export declare const getBalance: (token: string) => Promise<Account>;
+export declare const getTxs: (token: string) => Promise<LnTransaction[]>;
+export declare const payInvoice: (paymentRequest: string, token: string) => Promise<PayInvoiceResponse>;
+export declare const checkPayment: (paymentHash: string) => Promise<CheckPaymentResponse>;
+export declare const swapBtcLn: (token: string) => Promise<SwapBtcLnResponse>;
+export declare const swapLnBtc: (address: string, amount: bigint, token: string) => Promise<SwapLnBtcResponse>;
+export interface LnCredentials {
+    login: string;
+    password: string;
+    refreshToken: string;
+    accessToken: string;
+}
+export interface CreateWalletResponse {
+    username?: string;
+    error?: string;
+}
+export type AuthResponse = ErrorResponse | AuthResponseOk;
+export interface AuthResponseOk {
+    refresh: string;
+    token: string;
+}
+export interface ErrorResponse {
+    error: string;
+}
+export interface Account {
+    account_id: string;
+    balance: string;
+    currency: string;
+}
+export interface Money {
+    value: string;
+    currency: string;
+}
+export interface AddInvoiceResponse {
+    req_id: string;
+    uid: number;
+    payment_request: string;
+    meta: string;
+    metadata: string;
+    amount: Money;
+    rate: string;
+    currency: string;
+    target_account_currency: string;
+    account_id: string;
+    error: string;
+    fees: string;
+}
+export interface LnTransaction {
+    txid: string;
+    fee_txid: string;
+    outbound_txid: string;
+    inbound_txid: string;
+    created_at: bigint;
+    date: number;
+    outbound_amount: string;
+    inbound_amount: string;
+    outbound_account_id: string;
+    inbound_account_id: string;
+    outbound_uid: number;
+    inbound_uid: number;
+    outbound_currency: string;
+    inbound_currency: string;
+    exchange_rate: string;
+    tx_type: string;
+    fees: string;
+    reference: string;
+}
+export interface LnWalletData {
+    balance: Account;
+    transactions: LnTransaction[];
+}
+export interface PayInvoiceResponse {
+    payment_hash: string;
+    uid: number;
+    success: boolean;
+    currency: string;
+    payment_request: string;
+    amount: Money;
+    fees: Money;
+    error: string;
+    payment_preimage: string;
+    destination: string;
+    description: string;
+}
+export interface CheckPaymentResponse {
+    paid: boolean;
+}
+export interface SwapBtcLnResponse {
+    address: string;
+    commitment: string;
+    signature: string;
+    secret_access_key: string;
+}
+export interface SwapLnBtcResponse {
+    bolt11_invoice: string;
+    fee_sats: number;
+}
+//# sourceMappingURL=lightning.d.ts.map