@ibearua/bitmask-core-dev 1.0.0-beta.10 → 1.0.0-beta.12

package/bitcoin.d.ts

@@ -0,0 +1,140 @@
+export declare const hashPassword: (password: string) => string;
+export declare const decryptWallet: (hash: string, encryptedDescriptors: string, seedPassword?: string) => Promise<Vault>;
+export declare const upgradeWallet: (hash: string, encryptedDescriptors: string, seedPassword?: string) => Promise<string>;
+export declare const syncWallets: () => Promise<void>;
+export declare const newWallet: (hash: string, seedPassword: string) => Promise<string>;
+export declare const encryptWallet: (mnemonic: string, hash: string, seedPassword: string) => Promise<string>;
+export declare const getWalletData: (descriptor: string, changeDescriptor?: string) => Promise<WalletData>;
+export declare const getNewAddress: (descriptor: string, changeDescriptor?: string) => Promise<string>;
+export declare const sendSats: (descriptor: string, changeDescriptor: string, address: string, amount: bigint, broadcast: boolean, feeRate: number) => Promise<TransactionData>;
+export declare const fundVault: (descriptor: string, changeDescriptor: string, rgbAddress: string, broadcast: boolean, feeRate?: number) => Promise<FundVaultDetails>;
+export declare const getAssetsVault: (rgbDescriptorXpub: string) => Promise<FundVaultDetails>;
+export declare const drainWallet: (destination: string, descriptor: string, changeDescriptor?: string, feeRate?: number) => Promise<TransactionData>;
+export declare const bumpFee: (txid: string, feeRate: number, broadcast: boolean, descriptor: string, changeDescriptor?: string) => Promise<TransactionData>;
+export interface PrivateWalletData {
+    xprvkh: string;
+    btcDescriptorXprv: string;
+    btcChangeDescriptorXprv: string;
+    rgbDescriptorXprv: string;
+    nostrPrv: string;
+    nostrNsec: string;
+}
+export interface PublicWalletData {
+    xpubkh: string;
+    btcDescriptorXpub: string;
+    btcChangeDescriptorXpub: string;
+    rgbDescriptorXpub: string;
+    nostrPub: string;
+    nostrNpub: string;
+}
+export interface Vault {
+    mnemonic: string;
+    private: PrivateWalletData;
+    public: PublicWalletData;
+}
+export interface Transaction extends WalletTransaction {
+    amount: number;
+    asset?: string;
+    assetType: string;
+    fee: number;
+    message?: string;
+    note?: string;
+}
+export interface Activity extends Transaction {
+    id: string;
+    date: number;
+    action: string;
+    status: string;
+    lightning?: boolean;
+    sender?: {
+        name: string;
+        address: string;
+    };
+    recipient?: {
+        name: string;
+        address: string;
+        invoice: string;
+    };
+}
+export interface TransactionDetails extends Transaction {
+    sender: {
+        name: string;
+        address: string;
+    };
+    recipient: {
+        name: string;
+        address: string;
+        invoice: string;
+    };
+}
+export interface TransactionData {
+    details: TransactionDataDetails;
+    vsize: number;
+    feeRate: number;
+}
+export interface TransactionDataDetails {
+    transaction?: Transaction;
+    txid: string;
+    received: number;
+    sent: number;
+    fee: number;
+    confirmationTime?: ConfirmationTime;
+    confirmed?: boolean;
+}
+export interface ConfirmationTime {
+    height: number;
+    timestamp: number;
+}
+export interface WalletTransaction {
+    txid: string;
+    received: number;
+    sent: number;
+    fee: number;
+    confirmed: boolean;
+    confirmationTime: ConfirmationTime;
+    vsize: number;
+    feeRate: number;
+}
+export interface WalletBalance {
+    immature: number;
+    trustedPending: number;
+    untrustedPending: number;
+    confirmed: number;
+}
+export interface WalletData {
+    wallet?: string;
+    name: string;
+    address: string;
+    balance: WalletBalance;
+    transactions: WalletTransaction[];
+    utxos: string[];
+}
+export interface FundVaultDetails {
+    rgbOutput?: string;
+    isFunded: boolean;
+    fundTxid?: string;
+    fundFee?: number;
+}
+export type FeeEstimates = Record<string, number>;
+export declare function fetchFeeEstimates(): Promise<FeeEstimates>;
+export declare function feeFromRate(vbytes: number, satPerVb: number): number;
+/**
+ * Rough vbytes guesser for swap/bid PSBTs when you don't yet know exact inputs/outputs.
+ * Prefer passing a conservative bound to avoid underpaying relays:
+ * - Default assumes ~2 inputs, ~3 outputs, taproot heavy mix, returns ~400 vB.
+ * - Scale linearly for more inputs/outputs.
+ *
+ * If you know inputs/outputs counts beforehand, pass them to tighten the estimate.
+ */
+export declare function guessSwapVbytes(inputs?: number, outputs?: number, taprootHeavy?: boolean): number;
+/**
+ * Convenience: get a safe absolute fee quote for a swap given a target confirmation bucket.
+ * - bucket can be "1","2","3","6","144", etc., matching Esplora keys.
+ * - vbytesEstimate can be computed via guessSwapVbytes() or a tighter UI estimate.
+ * - Adds a small 10% safety margin on the feerate to reduce min-relay rejections.
+ */
+export declare function quoteSwapFeeSats(bucket: string, vbytesEstimate: number): Promise<{
+    rate: number;
+    fee: number;
+}>;
+//# sourceMappingURL=bitcoin.d.ts.map

