@qrkit/core 0.3.2 → 0.4.1

package/README.md

@@ -2,7 +2,7 @@
 
 Framework-agnostic protocol core for QR-based airgapped wallet flows. Designed for use in browser-based dApps.
 
-Handles the ERC-4527 / UR / CBOR stack: decoding scanned QR exports, deriving EVM addresses, building sign requests, and parsing signature responses. No DOM, no React, no external services.
+Handles the ERC-4527 / UR / CBOR stack: decoding scanned QR exports, deriving EVM and BTC addresses, building sign requests, carrying PSBTs, and parsing signature responses. No DOM, no React, no external services.
 
 ## Install
 
@@ -14,41 +14,50 @@ pnpm add @qrkit/core
 
 ### 1. Parse the connection QR from the wallet
 
-Scan the `crypto-hdkey` or `crypto-account` QR exported by the hardware wallet, then derive the EVM account:
+Scan the `crypto-hdkey`, `crypto-account`, or `crypto-multi-accounts` QR exported by the hardware wallet, then derive the accounts you need:
 
 ```ts
-import { parseConnection } from '@qrkit/core'
+import { parseConnection } from "@qrkit/core";
 
 // scannedUR comes from a QR scanner — { type: string, cbor: Uint8Array }
-const [account] = parseConnection(scannedUR, { chains: ['evm'] })
-
-account.address          // EIP-55 checksummed address
-account.publicKey        // compressed pubkey hex
-account.sourceFingerprint // master key fingerprint — required for signing
+const accounts = parseConnection(scannedUR, { chains: ["evm", "btc"] });
+const evm = accounts.find((account) => account.chain === "evm");
+const btc = accounts.find((account) => account.chain === "btc");
+
+evm?.address; // EIP-55 checksummed address
+btc?.address; // BTC address, e.g. bc1q...
+btc?.scriptType; // 'p2wpkh' | 'p2sh-p2wpkh' | 'p2pkh'
+evm?.sourceFingerprint; // master key fingerprint — required for signing
 ```
 
-### 2. Build a sign request
+`parseConnection()` can return multiple accounts from one scan, including mixed EVM and BTC results from `crypto-multi-accounts`.
+
+### 2. Build an EVM sign request
 
 Encode a message as animated UR parts to display as a QR code for the wallet to scan:
 
 ```ts
-import { buildEthSignRequestURParts, buildEthSignRequestUR, EthDataType } from '@qrkit/core'
+import {
+  buildEthSignRequestURParts,
+  buildEthSignRequestUR,
+  EthDataType,
+} from "@qrkit/core";
 
 // Animated QR (multiple parts for long messages)
 const parts = buildEthSignRequestURParts({
-  signData: message,            // string (UTF-8 encoded) or Uint8Array (raw bytes)
+  signData: message, // string (UTF-8 encoded) or Uint8Array (raw bytes)
   dataType: EthDataType.PersonalMessage, // defaults to PersonalMessage if omitted
-  address: account.address,
-  sourceFingerprint: account.sourceFingerprint,
-})
+  address: evm.address,
+  sourceFingerprint: evm.sourceFingerprint,
+});
 // parts is string[] — cycle through them to animate the QR
 
 // Single-frame QR (short messages)
 const ur = buildEthSignRequestUR({
   signData: message,
-  address: account.address,
-  sourceFingerprint: account.sourceFingerprint,
-})
+  address: evm.address,
+  sourceFingerprint: evm.sourceFingerprint,
+});
 ```
 
 ### 3. Parse the wallet's signature response