package/bitcoin.js

@@ -0,0 +1,154 @@
+"use strict";
+// Methods meant to work with BDK defined within the web::bitcoin 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.quoteSwapFeeSats = exports.guessSwapVbytes = exports.feeFromRate = exports.fetchFeeEstimates = exports.bumpFee = exports.drainWallet = exports.getAssetsVault = exports.fundVault = exports.sendSats = exports.getNewAddress = exports.getWalletData = exports.encryptWallet = exports.newWallet = exports.syncWallets = exports.upgradeWallet = exports.decryptWallet = exports.hashPassword = void 0;
+const BMC = __importStar(require("./bitmask_core"));
+const constants_1 = require("./constants");
+const hashPassword = (password) => BMC.hash_password(password);
+exports.hashPassword = hashPassword;
+const decryptWallet = (hash, encryptedDescriptors, seedPassword = "") => __awaiter(void 0, void 0, void 0, function* () {
+    return JSON.parse(yield BMC.decrypt_wallet(hash, encryptedDescriptors, seedPassword));
+});
+exports.decryptWallet = decryptWallet;
+const upgradeWallet = (hash, encryptedDescriptors, seedPassword = "") => __awaiter(void 0, void 0, void 0, function* () {
+    return JSON.parse(yield BMC.upgrade_wallet(hash, encryptedDescriptors, seedPassword));
+});
+exports.upgradeWallet = upgradeWallet;
+const syncWallets = () => __awaiter(void 0, void 0, void 0, function* () { return BMC.sync_wallets(); });
+exports.syncWallets = syncWallets;
+const newWallet = (hash, seedPassword) => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(yield BMC.new_wallet(hash, seedPassword)); });
+exports.newWallet = newWallet;
+const encryptWallet = (mnemonic, hash, seedPassword) => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(yield BMC.encrypt_wallet(mnemonic, hash, seedPassword)); });
+exports.encryptWallet = encryptWallet;
+const getWalletData = (descriptor, changeDescriptor) => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(yield BMC.get_wallet_data(descriptor, changeDescriptor)); });
+exports.getWalletData = getWalletData;
+const getNewAddress = (descriptor, changeDescriptor) => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(yield BMC.get_new_address(descriptor, changeDescriptor)); });
+exports.getNewAddress = getNewAddress;
+const sendSats = (descriptor, changeDescriptor, address, amount, broadcast, feeRate) => __awaiter(void 0, void 0, void 0, function* () {
+    return JSON.parse(yield BMC.send_sats(descriptor, changeDescriptor, address, amount, broadcast, feeRate));
+});
+exports.sendSats = sendSats;
+const fundVault = (descriptor, changeDescriptor, rgbAddress, broadcast, feeRate) => __awaiter(void 0, void 0, void 0, function* () {
+    return JSON.parse(yield BMC.fund_vault(descriptor, changeDescriptor, rgbAddress, broadcast, feeRate));
+});
+exports.fundVault = fundVault;
+const getAssetsVault = (rgbDescriptorXpub) => __awaiter(void 0, void 0, void 0, function* () { return JSON.parse(yield BMC.get_assets_vault(rgbDescriptorXpub)); });
+exports.getAssetsVault = getAssetsVault;
+const drainWallet = (destination, descriptor, changeDescriptor, feeRate) => __awaiter(void 0, void 0, void 0, function* () {
+    return JSON.parse(yield BMC.drain_wallet(destination, descriptor, changeDescriptor, feeRate));
+});
+exports.drainWallet = drainWallet;
+const bumpFee = (txid, feeRate, broadcast, descriptor, changeDescriptor) => __awaiter(void 0, void 0, void 0, function* () {
+    return JSON.parse(yield BMC.bump_fee(txid, feeRate, descriptor, changeDescriptor, broadcast));
+});
+exports.bumpFee = bumpFee;
+function fetchFeeEstimates() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const net = yield (0, constants_1.getNetwork)();
+        let envKey;
+        switch (net) {
+            case "bitcoin":
+                envKey = "BITCOIN_EXPLORER_API_MAINNET";
+                break;
+            case "testnet":
+                envKey = "BITCOIN_EXPLORER_API_TESTNET";
+                break;
+            case "signet":
+                envKey = "BITCOIN_EXPLORER_API_SIGNET";
+                break;
+            case "regtest":
+                envKey = "BITCOIN_EXPLORER_API_REGTEST";
+                break;
+            default:
+                // Fallback to signet if unknown string is returned
+                envKey = "BITCOIN_EXPLORER_API_SIGNET";
+                break;
+        }
+        const base = yield (0, constants_1.getEnv)(envKey);
+        if (!base) {
+            throw new Error(`fee-estimates: missing env ${envKey} for network ${net}`);
+        }
+        const baseUrl = (base || "").replace(/\/$/, "");
+        const url = `${baseUrl}/fee-estimates`;
+        const resp = yield fetch(url, { method: "GET" });
+        if (!resp.ok) {
+            const text = yield resp.text().catch(() => "");
+            throw new Error(`fee-estimates fetch failed ${resp.status}: ${text}`);
+        }
+        return (yield resp.json());
+    });
+}
+exports.fetchFeeEstimates = fetchFeeEstimates;
+function feeFromRate(vbytes, satPerVb) {
+    return Math.ceil(vbytes * satPerVb);
+}
+exports.feeFromRate = feeFromRate;
+/**
+ * Rough vbytes guesser for swap/bid PSBTs when you don't yet know exact inputs/outputs.
+ * Prefer passing a conservative bound to avoid underpaying relays:
+ * - Default assumes ~2 inputs, ~3 outputs, taproot heavy mix, returns ~400 vB.
+ * - Scale linearly for more inputs/outputs.
+ *
+ * If you know inputs/outputs counts beforehand, pass them to tighten the estimate.
+ */
+function guessSwapVbytes(inputs = 2, outputs = 3, taprootHeavy = true) {
+    // Heuristic base (conservative): taproot-heavy ~180 vB per input, ~34 vB per output, +10 overhead
+    // Non-taproot may be slightly bigger; this errs on the safe side.
+    const perIn = taprootHeavy ? 180 : 200;
+    const perOut = 34;
+    const overhead = 10;
+    // Ensure a floor to avoid extremely small estimates in edge cases
+    const est = inputs * perIn + outputs * perOut + overhead;
+    return Math.max(est, 300);
+}
+exports.guessSwapVbytes = guessSwapVbytes;
+/**
+ * Convenience: get a safe absolute fee quote for a swap given a target confirmation bucket.
+ * - bucket can be "1","2","3","6","144", etc., matching Esplora keys.
+ * - vbytesEstimate can be computed via guessSwapVbytes() or a tighter UI estimate.
+ * - Adds a small 10% safety margin on the feerate to reduce min-relay rejections.
+ */
+function quoteSwapFeeSats(bucket, vbytesEstimate) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const estimates = yield fetchFeeEstimates();
+        const satPerVb = (_b = (_a = estimates[bucket]) !== null && _a !== void 0 ? _a : estimates["6"]) !== null && _b !== void 0 ? _b : 1.0;
+        const paddedRate = Math.max(1.0, satPerVb * 1.1); // 10% headroom
+        const fee = feeFromRate(vbytesEstimate, paddedRate);
+        return { rate: paddedRate, fee };
+    });
+}
+exports.quoteSwapFeeSats = quoteSwapFeeSats;

package/bitcoin.ts

@@ -0,0 +1,317 @@
+// Methods meant to work with BDK defined within the web::bitcoin module from bitmask-core:
+// https://github.com/diba-io/bitmask-core/blob/development/src/web.rs
+
+import * as BMC from "./bitmask_core";
+import { getEnv, getNetwork, Network } from "./constants";
+
+export const hashPassword = (password: string) => BMC.hash_password(password);
+
+export const decryptWallet = async (
+  hash: string,
+  encryptedDescriptors: string,
+  seedPassword = ""
+): Promise<Vault> =>
+  JSON.parse(
+    await BMC.decrypt_wallet(hash, encryptedDescriptors, seedPassword)
+  );
+
+export const upgradeWallet = async (
+  hash: string,
+  encryptedDescriptors: string,
+  seedPassword = ""
+): Promise<string> =>
+  JSON.parse(
+    await BMC.upgrade_wallet(hash, encryptedDescriptors, seedPassword)
+  );
+
+export const syncWallets = async (): Promise<void> => BMC.sync_wallets();
+
+export const newWallet = async (
+  hash: string,
+  seedPassword: string
+): Promise<string> => JSON.parse(await BMC.new_wallet(hash, seedPassword));
+
+export const encryptWallet = async (
+  mnemonic: string,
+  hash: string,
+  seedPassword: string
+): Promise<string> =>
+  JSON.parse(await BMC.encrypt_wallet(mnemonic, hash, seedPassword));
+
+export const getWalletData = async (
+  descriptor: string,
+  changeDescriptor?: string
+): Promise<WalletData> =>
+  JSON.parse(await BMC.get_wallet_data(descriptor, changeDescriptor));
+
+export const getNewAddress = async (
+  descriptor: string,
+  changeDescriptor?: string
+): Promise<string> =>
+  JSON.parse(await BMC.get_new_address(descriptor, changeDescriptor));
+
+export const sendSats = async (
+  descriptor: string,
+  changeDescriptor: string,
+  address: string,
+  amount: bigint,
+  broadcast: boolean,
+  feeRate: number
+): Promise<TransactionData> =>
+  JSON.parse(
+    await BMC.send_sats(
+      descriptor,
+      changeDescriptor,
+      address,
+      amount,
+      broadcast,
+      feeRate
+    )
+  );
+
+export const fundVault = async (
+  descriptor: string,
+  changeDescriptor: string,
+  rgbAddress: string,
+  broadcast: boolean,
+  feeRate?: number
+): Promise<FundVaultDetails> =>
+  JSON.parse(
+    await BMC.fund_vault(
+      descriptor,
+      changeDescriptor,
+      rgbAddress,
+      broadcast,
+      feeRate
+    )
+  );
+
+export const getAssetsVault = async (
+  rgbDescriptorXpub: string
+): Promise<FundVaultDetails> =>
+  JSON.parse(await BMC.get_assets_vault(rgbDescriptorXpub));
+
+export const drainWallet = async (
+  destination: string,
+  descriptor: string,
+  changeDescriptor?: string,
+  feeRate?: number
+): Promise<TransactionData> =>
+  JSON.parse(
+    await BMC.drain_wallet(destination, descriptor, changeDescriptor, feeRate)
+  );
+
+export const bumpFee = async (
+  txid: string,
+  feeRate: number,
+  broadcast: boolean,
+  descriptor: string,
+  changeDescriptor?: string
+): Promise<TransactionData> =>
+  JSON.parse(
+    await BMC.bump_fee(txid, feeRate, descriptor, changeDescriptor, broadcast)
+  );
+
+// Core type interfaces based on structs defined within the bitmask-core Rust crate:
+// https://github.com/diba-io/bitmask-core/blob/development/src/structs.rs
+
+export interface PrivateWalletData {
+  xprvkh: string;
+  btcDescriptorXprv: string;
+  btcChangeDescriptorXprv: string;
+  rgbDescriptorXprv: string;
+  nostrPrv: string;
+  nostrNsec: string;
+}
+
+export interface PublicWalletData {
+  xpubkh: string;
+  btcDescriptorXpub: string;
+  btcChangeDescriptorXpub: string;
+  rgbDescriptorXpub: string;
+  nostrPub: string;
+  nostrNpub: string;
+}
+
+export interface Vault {
+  mnemonic: string;
+  private: PrivateWalletData;
+  public: PublicWalletData;
+}
+
+export interface Transaction extends WalletTransaction {
+  amount: number;
+  asset?: string;
+  assetType: string;
+  fee: number;
+  message?: string;
+  note?: string;
+}
+
+export interface Activity extends Transaction {
+  id: string;
+  date: number;
+  action: string;
+  status: string;
+  lightning?: boolean;
+  sender?: {
+    name: string;
+    address: string;
+  };
+  recipient?: {
+    name: string;
+    address: string;
+    invoice: string;
+  };
+}
+
+export interface TransactionDetails extends Transaction {
+  sender: {
+    name: string;
+    address: string;
+  };
+  recipient: {
+    name: string;
+    address: string;
+    invoice: string;
+  };
+}
+
+export interface TransactionData {
+  details: TransactionDataDetails;
+  vsize: number;
+  feeRate: number;
+}
+
+export interface TransactionDataDetails {
+  transaction?: Transaction;
+  txid: string;
+  received: number;
+  sent: number;
+  fee: number;
+  confirmationTime?: ConfirmationTime;
+  confirmed?: boolean;
+}
+
+export interface ConfirmationTime {
+  height: number;
+  timestamp: number;
+}
+
+export interface WalletTransaction {
+  txid: string;
+  received: number;
+  sent: number;
+  fee: number;
+  confirmed: boolean;
+  confirmationTime: ConfirmationTime;
+  vsize: number;
+  feeRate: number;
+}
+
+export interface WalletBalance {
+  immature: number;
+  trustedPending: number;
+  untrustedPending: number;
+  confirmed: number;
+}
+
+export interface WalletData {
+  wallet?: string;
+  name: string;
+  address: string;
+  balance: WalletBalance;
+  transactions: WalletTransaction[];
+  utxos: string[];
+}
+
+export interface FundVaultDetails {
+  rgbOutput?: string;
+  isFunded: boolean;
+  fundTxid?: string;
+  fundFee?: number;
+}
+
+export type FeeEstimates = Record<string, number>;
+
+export async function fetchFeeEstimates(): Promise<FeeEstimates> {
+  const net = await getNetwork();
+
+  let envKey: string;
+  switch (net) {
+    case "bitcoin":
+      envKey = "BITCOIN_EXPLORER_API_MAINNET";
+      break;
+    case "testnet":
+      envKey = "BITCOIN_EXPLORER_API_TESTNET";
+      break;
+    case "signet":
+      envKey = "BITCOIN_EXPLORER_API_SIGNET";
+      break;
+    case "regtest":
+      envKey = "BITCOIN_EXPLORER_API_REGTEST";
+      break;
+    default:
+      // Fallback to signet if unknown string is returned
+      envKey = "BITCOIN_EXPLORER_API_SIGNET";
+      break;
+  }
+
+  const base = await getEnv(envKey);
+  if (!base) {
+    throw new Error(`fee-estimates: missing env ${envKey} for network ${net}`);
+  }
+
+  const baseUrl = (base || "").replace(/\/$/, "");
+  const url = `${baseUrl}/fee-estimates`;
+  const resp = await fetch(url, { method: "GET" });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    throw new Error(`fee-estimates fetch failed ${resp.status}: ${text}`);
+  }
+  return (await resp.json()) as FeeEstimates;
+}
+
+export function feeFromRate(vbytes: number, satPerVb: number): number {
+  return Math.ceil(vbytes * satPerVb);
+}
+
+/**
+ * Rough vbytes guesser for swap/bid PSBTs when you don't yet know exact inputs/outputs.
+ * Prefer passing a conservative bound to avoid underpaying relays:
+ * - Default assumes ~2 inputs, ~3 outputs, taproot heavy mix, returns ~400 vB.
+ * - Scale linearly for more inputs/outputs.
+ *
+ * If you know inputs/outputs counts beforehand, pass them to tighten the estimate.
+ */
+export function guessSwapVbytes(
+  inputs = 2,
+  outputs = 3,
+  taprootHeavy = true
+): number {
+  // Heuristic base (conservative): taproot-heavy ~180 vB per input, ~34 vB per output, +10 overhead
+  // Non-taproot may be slightly bigger; this errs on the safe side.
+  const perIn = taprootHeavy ? 180 : 200;
+  const perOut = 34;
+  const overhead = 10;
+  // Ensure a floor to avoid extremely small estimates in edge cases
+  const est = inputs * perIn + outputs * perOut + overhead;
+  return Math.max(est, 300);
+}
+
+/**
+ * Convenience: get a safe absolute fee quote for a swap given a target confirmation bucket.
+ * - bucket can be "1","2","3","6","144", etc., matching Esplora keys.
+ * - vbytesEstimate can be computed via guessSwapVbytes() or a tighter UI estimate.
+ * - Adds a small 10% safety margin on the feerate to reduce min-relay rejections.
+ */
+export async function quoteSwapFeeSats(
+  bucket: string,
+  vbytesEstimate: number
+): Promise<{ rate: number; fee: number }> {
+  const estimates = await fetchFeeEstimates();
+  const satPerVb = estimates[bucket] ?? estimates["6"] ?? 1.0;
+  const paddedRate = Math.max(1.0, satPerVb * 1.1); // 10% headroom
+  const fee = feeFromRate(vbytesEstimate, paddedRate);
+  return { rate: paddedRate, fee };
+}