@@ -56,21 +65,72 @@ const ur = buildEthSignRequestUR({
 After the user scans the wallet's response QR, decode the signature:
 
 ```ts
-import { parseEthSignature } from '@qrkit/core'
+import { parseEthSignature } from "@qrkit/core";
 
-const signature = parseEthSignature(scannedResponseUR)
+const signature = parseEthSignature(scannedResponseUR);
 // → '0x...' hex string, ready for ethers / viem
 ```
 
+### 4. Build a BTC message sign request
+
+Direct BTC message signing uses `btc-sign-request` and returns `btc-signature`:
+
+```ts
+import { buildBtcSignRequestURParts, parseBtcSignature } from "@qrkit/core";
+
+const parts = buildBtcSignRequestURParts({
+  signData: "Hello Bitcoin",
+  address: btc.address,
+  scriptType: btc.scriptType,
+  sourceFingerprint: btc.sourceFingerprint,
+});
+
+const result = parseBtcSignature(scannedResponseUR);
+result.signature; // base64 compact Bitcoin message signature (65 bytes)
+result.publicKey; // compressed public key hex
+```
+
+### 5. Carry a BTC PSBT
+
+Bitcoin transaction signing, and BIP-322-style message signing, use `crypto-psbt`.
+qrkit carries PSBT bytes over QR; the airgapped wallet signs offline and returns a signed `crypto-psbt`.
+
+```ts
+import { buildCryptoPsbtURParts, parseCryptoPsbt } from "@qrkit/core";
+
+const parts = buildCryptoPsbtURParts(unsignedPsbtHex);
+// render parts as QR codes
+
+const signed = parseCryptoPsbt(scannedResponseUR);
+signed.psbtHex; // signed PSBT hex
+```
+
+Note: BIP-322-style message signing is also carried as `crypto-psbt`, but wallet review UX varies. Some wallets present it as a Bitcoin message flow, while others show only the proving address or a generic PSBT review.
+
 ## API
 
-| Export | Description |
-|---|---|
-| `parseConnection(ur, options)` | Parse a `crypto-hdkey` or `crypto-account` UR into `Account[]` |
-| `buildEthSignRequestURParts(params)` | Build animated UR parts for a sign request (`EthSignRequestParams`) |
-| `buildEthSignRequestUR(params)` | Build a single-frame UR for a sign request (`EthSignRequestParams`) |
-| `EthDataType` | Constants for ERC-4527 data types (1–4) |
-| `parseEthSignature(ur)` | Decode an `eth-signature` UR into a `0x...` hex string |
+| Export                               | Description                                                                     |
+| ------------------------------------ | ------------------------------------------------------------------------------- |
+| `parseConnection(ur, options)`       | Parse a connection UR into `Account[]`                                          |
+| `buildEthSignRequestURParts(params)` | Build animated UR parts for a sign request (`EthSignRequestParams`)             |
+| `buildEthSignRequestUR(params)`      | Build a single-frame UR for a sign request (`EthSignRequestParams`)             |
+| `EthDataType`                        | Constants for ERC-4527 data types (1–4)                                         |
+| `parseEthSignature(ur)`              | Decode an `eth-signature` UR into a `0x...` hex string                          |
+| `buildBtcSignRequestURParts(params)` | Build animated UR parts for a BTC message sign request (`BtcSignRequestParams`) |
+| `buildBtcSignRequestUR(params)`      | Build a single-frame BTC message sign request UR                                |
+| `BtcDataType`                        | Constants for BTC sign request data types                                       |
+| `parseBtcSignature(ur)`              | Decode a `btc-signature` UR into a base64 signature and public key              |
+| `buildCryptoPsbtURParts(psbt)`       | Build animated UR parts for a `crypto-psbt` request                             |
+| `buildCryptoPsbtUR(psbt)`            | Build a single-frame `crypto-psbt` UR                                           |
+| `parseCryptoPsbt(ur)`                | Decode a `crypto-psbt` UR into PSBT bytes and hex                               |
+
+## Examples
+
+```sh
+pnpm --filter @qrkit/core example:eth
+pnpm --filter @qrkit/core example:btc-message
+pnpm --filter @qrkit/core example:btc-psbt
+```
 
 ## License
 

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,27 +15,156 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BtcDataType: () => BtcDataType,
   EthDataType: () => EthDataType,
+  buildBtcSignRequestUR: () => buildBtcSignRequestUR,
+  buildBtcSignRequestURParts: () => buildBtcSignRequestURParts,
+  buildCryptoPsbtUR: () => buildCryptoPsbtUR,
+  buildCryptoPsbtURParts: () => buildCryptoPsbtURParts,
   buildEthSignRequestUR: () => buildEthSignRequestUR,
   buildEthSignRequestURParts: () => buildEthSignRequestURParts,
+  parseBtcSignature: () => parseBtcSignature,
   parseConnection: () => parseConnection,
+  parseCryptoPsbt: () => parseCryptoPsbt,
   parseEthSignature: () => parseEthSignature
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/btc/address.ts
+var import_base = require("@scure/base");
+var import_legacy = require("@noble/hashes/legacy.js");
+var import_sha2 = require("@noble/hashes/sha2.js");
+var base58check = (0, import_base.createBase58check)(import_sha2.sha256);
+function hash160(bytes) {
+  return (0, import_legacy.ripemd160)((0, import_sha2.sha256)(bytes));
+}
+function pubKeyToP2wpkh(compressedPubKey) {
+  const h = hash160(compressedPubKey);
+  const words = import_base.bech32.toWords(h);
+  return import_base.bech32.encode("bc", [0, ...words]);
+}
+function pubKeyToP2shP2wpkh(compressedPubKey) {
+  const h = hash160(compressedPubKey);
+  const redeemScript = new Uint8Array(22);
+  redeemScript[0] = 0;
+  redeemScript[1] = 20;
+  redeemScript.set(h, 2);
+  const scriptHash = hash160(redeemScript);
+  const payload = new Uint8Array(21);
+  payload[0] = 5;
+  payload.set(scriptHash, 1);
+  return base58check.encode(payload);
+}
+function pubKeyToP2pkh(compressedPubKey) {
+  const h = hash160(compressedPubKey);
+  const payload = new Uint8Array(21);
+  payload[0] = 0;
+  payload.set(h, 1);
+  return base58check.encode(payload);
+}
+
+// src/bytes.ts
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function bytesToHex(bytes) {
+  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(hex) {
+  const normalized = hex.trim().replace(/^0x/i, "");
+  if (normalized.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(normalized)) {
+    throw new Error("Invalid hex string");
+  }
+  return new Uint8Array(
+    normalized.match(/.{2}/g)?.map((byte) => parseInt(byte, 16)) ?? []
+  );
+}
+
+// src/btc/deriveAccount.ts
+function firstChild(accountKey) {
+  return accountKey.deriveChild(0).deriveChild(0);
+}
+function scriptTypeFromPurpose(purpose) {
+  if (purpose === 84) return "p2wpkh";
+  if (purpose === 49) return "p2sh-p2wpkh";
+  if (purpose === 44) return "p2pkh";
+  return void 0;
+}
+function deriveAddress(pubKey, scriptType) {
+  if (scriptType === "p2wpkh") return pubKeyToP2wpkh(pubKey);
+  if (scriptType === "p2sh-p2wpkh") return pubKeyToP2shP2wpkh(pubKey);
+  return pubKeyToP2pkh(pubKey);
+}
+function deriveBtcAccount(parsed) {
+  const results = [];
+  for (const entry of parsed) {
+    const { hdKey, purpose, coinType, sourceFingerprint, name } = entry;
+    if (coinType !== 0) continue;
+    const scriptType = scriptTypeFromPurpose(purpose);
+    if (!scriptType) continue;
+    const child = firstChild(hdKey);
+    if (!child.publicKey) continue;
+    results.push({
+      address: deriveAddress(child.publicKey, scriptType),
+      scriptType,
+      publicKey: bytesToHex(child.publicKey),
+      sourceFingerprint,
+      device: name
+    });
+  }
+  return results;
+}
+
+// src/eth/address.ts
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_sha3 = require("@noble/hashes/sha3.js");
+function pubKeyToEthAddress(compressedPubKey) {
+  const pubKeyHex = [...compressedPubKey].map((b) => b.toString(16).padStart(2, "0")).join("");
+  const uncompressed = import_secp256k1.secp256k1.Point.fromHex(pubKeyHex).toBytes(false);
+  const hash = (0, import_sha3.keccak_256)(uncompressed.slice(1));
+  const hex = [...hash.slice(12)].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return toChecksumAddress(hex);
+}
+function toChecksumAddress(hex) {
+  const checksumHash = (0, import_sha3.keccak_256)(new TextEncoder().encode(hex));
+  return "0x" + [...hex].map((c, i) => {
+    if (c >= "0" && c <= "9") return c;
+    const nibble = i % 2 === 0 ? checksumHash[Math.floor(i / 2)] >> 4 & 15 : checksumHash[Math.floor(i / 2)] & 15;
+    return nibble >= 8 ? c.toUpperCase() : c.toLowerCase();
+  }).join("");
+}
+
+// src/eth/deriveAccount.ts
+function firstChild2(accountKey) {
+  return accountKey.deriveChild(0).deriveChild(0);
+}
+function deriveEvmAccount(parsed) {
+  const results = [];
+  for (const entry of parsed) {
+    const { hdKey, purpose, coinType, type, sourceFingerprint, name } = entry;
+    const isEvm = purpose === 44 && coinType === 60 || purpose === void 0 && type === "xpub";
+    if (!isEvm) continue;
+    const child = firstChild2(hdKey);
+    if (!child.publicKey) continue;
+    results.push({
+      address: pubKeyToEthAddress(child.publicKey),
+      publicKey: bytesToHex(child.publicKey),
+      sourceFingerprint,
+      device: name
+    });
+  }
+  return results;
+}
+
 // src/parseXpub.ts
 var import_bip32 = require("@scure/bip32");
 var import_cborg = require("cborg");
@@ -45,23 +172,46 @@ function get(m, k) {
   if (m instanceof Map) return m.get(k);
   return void 0;
 }
+function bytesFromCbor(value) {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof Map && value.get("type") === "Buffer") {
+    const data = value.get("data");
+    if (Array.isArray(data) && data.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+      return new Uint8Array(data);
+    }
+  }
+  return void 0;
+}
 var passthrough = (v) => v;
 function decodeCbor(cbor) {
+  const tags = new Proxy([], {
+    get(target, property, receiver) {
+      if (typeof property === "string" && /^\d+$/.test(property)) {
+        return passthrough;
+      }
+      return Reflect.get(target, property, receiver);
+    }
+  });
   return (0, import_cborg.decode)(cbor, {
     useMaps: true,
-    tags: Object.assign([], {
-      303: passthrough,
-      // crypto-hdkey
-      304: passthrough,
-      // crypto-keypath
-      305: passthrough
-      // crypto-coin-info
-    })
+    tags
   });
 }
-function parseCryptoHdKey(map, raw) {
-  const keyData = get(map, 3);
-  const chainCode = get(map, 4);
+function isCborMap(value) {
+  return value instanceof Map;
+}
+function assertCryptoHdKeyShape(value) {
+  if (!isCborMap(value)) {
+    throw new Error("crypto-hdkey entry must be a CBOR map");
+  }
+  if (!value.has(3) || !value.has(4)) {
+    throw new Error("crypto-hdkey missing key-data or chain-code");
+  }
+  return value;
+}
+function parseCryptoHdKey(map, raw, fallbackName) {
+  const keyData = bytesFromCbor(get(map, 3));
+  const chainCode = bytesFromCbor(get(map, 4));
   if (!keyData || !chainCode) {
     throw new Error("crypto-hdkey missing key-data or chain-code");
   }
@@ -77,25 +227,28 @@ function parseCryptoHdKey(map, raw) {
     }
     sourceFingerprint = get(origin, 2);
   }
-  const name = get(map, 9);
+  const name = get(map, 9) ?? fallbackName;
   const hdKey = new import_bip32.HDKey({ publicKey: keyData, chainCode });
   return { hdKey, type: "xpub", purpose, coinType, sourceFingerprint, name, raw };
 }
 function parseScannedUR(scanned) {
   const { type, cbor } = scanned;
   const raw = `ur:${type}`;
-  if (type !== "crypto-hdkey" && type !== "crypto-account") {
+  if (type !== "crypto-hdkey" && type !== "crypto-account" && type !== "crypto-multi-accounts") {
     throw new Error(`Unsupported UR type: ${type}`);
   }
   const map = decodeCbor(cbor);
   if (type === "crypto-hdkey") {
-    return parseCryptoHdKey(map, raw);
+    return parseCryptoHdKey(assertCryptoHdKeyShape(map), raw);
   }
   const accounts = map.get(2);
   if (!Array.isArray(accounts) || accounts.length === 0) {
-    throw new Error("crypto-account contains no keys");
+    throw new Error(`${type} contains no keys`);
   }
-  return accounts.map((entry) => parseCryptoHdKey(entry, raw));
+  const fallbackName = type === "crypto-multi-accounts" ? map.get(3) : void 0;
+  return accounts.map(
+    (entry) => parseCryptoHdKey(assertCryptoHdKeyShape(entry), raw, fallbackName)
+  );
 }
 function parseXpub(input) {
   if (typeof input !== "string") {
@@ -115,48 +268,6 @@ function parseXpub(input) {
   ];
 }
 
-// src/eth/address.ts
-var import_sha3 = require("@noble/hashes/sha3.js");
-var secp = __toESM(require("@noble/secp256k1"), 1);
-function pubKeyToEthAddress(compressedPubKey) {
-  const uncompressed = secp.Point.fromBytes(compressedPubKey).toBytes(false);
-  const hash = (0, import_sha3.keccak_256)(uncompressed.slice(1));
-  const hex = [...hash.slice(12)].map((b) => b.toString(16).padStart(2, "0")).join("");
-  return toChecksumAddress(hex);
-}
-function toChecksumAddress(hex) {
-  const checksumHash = (0, import_sha3.keccak_256)(new TextEncoder().encode(hex));
-  return "0x" + [...hex].map((c, i) => {
-    if (c >= "0" && c <= "9") return c;
-    const nibble = i % 2 === 0 ? checksumHash[Math.floor(i / 2)] >> 4 & 15 : checksumHash[Math.floor(i / 2)] & 15;
-    return nibble >= 8 ? c.toUpperCase() : c.toLowerCase();
-  }).join("");
-}
-
-// src/eth/deriveAccount.ts
-function firstChild(accountKey) {
-  return accountKey.deriveChild(0).deriveChild(0);
-}
-function toHex(bytes) {
-  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function deriveEvmAccount(parsed) {
-  for (const entry of parsed) {
-    const { hdKey, purpose, coinType, type, sourceFingerprint, name } = entry;
-    const isEvm = purpose === 44 && coinType === 60 || purpose === void 0 && type === "xpub";
-    if (!isEvm) continue;
-    const child = firstChild(hdKey);
-    if (!child.publicKey) continue;
-    return {
-      address: pubKeyToEthAddress(child.publicKey),
-      publicKey: toHex(child.publicKey),
-      sourceFingerprint,
-      device: name
-    };
-  }
-  return void 0;
-}
-
 // src/parseConnection.ts
 var ALL_CHAINS = ["evm", "btc"];
 function parseConnection(scannedUR, config = {}) {
@@ -164,11 +275,15 @@ function parseConnection(scannedUR, config = {}) {
   const parsed = parseXpub(scannedUR);
   const accounts = [];
   if (chains.includes("evm")) {
-    const account = deriveEvmAccount(parsed);
-    if (account) {
+    for (const account of deriveEvmAccount(parsed)) {
       accounts.push({ chain: "evm", ...account });
     }
   }
+  if (chains.includes("btc")) {
+    for (const account of deriveBtcAccount(parsed)) {
+      accounts.push({ chain: "btc", ...account });
+    }
+  }
   return accounts;
 }
 
@@ -305,14 +420,132 @@ function parseEthSignature(scanned) {
   if (!sigBytes || sigBytes.length < 64) {
     throw new Error("Invalid or missing signature bytes");
   }
-  return "0x" + [...sigBytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `0x${bytesToHex(sigBytes)}`;
+}
+
+// src/btc/signRequest.ts
+var BtcDataType = {
+  Message: 1
+};
+var TAG_KEYPATH2 = 304;
+var PURPOSE_BY_SCRIPT_TYPE = {
+  p2wpkh: 84,
+  "p2sh-p2wpkh": 49,
+  p2pkh: 44
+};
+function randomBytes2(n) {
+  const buf = new Uint8Array(n);
+  crypto.getRandomValues(buf);
+  return buf;
+}
+function purposeFromScriptType(scriptType) {
+  return PURPOSE_BY_SCRIPT_TYPE[scriptType];
+}
+function buildKeypath2(scriptType, sourceFingerprint) {
+  const purpose = purposeFromScriptType(scriptType);
+  const components = [purpose, true, 0, true, 0, true, 0, false, 0, false];
+  const keypathMap = /* @__PURE__ */ new Map([[1, components]]);
+  if (sourceFingerprint !== void 0) {
+    keypathMap.set(2, sourceFingerprint);
+  }
+  return new CborTag(TAG_KEYPATH2, keypathMap);
+}
+function buildBtcSignRequestCbor(params) {
+  const { signData, address, scriptType, sourceFingerprint, origin = "qrkit" } = params;
+  const requestId = randomBytes2(16);
+  const signBytes = typeof signData === "string" ? new TextEncoder().encode(signData) : signData;
+  const keypath = buildKeypath2(scriptType, sourceFingerprint);
+  return encode(
+    /* @__PURE__ */ new Map([
+      [1, new CborTag(37, requestId)],
+      // request-id: uuid = #6.37(bstr)
+      [2, signBytes],
+      // sign-data
+      [3, BtcDataType.Message],
+      // data-type
+      [4, [keypath]],
+      // btc-derivation-paths
+      [5, [address]],
+      // btc-addresses
+      [6, origin]
+      // origin
+    ])
+  );
+}
+function buildBtcSignRequestURParts(params) {
+  return encodeURParts(buildBtcSignRequestCbor(params), "btc-sign-request");
+}
+function buildBtcSignRequestUR(params) {
+  return encodeURParts(buildBtcSignRequestCbor(params), "btc-sign-request")[0];
+}
+
+// src/btc/signature.ts
+var import_cborg3 = require("cborg");
+function parseBtcSignature(scanned) {
+  if (scanned.type !== "btc-signature") {
+    throw new Error(`Expected btc-signature, got: ${scanned.type}`);
+  }
+  const map = (0, import_cborg3.decode)(scanned.cbor, {
+    useMaps: true,
+    tags: Object.assign([], { 37: (v) => v })
+  });
+  const requestId = map.get(1);
+  const sigBytes = map.get(2);
+  const publicKeyBytes = map.get(3);
+  if (!sigBytes || sigBytes.length !== 65) {
+    throw new Error("Invalid or missing BTC signature bytes");
+  }
+  if (!publicKeyBytes || publicKeyBytes.length !== 33) {
+    throw new Error("Invalid or missing BTC public key bytes");
+  }
+  return {
+    signature: bytesToBase64(sigBytes),
+    publicKey: bytesToHex(publicKeyBytes),
+    requestId: requestId ? bytesToHex(requestId) : void 0
+  };
+}
+
+// src/btc/psbt.ts
+var import_cborg4 = require("cborg");
+function normalizePsbt(psbt) {
+  try {
+    return typeof psbt === "string" ? hexToBytes(psbt) : psbt;
+  } catch (error) {
+    throw new Error("Invalid PSBT hex", { cause: error });
+  }
+}
+function parseCryptoPsbt(scanned) {
+  if (scanned.type !== "crypto-psbt") {
+    throw new Error(`Expected crypto-psbt, got: ${scanned.type}`);
+  }
+  const psbt = (0, import_cborg4.decode)(scanned.cbor);
+  if (!(psbt instanceof Uint8Array)) {
+    throw new Error("Invalid crypto-psbt payload");
+  }
+  return {
+    psbt,
+    psbtHex: bytesToHex(psbt)
+  };
+}
+function buildCryptoPsbtURParts(psbt) {
+  return encodeURParts(encode(normalizePsbt(psbt)), "crypto-psbt");
+}
+function buildCryptoPsbtUR(psbt) {
+  return buildCryptoPsbtURParts(psbt)[0];
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BtcDataType,
   EthDataType,
+  buildBtcSignRequestUR,
+  buildBtcSignRequestURParts,
+  buildCryptoPsbtUR,
+  buildCryptoPsbtURParts,
   buildEthSignRequestUR,
   buildEthSignRequestURParts,
+  parseBtcSignature,
   parseConnection,
+  parseCryptoPsbt,
   parseEthSignature
 });
 //# sourceMappingURL=index.cjs.map