package/bitmask_core.js

@@ -2256,19 +2256,19 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper11530 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper11536 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 2666, __wbg_adapter_60);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper15959 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper15965 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 3826, __wbg_adapter_63);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper7697 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper7702 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 1856, __wbg_adapter_54);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper8145 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper8151 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 1998, __wbg_adapter_57);
         return ret;
     };

package/bp.d.ts

@@ -0,0 +1,28 @@
+import { FundVaultDetails, TransactionDataDetails, WalletTransaction } from "./bitcoin";
+export declare const transferBtc: (nostrHexSk: string, address: string, sats: bigint, feeRate: number, secrets: string[]) => Promise<TransactionData>;
+export declare const fundRgbVault: (nostrHexSk: string, feeRate: number, secrets: string[], broadcast: boolean, fundValue?: bigint | null, coordinatorFee?: boolean | null) => Promise<FundVaultDetails>;
+export declare const backupBtcWallet: (nostrHexSk: string) => Promise<boolean>;
+export declare const restoreBtcWallet: (nostrHexSk: string) => Promise<boolean>;
+export declare const recoverFundsFromBadWallets: (seed: string, passPhrase: string, recoverAddress: string) => Promise<RecoverVaultDetails>;
+export declare const getBtcWallet: (nostrHexSk: string) => Promise<WalletData>;
+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;
+}
+//# sourceMappingURL=bp.d.ts.map