diff --git a/.github/workflows/deploy-pages.yaml b/.github/workflows/deploy-pages.yaml index 159658bdb9b..0be458f6765 100644 --- a/.github/workflows/deploy-pages.yaml +++ b/.github/workflows/deploy-pages.yaml @@ -3,7 +3,7 @@ name: "Deploy to GitHub Pages" on: push: branches: - - gh-pages + - master workflow_dispatch: # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages diff --git a/package-lock.json b/package-lock.json index b41b2d69cf9..1fe58b2b923 100644 --- a/package-lock.json +++ b/package-lock.json @@ -3018,6 +3018,7 @@ "integrity": "sha512-/g2d4sW9nUDJOMz3mabVQvOGhVa4e/BN/Um7yca9Bb2XTzPPnfTWHWQg+IsEYO7M3Vx+EXvaM/I2pJWIMun1bg==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@octokit/auth-token": "^4.0.0", "@octokit/graphql": "^7.1.0", @@ -3396,6 +3397,7 @@ "integrity": "sha512-DhGl4xMVFGVIyMwswXeyzdL4uXD5OGILGX5N8Y+f6W7LhC1Ze2poSNrkF/fedpVDHEEZ+PHFW0vL14I+mm8K3Q==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@octokit/auth-token": "^6.0.0", "@octokit/graphql": "^9.0.3", @@ -3626,6 +3628,7 @@ "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">=12" }, @@ -4748,6 +4751,7 @@ "integrity": "sha512-lJi3PfxVmo0AkEY93ecfN+r8SofEqZNGByvHAI3GBLrvt1Cw6H5k1IM02nSzu0RfUafr2EvFSw0wAsZgubNplQ==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@typescript-eslint/scope-manager": "8.47.0", "@typescript-eslint/types": "8.47.0", @@ -5240,6 +5244,7 @@ "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", "dev": true, "license": "MIT", + "peer": true, "bin": { "acorn": "bin/acorn" }, @@ -5959,6 +5964,7 @@ } ], "license": "MIT", + "peer": true, "dependencies": { "baseline-browser-mapping": "^2.9.0", "caniuse-lite": "^1.0.30001759", @@ -8187,6 +8193,7 @@ "integrity": "sha512-BhHmn2yNOFA9H9JmmIVKJmd288g9hrVRDkdoIgRCRuSySRUHH7r/DI6aAXW9T1WwUuY3DFgrcaqB+deURBLR5g==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.1", @@ -9029,7 +9036,8 @@ "node_modules/fp-ts": { "version": "2.16.9", "resolved": "https://registry.npmjs.org/fp-ts/-/fp-ts-2.16.9.tgz", - "integrity": "sha512-+I2+FnVB+tVaxcYyQkHUq7ZdKScaBlX53A41mxQtpIccsfyv8PzdzP7fzp2AY832T4aoK6UZ5WRX/ebGd8uZuQ==" + "integrity": "sha512-+I2+FnVB+tVaxcYyQkHUq7ZdKScaBlX53A41mxQtpIccsfyv8PzdzP7fzp2AY832T4aoK6UZ5WRX/ebGd8uZuQ==", + "peer": true }, "node_modules/fresh": { "version": "0.5.2", @@ -10488,6 +10496,7 @@ "version": "2.2.21", "resolved": "https://registry.npmjs.org/io-ts/-/io-ts-2.2.21.tgz", "integrity": "sha512-zz2Z69v9ZIC3mMLYWIeoUcwWD6f+O7yP92FMVVaXEOSZH1jnVBmET/urd/uoarD1WGBY4rCj8TAyMPzsGNzMFQ==", + "peer": true, "peerDependencies": { "fp-ts": "^2.5.0" } @@ -12528,6 +12537,7 @@ "integrity": "sha512-8dD6FusOQSrpv9Z1rdNMdlSgQOIP880DHqnohobOmYLElGEqAL/JvxvuxZO16r4HtjTlfPRDC1hbvxC9dPN2nA==", "dev": true, "license": "MIT", + "peer": true, "bin": { "marked": "bin/marked.js" }, @@ -13307,6 +13317,7 @@ "version": "2.3.13", "resolved": "https://registry.npmjs.org/monocle-ts/-/monocle-ts-2.3.13.tgz", "integrity": "sha512-D5Ygd3oulEoAm3KuGO0eeJIrhFf1jlQIoEVV2DYsZUMz42j4tGxgct97Aq68+F8w4w4geEnwFa8HayTS/7lpKQ==", + "peer": true, "peerDependencies": { "fp-ts": "^2.5.0" } @@ -13610,6 +13621,7 @@ "version": "0.3.5", "resolved": "https://registry.npmjs.org/newtype-ts/-/newtype-ts-0.3.5.tgz", "integrity": "sha512-v83UEQMlVR75yf1OUdoSFssjitxzjZlqBAjiGQ4WJaML8Jdc68LJ+BaSAXUmKY4bNzp7hygkKLYTsDi14PxI2g==", + "peer": true, "peerDependencies": { "fp-ts": "^2.0.0", "monocle-ts": "^2.0.0" @@ -16035,6 +16047,7 @@ "dev": true, "inBundle": true, "license": "MIT", + "peer": true, "engines": { "node": ">=12" }, @@ -16186,6 +16199,7 @@ "dev": true, "hasInstallScript": true, "license": "MIT", + "peer": true, "dependencies": { "@napi-rs/wasm-runtime": "0.2.4", "@yarnpkg/lockfile": "^1.1.0", @@ -17505,6 +17519,7 @@ "url": "https://github.com/sponsors/ai" } ], + "peer": true, "dependencies": { "nanoid": "^3.3.7", "picocolors": "^1.0.1", @@ -18605,6 +18620,7 @@ "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", @@ -18677,6 +18693,7 @@ "integrity": "sha512-6qGjWccl5yoyugHt3jTgztJ9Y0JVzyH8/Voc/D8PlLat9pwxQYXz7W1Dpnq5h0/G5GCYGUaDSlYcyk3AMh5A6g==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@semantic-release/commit-analyzer": "^13.0.1", "@semantic-release/error": "^4.0.0", @@ -20845,6 +20862,7 @@ "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">=12" }, @@ -21027,7 +21045,8 @@ "version": "2.6.3", "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.3.tgz", "integrity": "sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==", - "dev": true + "dev": true, + "peer": true }, "node_modules/tsx": { "version": "4.20.6", @@ -21180,6 +21199,7 @@ "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", "dev": true, "license": "Apache-2.0", + "peer": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -21551,6 +21571,7 @@ "integrity": "sha512-Qphch25abbMNtekmEGJmeRUhLDbe+QfiWTiqpKYkpCOWY64v9eyl+KRRLmqOFA2AvKPpc9DC6+u2n76tQLBoaA==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@types/eslint-scope": "^3.7.7", "@types/estree": "^1.0.8", @@ -21599,6 +21620,7 @@ "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-5.1.4.tgz", "integrity": "sha512-pIDJHIEI9LR0yxHXQ+Qh95k2EvXpWzZ5l+d+jIo+RdSm9MiHfzazIxwwni/p7+x4eJZuvG1AJwgC4TNQ7NRgsg==", "dev": true, + "peer": true, "dependencies": { "@discoveryjs/json-ext": "^0.5.0", "@webpack-cli/configtest": "^2.1.1", diff --git a/packages/webui/.gitignore b/packages/webui/.gitignore index 849ddff3b7e..2a851e2c33f 100644 --- a/packages/webui/.gitignore +++ b/packages/webui/.gitignore @@ -1 +1,2 @@ dist/ +wasm/ diff --git a/packages/webui/package.json b/packages/webui/package.json index ac86b67d683..9c473603387 100644 --- a/packages/webui/package.json +++ b/packages/webui/package.json @@ -11,10 +11,12 @@ "main": "./dist/src/index.js", "private": true, "scripts": { - "build": "webpack --mode production --progress --config ./webpack.config.js", + "extract-samples": "node scripts/extract-samples.js", + "build:wasm": "bash scripts/build-wasm.sh", + "build": "npm run build:wasm && npm run extract-samples && webpack --mode production --progress --config ./webpack.config.js", "typecheck": "tsc --noEmit", "test": "echo \"Error: no test specified\"", - "dev": "webpack serve --mode development --progress --hot --config ./webpack.config.js", + "dev": "npm run build:wasm && npm run extract-samples && webpack serve --mode development --progress --hot --config ./webpack.config.js", "fmt": "prettier --write .", "check-fmt": "prettier --check '{src,webpack}/**/*.{tsx,ts,js}'", "clean": "rm -r ./dist", diff --git a/packages/webui/scripts/build-wasm.sh b/packages/webui/scripts/build-wasm.sh new file mode 100755 index 00000000000..a345a05c0db --- /dev/null +++ b/packages/webui/scripts/build-wasm.sh @@ -0,0 +1,48 @@ +#!/usr/bin/env bash +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +WEBUI_DIR="$(cd "$SCRIPT_DIR/.." && pwd)" +WASM_UTXO_DIR="$(cd "$WEBUI_DIR/../wasm-utxo" && pwd)" +OUT_DIR="$WEBUI_DIR/wasm" + +# Auto-detect Mac and use Homebrew LLVM for WASM compilation +# Apple's Clang doesn't support wasm32-unknown-unknown target +if [[ "$(uname -s)" == "Darwin" ]]; then + HOMEBREW_LLVM="$(brew --prefix llvm 2>/dev/null || true)" + if [[ -n "$HOMEBREW_LLVM" ]]; then + export CC="$HOMEBREW_LLVM/bin/clang" + export AR="$HOMEBREW_LLVM/bin/llvm-ar" + echo "Using Homebrew LLVM: $HOMEBREW_LLVM" + fi +fi + +echo "Building wasm-utxo with inspect feature..." +rm -rf "$OUT_DIR" +wasm-pack build \ + --no-opt \ + --no-pack \ + --weak-refs \ + "$WASM_UTXO_DIR" \ + --out-dir "$OUT_DIR" \ + --target bundler \ + --features inspect + +echo "Optimizing wasm..." +wasm-opt \ + --enable-bulk-memory \ + --enable-nontrapping-float-to-int \ + --enable-sign-ext \ + -Oz \ + "$OUT_DIR"/wasm_utxo_bg.wasm \ + -o "$OUT_DIR"/wasm_utxo_bg.wasm + +# Remove .gitignore files that wasm-pack generates +find "$OUT_DIR" -name .gitignore -delete + +# Copy .d.ts to wasm-utxo/js/wasm/ so ts-loader (project references) sees inspect types. +# This is safe: js/wasm/ is a build artifact, and the npm publish uses dist/ which is already built. +cp "$OUT_DIR"/wasm_utxo.d.ts "$WASM_UTXO_DIR/js/wasm/" + +echo "wasm build complete: $OUT_DIR" +ls -lh "$OUT_DIR"/*.wasm diff --git a/packages/webui/scripts/extract-samples.js b/packages/webui/scripts/extract-samples.js new file mode 100644 index 00000000000..9330c7e6f82 --- /dev/null +++ b/packages/webui/scripts/extract-samples.js @@ -0,0 +1,130 @@ +#!/usr/bin/env node +/** + * Extract sample PSBT/TX data from fixtures for the parser UI. + * + * This script reads fixture files and extracts: + * - psbtBase64: unsigned or partially signed PSBT + * - psbtBase64Finalized: fully signed PSBT + * - extractedTransaction: raw transaction hex + * + * Usage: node scripts/extract-samples.js + */ + +const fs = require("fs"); +const path = require("path"); + +const FIXTURES_DIR = path.resolve(__dirname, "../src/fixtures/fixed-script"); +const OUTPUT_FILE = path.resolve(__dirname, "../src/wasm-utxo/parser/samples.ts"); + +function extractSamples() { + const samples = []; + + // Read fixture files + const files = fs.readdirSync(FIXTURES_DIR).filter((f) => f.endsWith(".json") && f.startsWith("psbt")); + + for (const file of files) { + const filePath = path.join(FIXTURES_DIR, file); + const content = fs.readFileSync(filePath, "utf-8"); + + let fixture; + try { + fixture = JSON.parse(content); + } catch { + console.warn(`Skipping invalid JSON: ${file}`); + continue; + } + + // Extract name from filename: psbt-lite.bitcoin.unsigned.json -> Bitcoin Lite (unsigned) + const match = file.match(/^psbt(-lite)?\.(\w+)\.(\w+)\.json$/); + if (!match) continue; + + const [, lite, network, state] = match; + const networkName = network.charAt(0).toUpperCase() + network.slice(1); + const stateName = state.charAt(0).toUpperCase() + state.slice(1); + const liteLabel = lite ? " Lite" : ""; + + // Add psbtBase64 (unsigned/halfsigned/fullsigned) + if (fixture.psbtBase64) { + samples.push({ + name: `${networkName}${liteLabel} PSBT (${stateName})`, + type: "psbt", + data: fixture.psbtBase64, + }); + } + + // Add psbtBase64Finalized (from fullsigned files only) + if (fixture.psbtBase64Finalized && state === "fullsigned") { + samples.push({ + name: `${networkName}${liteLabel} PSBT (Finalized)`, + type: "psbt", + data: fixture.psbtBase64Finalized, + }); + } + + // Add extractedTransaction + if (fixture.extractedTransaction) { + samples.push({ + name: `${networkName}${liteLabel} TX (Extracted)`, + type: "tx", + data: fixture.extractedTransaction, + }); + } + } + + // Sort by name + samples.sort((a, b) => a.name.localeCompare(b.name)); + + return samples; +} + +function generateTypeScript(samples) { + const lines = [ + "/**", + " * Sample PSBT/TX data extracted from test fixtures.", + " * Auto-generated by scripts/extract-samples.js", + " * DO NOT EDIT MANUALLY", + " */", + "", + "export interface Sample {", + " name: string;", + ' type: "psbt" | "tx";', + " data: string;", + "}", + "", + "export const samples: Sample[] = [", + ]; + + for (const sample of samples) { + lines.push(" {"); + lines.push(` name: ${JSON.stringify(sample.name)},`); + lines.push(` type: ${JSON.stringify(sample.type)},`); + lines.push(` data: ${JSON.stringify(sample.data)},`); + lines.push(" },"); + } + + lines.push("];"); + lines.push(""); + + return lines.join("\n"); +} + +function main() { + console.log("Extracting samples from fixtures..."); + + const samples = extractSamples(); + console.log(`Found ${samples.length} samples`); + + const typescript = generateTypeScript(samples); + + // Ensure output directory exists + const outputDir = path.dirname(OUTPUT_FILE); + if (!fs.existsSync(outputDir)) { + fs.mkdirSync(outputDir, { recursive: true }); + } + + fs.writeFileSync(OUTPUT_FILE, typescript); + console.log(`Written to ${OUTPUT_FILE}`); +} + +main(); + diff --git a/packages/webui/src/fixtures b/packages/webui/src/fixtures new file mode 120000 index 00000000000..99f860f44c1 --- /dev/null +++ b/packages/webui/src/fixtures @@ -0,0 +1 @@ +../../wasm-utxo/test/fixtures \ No newline at end of file diff --git a/packages/webui/src/index.ts b/packages/webui/src/index.ts index 54d3c9172ee..605f5098c88 100644 --- a/packages/webui/src/index.ts +++ b/packages/webui/src/index.ts @@ -10,6 +10,7 @@ import { initRouter, type Route } from "./lib/router"; // Import demo components (registers them as custom elements) import "./wasm-utxo/addresses"; import "./wasm-solana/transaction"; +import "./wasm-utxo/parser"; // Common styles used across components export const commonStyles = ` @@ -33,6 +34,10 @@ export const commonStyles = ` text-decoration: underline; } + button, input, textarea, select { + font-family: inherit; + } + h1, h2, h3 { margin: 0 0 1rem; font-weight: 500; @@ -119,7 +124,7 @@ class HomePage extends BaseComponent { "div", { class: "home" }, h("h1", {}, "BitGoWASM Demos"), - h("p", { class: "subtitle" }, "Interactive demos for BitGo WASM libraries"), + h("p", { class: "subtitle" }, "Developer tools for BitGoWASM libraries"), h( "ul", { class: "demo-list" }, @@ -137,6 +142,20 @@ class HomePage extends BaseComponent { ), ), ), + h( + "li", + {}, + h( + "a", + { class: "demo-link", href: "#/wasm-utxo/parser" }, + h("div", { class: "demo-title" }, "UTXO PSBT/TX Parser"), + h( + "div", + { class: "demo-desc" }, + "Parse and inspect PSBTs and transactions as collapsible trees", + ), + ), + ), h( "li", {}, @@ -163,6 +182,7 @@ defineComponent("home-page", HomePage); const routes: Route[] = [ { path: "/", component: "home-page" }, { path: "/wasm-utxo/addresses", component: "address-converter" }, + { path: "/wasm-utxo/parser", component: "psbt-tx-parser" }, { path: "/wasm-solana/transaction", component: "solana-transaction-parser" }, ]; diff --git a/packages/webui/src/wasm-utxo/addresses/index.ts b/packages/webui/src/wasm-utxo/addresses/index.ts index dec3ac3d2d0..f3c0376bdb7 100644 --- a/packages/webui/src/wasm-utxo/addresses/index.ts +++ b/packages/webui/src/wasm-utxo/addresses/index.ts @@ -339,6 +339,16 @@ class AddressConverter extends BaseComponent { margin: 0; } + .disclaimer { + padding: 0.75rem 1rem; + background: rgba(207, 172, 83, 0.1); + border: 1px solid rgba(207, 172, 83, 0.4); + border-radius: 6px; + color: var(--warning, #CFAC53); + margin-bottom: 1.5rem; + font-size: 0.875rem; + } + @media (max-width: 768px) { .result-row { grid-template-columns: 1fr auto; @@ -370,6 +380,11 @@ class AddressConverter extends BaseComponent { h("span", {}, "UTXO Address Converter"), ), h("h1", {}, "UTXO Address Converter"), + h( + "div", + { class: "disclaimer" }, + "⚠ Careful: funds sent to addresses of other networks may be lost forever!", + ), h( "section", { class: "input-section" }, @@ -380,6 +395,9 @@ class AddressConverter extends BaseComponent { id: "address-input", placeholder: "Paste a utxo address...", rows: "2", + spellcheck: "false", + autocomplete: "off", + style: "resize: none", oninput: (e: Event) => this.handleInput(e), }), h( diff --git a/packages/webui/src/wasm-utxo/parser/index.ts b/packages/webui/src/wasm-utxo/parser/index.ts new file mode 100644 index 00000000000..d64052bffe0 --- /dev/null +++ b/packages/webui/src/wasm-utxo/parser/index.ts @@ -0,0 +1,1283 @@ +/** + * PSBT/Transaction Parser Demo + * + * Parses PSBTs and transactions and displays them as collapsible trees. + */ + +import { BaseComponent, defineComponent, h, css, fragment, type Child } from "../../lib/html"; +import { setParams } from "../../lib/router"; +import { commonStyles } from "../../index"; +import { + type Node, + type Primitive, + type CoinName, + parsePsbtToNode, + parseTxToNode, + parsePsbtRawToNode, + isInspectEnabled, + tryParsePsbt, + tryParseTx, + tryParsePsbtRaw, + allNetworks, +} from "@bitgo/wasm-utxo/inspect"; +import { samples, type Sample } from "./samples"; + +type ParseMode = "psbt" | "tx" | "psbt-raw"; + +// PSBT magic bytes: "psbt" followed by 0xff +const PSBT_MAGIC = "70736274ff"; + +// Network display names +const networkLabels: Record = { + btc: "Bitcoin", + tbtc: "Bitcoin Testnet", + tbtc4: "Bitcoin Testnet4", + tbtcsig: "Bitcoin Signet", + tbtcbgsig: "Bitcoin BitGo Signet", + ltc: "Litecoin", + tltc: "Litecoin Testnet", + bch: "Bitcoin Cash", + tbch: "Bitcoin Cash Testnet", + bcha: "eCash", + tbcha: "eCash Testnet", + btg: "Bitcoin Gold", + tbtg: "Bitcoin Gold Testnet", + bsv: "Bitcoin SV", + tbsv: "Bitcoin SV Testnet", + dash: "Dash", + tdash: "Dash Testnet", + doge: "Dogecoin", + tdoge: "Dogecoin Testnet", + zec: "Zcash", + tzec: "Zcash Testnet", +}; + +/** + * Try to decode input as hex. + */ +function tryDecodeHex(input: string): Uint8Array | null { + const trimmed = input.trim(); + if (!/^[0-9a-fA-F]*$/.test(trimmed) || trimmed.length % 2 !== 0) { + return null; + } + const bytes = new Uint8Array(trimmed.length / 2); + for (let i = 0; i < bytes.length; i++) { + bytes[i] = parseInt(trimmed.slice(i * 2, i * 2 + 2), 16); + } + return bytes; +} + +/** + * Try to decode input as base64. + */ +function tryDecodeBase64(input: string): Uint8Array | null { + const trimmed = input.trim(); + try { + const binary = atob(trimmed); + const bytes = new Uint8Array(binary.length); + for (let i = 0; i < binary.length; i++) { + bytes[i] = binary.charCodeAt(i); + } + return bytes; + } catch { + return null; + } +} + +/** + * Get all possible decodings of the input (hex, base64). + */ +function possibleDecodings(input: string): Uint8Array[] { + const decodings: Uint8Array[] = []; + + const hex = tryDecodeHex(input); + if (hex) decodings.push(hex); + + const base64 = tryDecodeBase64(input); + if (base64) decodings.push(base64); + + return decodings; +} + +/** + * Convert bytes to hex string. + */ +function toHex(bytes: Uint8Array): string { + return Array.from(bytes) + .map((b) => b.toString(16).padStart(2, "0")) + .join(""); +} + +/** + * Detect if input is a PSBT based on magic bytes. + */ +function isPsbt(bytes: Uint8Array): boolean { + if (bytes.length < 5) return false; + const magic = toHex(bytes.slice(0, 5)); + return magic === PSBT_MAGIC; +} + +/** + * Format a primitive value for display. + */ +function formatPrimitive(primitive: Primitive, expanded: boolean = false): string { + if (primitive.type === "None") return ""; + if (primitive.type === "Buffer") { + const hex = String(primitive.value ?? ""); + // Only truncate when hiding more than 8 characters (64 shown + 8 hidden = 72) + if (!expanded && hex.length > 72) { + return hex.slice(0, 32) + "..." + hex.slice(-32); + } + return hex; + } + if (primitive.type === "Boolean") { + return primitive.value ? "true" : "false"; + } + return String(primitive.value ?? ""); +} + +/** + * Check if a buffer value is truncatable. + */ +function isTruncatable(primitive: Primitive): boolean { + if (primitive.type !== "Buffer") return false; + const hex = String(primitive.value ?? ""); + // Only expandable when truncation would hide more than 8 characters + return hex.length > 72; +} + +/** + * Get full value for copying. + */ +function getFullValue(primitive: Primitive): string { + if (primitive.type === "None") return ""; + if (primitive.type === "Boolean") { + return primitive.value ? "true" : "false"; + } + return String(primitive.value ?? ""); +} + +/** + * Copy text to clipboard and show feedback. + */ +async function copyToClipboard(text: string, button: HTMLElement): Promise { + try { + await navigator.clipboard.writeText(text); + const original = button.textContent; + button.textContent = "Copied!"; + setTimeout(() => { + button.textContent = original; + }, 1500); + } catch (e) { + console.error("Failed to copy:", e); + } +} + +/** + * Tree Node component for recursive rendering. + */ +function renderTreeNode( + node: Node, + expandedPaths: Set, + onToggle: (path: string) => void, + expandedValues: Set, + onToggleValue: (path: string) => void, + path: string = "root", +): HTMLElement { + const hasChildren = node.children.length > 0; + const isExpanded = expandedPaths.has(path); + const hasValue = node.value.type !== "None"; + const isValueExpanded = expandedValues.has(path); + const canExpandValue = isTruncatable(node.value); + + const toggleExpand = () => { + onToggle(path); + }; + + const toggleValueExpand = (e: Event) => { + e.stopPropagation(); + onToggleValue(path); + }; + + // Leaf node - just show label: value + if (!hasChildren) { + return h( + "div", + { class: "tree-leaf" }, + h("span", { class: "tree-label" }, node.label), + hasValue + ? [ + h("span", { class: "tree-separator" }, ": "), + h( + "span", + { + class: `tree-value tree-value-${node.value.type.toLowerCase()}${canExpandValue ? " expandable" : ""}${isValueExpanded ? " expanded" : ""}`, + title: + canExpandValue && !isValueExpanded ? "Click to expand" : getFullValue(node.value), + onclick: canExpandValue ? toggleValueExpand : undefined, + }, + formatPrimitive(node.value, isValueExpanded), + ), + h( + "button", + { + class: "copy-btn", + onclick: (e: Event) => { + e.stopPropagation(); + copyToClipboard(getFullValue(node.value), e.target as HTMLElement); + }, + }, + "Copy", + ), + ] + : null, + ); + } + + // Branch node - collapsible + const childCount = node.children.length; + const labelText = hasValue + ? `${node.label}: ${formatPrimitive(node.value, isValueExpanded)}` + : `${node.label} [${childCount}]`; + + return h( + "div", + { class: "tree-branch" }, + h( + "div", + { + class: "tree-branch-header", + onclick: toggleExpand, + }, + h("span", { class: `tree-chevron ${isExpanded ? "expanded" : ""}` }, isExpanded ? "▼" : "►"), + h("span", { class: "tree-label" }, labelText), + ), + isExpanded + ? h( + "div", + { class: "tree-children" }, + ...node.children.map((child, i) => + renderTreeNode( + child, + expandedPaths, + onToggle, + expandedValues, + onToggleValue, + `${path}.${i}`, + ), + ), + ) + : null, + ); +} + +/** + * Parser Web Component + */ +class PsbtTxParser extends BaseComponent { + private debounceTimer: number | null = null; + private expandedPaths: Set = new Set(["root"]); + private expandedValues: Set = new Set(); + private currentMode: ParseMode = "psbt"; + private currentNode: Node | null = null; + private currentNetwork: CoinName = "btc"; + private autoDetectNetwork: boolean = true; + + render() { + const featureEnabled = isInspectEnabled(); + + return fragment( + css(` + ${commonStyles} + + .parser { + max-width: none; + width: 100%; + } + + .parser-layout { + display: grid; + grid-template-columns: 400px 1fr; + gap: 1.5rem; + align-items: start; + } + + @media (max-width: 900px) { + .parser-layout { + grid-template-columns: 1fr; + } + } + + .controls-panel { + position: sticky; + top: 1rem; + } + + .results-panel { + min-width: 0; + } + + .input-section { + margin-bottom: 0; + } + + .input-row { + display: flex; + gap: 0.5rem; + margin-bottom: 0.75rem; + } + + textarea { + width: 100%; + font-family: inherit; + font-size: 0.875rem; + padding: 0.75rem 1rem; + background: var(--surface, #161b22); + border: 1px solid var(--border, #30363d); + border-radius: 6px; + color: var(--fg, #c9d1d9); + resize: vertical; + min-height: 200px; + } + + textarea:focus { + outline: none; + border-color: var(--accent, #58a6ff); + } + + textarea::placeholder { + color: var(--muted, #8b949e); + } + + .btn { + padding: 0.5rem 1rem; + font-family: inherit; + font-size: 0.875rem; + background: var(--surface, #161b22); + border: 1px solid var(--border, #30363d); + border-radius: 6px; + color: var(--fg, #c9d1d9); + cursor: pointer; + transition: border-color 0.15s, background 0.15s; + white-space: nowrap; + } + + .btn:hover { + border-color: var(--accent, #58a6ff); + background: var(--surface-hover, #1c2128); + } + + .btn-group { + display: flex; + gap: 0; + } + + .btn-group .btn { + border-radius: 0; + } + + .btn-group .btn:first-child { + border-radius: 6px 0 0 6px; + } + + .btn-group .btn:last-child { + border-radius: 0 6px 6px 0; + } + + .btn-group .btn:not(:first-child) { + margin-left: -1px; + } + + .btn-group .btn.active { + background: var(--accent, #58a6ff); + border-color: var(--accent, #58a6ff); + color: var(--bg, #0d1117); + } + + .controls-row { + display: flex; + flex-direction: column; + gap: 0.75rem; + align-items: stretch; + } + + .controls-row-group { + display: flex; + gap: 0.5rem; + align-items: center; + flex-wrap: wrap; + } + + .mode-label { + font-size: 0.75rem; + color: var(--muted, #8b949e); + text-transform: uppercase; + letter-spacing: 0.05em; + } + + .error-message { + padding: 1rem; + background: rgba(248, 81, 73, 0.1); + border: 1px solid rgba(248, 81, 73, 0.4); + border-radius: 6px; + color: #f85149; + margin-bottom: 1.5rem; + font-size: 0.875rem; + } + + .feature-disabled { + padding: 1rem; + background: rgba(207, 172, 83, 0.1); + border: 1px solid rgba(207, 172, 83, 0.4); + border-radius: 6px; + color: var(--warning, #CFAC53); + margin-bottom: 1.5rem; + } + + .tree-container { + background: var(--surface, #161b22); + border: 1px solid var(--border, #30363d); + border-radius: 6px; + padding: 1rem; + overflow-x: auto; + } + + .tree-branch { + margin-left: 0; + } + + .tree-branch .tree-branch, + .tree-branch .tree-leaf { + margin-left: 1.25rem; + border-left: 1px solid var(--border-subtle, #21262d); + padding-left: 0.75rem; + } + + .tree-branch-header { + display: flex; + align-items: center; + gap: 0.5rem; + padding: 0.25rem 0; + cursor: pointer; + user-select: none; + } + + .tree-branch-header:hover { + background: var(--surface-hover, #1c2128); + margin: 0 -0.5rem; + padding: 0.25rem 0.5rem; + border-radius: 4px; + } + + .tree-chevron { + font-size: 0.75rem; + color: var(--muted, #8b949e); + width: 1rem; + text-align: center; + } + + .tree-leaf { + display: flex; + align-items: center; + gap: 0; + padding: 0.25rem 0; + flex-wrap: wrap; + } + + .tree-label { + color: var(--accent, #58a6ff); + font-weight: 500; + } + + .tree-separator { + color: var(--muted, #8b949e); + } + + .tree-value { + color: var(--fg, #c9d1d9); + word-break: break-all; + max-width: 600px; + } + + .tree-value-buffer { + color: var(--green, #7ACC8F); + font-family: inherit; + } + + .tree-value-buffer.expandable { + cursor: pointer; + text-decoration: underline dotted; + text-underline-offset: 2px; + } + + .tree-value-buffer.expandable:hover { + background: rgba(122, 204, 143, 0.1); + border-radius: 2px; + } + + .tree-value-buffer.expanded { + text-decoration: none; + word-break: break-all; + max-width: none; + } + + .tree-value-string { + color: var(--yellow, #EBC55E); + } + + .tree-value-integer, + .tree-value-u8, + .tree-value-u16, + .tree-value-u32, + .tree-value-u64, + .tree-value-i8, + .tree-value-i16, + .tree-value-i32, + .tree-value-i64 { + color: var(--lavender, #8780FF); + } + + .tree-value-boolean { + color: var(--orange, #FF704C); + } + + .tree-children { + margin-top: 0.25rem; + } + + .copy-btn { + padding: 0.125rem 0.375rem; + font-size: 0.625rem; + background: transparent; + border: 1px solid var(--border, #30363d); + border-radius: 3px; + color: var(--muted, #8b949e); + cursor: pointer; + margin-left: 0.5rem; + opacity: 0; + transition: opacity 0.15s, border-color 0.15s, color 0.15s; + } + + .tree-leaf:hover .copy-btn { + opacity: 1; + } + + .copy-btn:hover { + border-color: var(--accent, #58a6ff); + color: var(--accent, #58a6ff); + } + + .empty-state { + text-align: center; + padding: 3rem 1rem; + color: var(--muted, #8b949e); + } + + .detected-type { + font-size: 0.75rem; + color: var(--muted, #8b949e); + padding: 0.5rem 0; + } + + .expand-controls { + display: flex; + gap: 0.5rem; + } + + .action-buttons { + display: flex; + gap: 0.5rem; + flex-wrap: wrap; + } + + .expand-controls .btn { + padding: 0.25rem 0.5rem; + font-size: 0.75rem; + } + + .modal-overlay { + display: none; + position: fixed; + top: 0; + left: 0; + right: 0; + bottom: 0; + background: rgba(0, 0, 0, 0.7); + z-index: 1000; + align-items: center; + justify-content: center; + } + + .modal-overlay.open { + display: flex; + } + + .modal { + background: var(--bg, #0d1117); + border: 1px solid var(--border, #30363d); + border-radius: 8px; + max-width: 500px; + width: 90%; + max-height: 80vh; + display: flex; + flex-direction: column; + box-shadow: 0 8px 32px rgba(0, 0, 0, 0.4); + } + + .modal-header { + display: flex; + justify-content: space-between; + align-items: center; + padding: 1rem 1.25rem; + border-bottom: 1px solid var(--border, #30363d); + } + + .modal-header h2 { + margin: 0; + font-size: 1rem; + font-weight: 600; + } + + .modal-close { + background: none; + border: none; + color: var(--muted, #8b949e); + cursor: pointer; + font-size: 1.25rem; + padding: 0.25rem; + line-height: 1; + } + + .modal-close:hover { + color: var(--fg, #c9d1d9); + } + + .modal-body { + padding: 0.5rem; + overflow-y: auto; + flex: 1; + } + + .sample-list { + list-style: none; + margin: 0; + padding: 0; + } + + .sample-list li { + margin: 0; + } + + .sample-item { + display: block; + width: 100%; + padding: 0.625rem 0.75rem; + background: none; + border: none; + color: var(--fg, #c9d1d9); + text-align: left; + cursor: pointer; + font-family: inherit; + font-size: 0.875rem; + border-radius: 4px; + transition: background 0.15s; + } + + .sample-item:hover { + background: var(--surface, #161b22); + } + + .sample-item .sample-type { + font-size: 0.625rem; + text-transform: uppercase; + color: var(--muted, #8b949e); + margin-left: 0.5rem; + } + + .load-sample-btn { + width: 100%; + margin-top: 1rem; + } + + .network-select { + font-family: inherit; + font-size: 0.875rem; + padding: 0.375rem 0.75rem; + background: var(--surface, #161b22); + border: 1px solid var(--border, #30363d); + border-radius: 6px; + color: var(--fg, #c9d1d9); + cursor: pointer; + } + + .network-select:focus { + outline: none; + border-color: var(--accent, #58a6ff); + } + + .network-select option { + background: var(--surface, #161b22); + color: var(--fg, #c9d1d9); + } + `), + h( + "div", + { class: "parser" }, + h( + "nav", + { class: "breadcrumb" }, + h("a", { href: "#/" }, "Home"), + " / ", + h("span", {}, "UTXO PSBT/TX Parser"), + ), + h("h1", {}, "UTXO PSBT/TX Parser"), + !featureEnabled + ? h( + "div", + { class: "feature-disabled" }, + "⚠ The inspect feature is not enabled in this WASM build.", + ) + : null, + h( + "div", + { class: "parser-layout" }, + // Left panel: Controls + h( + "div", + { class: "controls-panel" }, + h( + "section", + { class: "input-section" }, + h( + "div", + { class: "input-row" }, + h("textarea", { + id: "data-input", + placeholder: "Paste a PSBT or transaction (hex or base64)...", + rows: "6", + spellcheck: "false", + autocomplete: "off", + oninput: (e: Event) => this.handleInput(e), + }), + ), + h( + "div", + { class: "controls-row" }, + h( + "div", + { class: "controls-row-group" }, + h("span", { class: "mode-label" }, "Mode:"), + h( + "div", + { class: "btn-group" }, + h( + "button", + { + id: "mode-psbt", + class: "btn active", + onclick: () => this.setMode("psbt"), + }, + "PSBT", + ), + h( + "button", + { + id: "mode-psbt-raw", + class: "btn", + onclick: () => this.setMode("psbt-raw"), + }, + "PSBT Raw", + ), + h( + "button", + { + id: "mode-tx", + class: "btn", + onclick: () => this.setMode("tx"), + }, + "Transaction", + ), + ), + ), + h( + "div", + { class: "controls-row-group" }, + h("span", { class: "mode-label" }, "Network:"), + h( + "select", + { + id: "network-select", + class: "network-select", + onchange: (e: Event) => this.setNetwork(e), + }, + h("option", { value: "auto", selected: true }, "Auto-detect"), + ...allNetworks.map((network) => + h("option", { value: network }, networkLabels[network]), + ), + ), + ), + h("span", { id: "detected-type", class: "detected-type" }), + h( + "div", + { class: "action-buttons" }, + h( + "div", + { class: "expand-controls" }, + h( + "button", + { + class: "btn", + onclick: () => this.expandAll(), + }, + "Expand All", + ), + h( + "button", + { + class: "btn", + onclick: () => this.collapseAll(), + }, + "Collapse All", + ), + ), + h( + "button", + { + class: "btn", + onclick: () => this.share(), + }, + "Share", + ), + h( + "button", + { + class: "btn", + onclick: () => this.clear(), + }, + "Clear", + ), + ), + ), + ), + h("div", { id: "error-message" }), + h( + "button", + { + class: "btn load-sample-btn", + onclick: () => this.openSampleModal(), + }, + "Load Sample", + ), + ), + // Right panel: Results + h( + "div", + { class: "results-panel" }, + h( + "div", + { id: "results" }, + h( + "div", + { class: "empty-state" }, + h("p", {}, "Enter a PSBT or transaction to parse it"), + ), + ), + ), + ), + // Sample modal + h( + "div", + { + id: "sample-modal", + class: "modal-overlay", + onclick: (e: Event) => { + // Close modal when clicking on overlay (not the modal itself) + if ((e.target as HTMLElement).classList.contains("modal-overlay")) { + this.closeSampleModal(); + } + }, + }, + h( + "div", + { class: "modal" }, + h( + "div", + { class: "modal-header" }, + h("h2", {}, "Load Sample"), + h( + "button", + { + class: "modal-close", + onclick: () => this.closeSampleModal(), + }, + "×", + ), + ), + h( + "div", + { class: "modal-body" }, + h( + "ul", + { class: "sample-list" }, + ...samples.map((sample: Sample, index: number) => + h( + "li", + {}, + h( + "button", + { + class: "sample-item", + onclick: () => this.selectSample(index), + }, + sample.name, + h("span", { class: "sample-type" }, sample.type === "tx" ? "TX" : "PSBT"), + ), + ), + ), + ), + ), + ), + ), + ), + ); + } + + onParamsChange(params: URLSearchParams): void { + const data = params.get("data"); + const mode = params.get("mode") as ParseMode | null; + const network = params.get("network"); + const input = this.$("#data-input"); + + if (mode && ["psbt", "psbt-raw", "tx"].includes(mode)) { + this.currentMode = mode; + this.updateModeButtons(); + } + + if (network) { + if (network === "auto") { + this.autoDetectNetwork = true; + } else if (allNetworks.includes(network as CoinName)) { + this.autoDetectNetwork = false; + this.currentNetwork = network as CoinName; + } + this.updateNetworkSelect(); + } + + if (input && data) { + input.value = data; + this.parse(data); + } else if (input && !data) { + input.value = ""; + this.showEmpty(); + } + } + + private handleInput(e: Event): void { + const value = (e.target as HTMLTextAreaElement).value.trim(); + + // Debounce URL updates + if (this.debounceTimer) { + clearTimeout(this.debounceTimer); + } + + const networkParam = this.autoDetectNetwork ? "auto" : this.currentNetwork; + this.debounceTimer = window.setTimeout(() => { + setParams({ data: value, mode: this.currentMode, network: networkParam }); + }, 300); + + // Update results immediately + if (value) { + this.parse(value); + } else { + this.showEmpty(); + } + } + + private openSampleModal(): void { + const modal = this.$("#sample-modal"); + if (modal) { + modal.classList.add("open"); + } + } + + private closeSampleModal(): void { + const modal = this.$("#sample-modal"); + if (modal) { + modal.classList.remove("open"); + } + } + + private selectSample(index: number): void { + if (index < 0 || index >= samples.length) { + return; + } + + const sample = samples[index]; + const input = this.$("#data-input"); + + if (input) { + input.value = sample.data; + + // Set mode based on sample type + const mode: ParseMode = sample.type === "tx" ? "tx" : "psbt"; + this.currentMode = mode; + this.updateModeButtons(); + + // Reset to auto-detect for samples + this.autoDetectNetwork = true; + this.updateNetworkSelect(); + + // Update URL and parse + setParams({ data: sample.data, mode, network: "auto" }); + this.parse(sample.data); + } + + this.closeSampleModal(); + } + + private setMode(mode: ParseMode): void { + this.currentMode = mode; + this.updateModeButtons(); + + const input = this.$("#data-input"); + const value = input?.value.trim(); + + if (value) { + setParams({ mode }); + this.parse(value); + } + } + + private setNetwork(e: Event): void { + const select = e.target as HTMLSelectElement; + const value = select.value; + + if (value === "auto") { + this.autoDetectNetwork = true; + } else { + this.autoDetectNetwork = false; + this.currentNetwork = value as CoinName; + } + + const input = this.$("#data-input"); + const inputValue = input?.value.trim(); + + if (inputValue) { + setParams({ network: value }); + this.parse(inputValue); + } + } + + private updateModeButtons(): void { + const modes: ParseMode[] = ["psbt", "psbt-raw", "tx"]; + for (const m of modes) { + const btn = this.$(`#mode-${m}`); + if (btn) { + btn.classList.toggle("active", m === this.currentMode); + } + } + } + + private updateNetworkSelect(): void { + const select = this.$("#network-select"); + if (select) { + select.value = this.autoDetectNetwork ? "auto" : this.currentNetwork; + } + } + + private parse(input: string): void { + const errorEl = this.$("#error-message"); + const resultsEl = this.$("#results"); + const detectedEl = this.$("#detected-type"); + + if (!errorEl || !resultsEl || !detectedEl) return; + + // Clear previous state + errorEl.innerHTML = ""; + this.expandedPaths = new Set(["root"]); + this.expandedValues = new Set(); + + // Get all possible decodings (hex, base64) + const decodings = possibleDecodings(input); + if (decodings.length === 0) { + errorEl.replaceChildren( + h("div", { class: "error-message" }, "Failed to decode input: not valid hex or base64"), + ); + resultsEl.replaceChildren( + h("div", { class: "empty-state" }, h("p", {}, "Enter valid hex or base64 data")), + ); + return; + } + + // Parse based on mode with network handling + // Try all decodings and pick the first one that parses successfully + let node: Node | null = null; + let detectedNetwork: CoinName | null = null; + let successBytes: Uint8Array | null = null; + let lastError: string | null = null; + + for (const bytes of decodings) { + try { + if (this.autoDetectNetwork) { + // Try all networks and pick the first one that works + if (this.currentMode === "psbt") { + const result = tryParsePsbt(bytes); + if (result) { + detectedNetwork = result.network; + this.currentNetwork = result.network; + node = result.node; + successBytes = bytes; + break; + } + } else if (this.currentMode === "psbt-raw") { + const result = tryParsePsbtRaw(bytes); + if (result) { + detectedNetwork = result.network; + this.currentNetwork = result.network; + node = result.node; + successBytes = bytes; + break; + } + } else { + const result = tryParseTx(bytes); + if (result) { + detectedNetwork = result.network; + this.currentNetwork = result.network; + node = result.node; + successBytes = bytes; + break; + } + } + } else { + // Use the specified network + switch (this.currentMode) { + case "psbt": + node = parsePsbtToNode(bytes, this.currentNetwork); + break; + case "psbt-raw": + node = parsePsbtRawToNode(bytes, this.currentNetwork); + break; + case "tx": + node = parseTxToNode(bytes, this.currentNetwork); + break; + } + if (node) { + successBytes = bytes; + break; + } + } + } catch (e) { + lastError = String(e); + // Continue trying other decodings + } + } + + if (!node) { + const errorMsg = lastError + ? `Parse error (tried hex and base64): ${lastError}` + : "Failed to parse with any encoding"; + errorEl.replaceChildren(h("div", { class: "error-message" }, errorMsg)); + resultsEl.replaceChildren( + h("div", { class: "empty-state" }, h("p", {}, "Failed to parse data")), + ); + return; + } + + // Auto-detect type (PSBT vs TX) based on successfully decoded bytes + const detectedPsbt = successBytes ? isPsbt(successBytes) : false; + + // Update detected type display + const typeStr = detectedPsbt ? "PSBT" : "Transaction"; + const networkStr = detectedNetwork + ? ` · Network: ${networkLabels[detectedNetwork]}` + : ` · Network: ${networkLabels[this.currentNetwork]}`; + detectedEl.textContent = `Detected: ${typeStr}${networkStr}`; + + this.currentNode = node; + this.renderTree(); + } + + private renderTree(): void { + const resultsEl = this.$("#results"); + if (!resultsEl || !this.currentNode) return; + + const treeEl = renderTreeNode( + this.currentNode, + this.expandedPaths, + (path) => { + if (this.expandedPaths.has(path)) { + this.expandedPaths.delete(path); + } else { + this.expandedPaths.add(path); + } + this.renderTree(); + }, + this.expandedValues, + (path) => { + if (this.expandedValues.has(path)) { + this.expandedValues.delete(path); + } else { + this.expandedValues.add(path); + } + this.renderTree(); + }, + ); + + resultsEl.replaceChildren(h("div", { class: "tree-container" }, treeEl)); + } + + private expandAll(): void { + if (!this.currentNode) return; + + // Collect all paths + const collectPaths = (node: Node, path: string): void => { + this.expandedPaths.add(path); + node.children.forEach((child, i) => { + collectPaths(child, `${path}.${i}`); + }); + }; + + collectPaths(this.currentNode, "root"); + this.renderTree(); + } + + private collapseAll(): void { + this.expandedPaths = new Set(["root"]); + this.expandedValues = new Set(); + this.renderTree(); + } + + private showEmpty(): void { + const errorEl = this.$("#error-message"); + const resultsEl = this.$("#results"); + const detectedEl = this.$("#detected-type"); + + if (errorEl) errorEl.innerHTML = ""; + if (detectedEl) detectedEl.textContent = ""; + if (resultsEl) { + resultsEl.replaceChildren( + h( + "div", + { class: "empty-state" }, + h("p", {}, "Enter a PSBT or transaction above to parse it"), + ), + ); + } + this.currentNode = null; + } + + private share(): void { + copyToClipboard(location.href, this.$(".btn")!); + } + + private clear(): void { + const input = this.$("#data-input"); + if (input) { + input.value = ""; + setParams({ data: "", mode: "" }); + this.showEmpty(); + } + } +} + +defineComponent("psbt-tx-parser", PsbtTxParser); diff --git a/packages/webui/src/wasm-utxo/parser/samples.ts b/packages/webui/src/wasm-utxo/parser/samples.ts new file mode 100644 index 00000000000..daa855da668 --- /dev/null +++ b/packages/webui/src/wasm-utxo/parser/samples.ts @@ -0,0 +1,414 @@ +/** + * Sample PSBT/TX data extracted from test fixtures. + * Auto-generated by scripts/extract-samples.js + * DO NOT EDIT MANUALLY + */ + +export interface Sample { + name: string; + type: "psbt" | "tx"; + data: string; +} + +export const samples: Sample[] = [ + { + name: "Bitcoin Lite PSBT (Finalized)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoin Lite PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoin Lite PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoin Lite PSBT (Unsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoin Lite TX (Extracted)", + type: "tx", + data: "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", + }, + { + name: "Bitcoin PSBT (Finalized)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoin PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoin PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoin PSBT (Unsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoin TX (Extracted)", + type: "tx", + data: "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", + }, + { + name: "Bitcoincash Lite PSBT (Finalized)", + type: "psbt", + data: "cHNidP8BANYCAAAAAtXfdTBXaO3hAaMVPLavKMxhzcqBZRvfo2qnxEBDSeXtAAAAAAD/////AWwmXH9/BmqsmzByVuaOTbCQFWkakkLlHO5gfQAfp/MBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHAQf9/QAARzBEAiAl3cP2yVD9Ntv+YcJ5b1zD/S9XFwCOlXkNk+9nfXYyBgIgAclrPDfm1WnnoeQg908H+Uyul3x5AraJDdHIJJdT5KRBSDBFAiEA0Lwfy+ZkxgQW3eeY3eIEz+sm2sRA4dXwwcgPLmjBDyACIAynTh4KfUzeAYVRUMzilU7hSbZprrYJRHh0U4r8PLWWQUxpUiED9vQHZL1dY/IAoneIg6z3XpbxUJXJmCY8CHJw0Ml+fn8hA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyIQPhUk1/b8V6s+rLtlm3hxBngKR10dtIOVLCMQt+mjiXW1OuAAEBINAHAAAAAAAAF6kUILNwlNgqUTRR/wzNnbI6ugW8XvOHAQdsRzBEAiASlkVIyCpGZvmIL8kkbtVVt4TqLq4ThNyQ1LngkbFlsgIgNFvVDciI/72SGZikKDO2d+HgexLxv2ppRrydatC5JcxBIyEDNu8ij/6bjv/7oFLDLTNGYN0fg2bPj+RK5apnK2tikJWsAAEAaVIhAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJIQLXL9DQ2QKTQ0rV/KFg8njgPGFEl6pOQlz0VOLBMw+WqyEDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvFTriICAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJFPLvA4kAAAAAAAAAAAAAAAAAAAAAIgIC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqsUzBiuCAAAAAAAAAAAAAAAAAAAAAAiAgNE2IQTbfVQIChl/7xiGMf5yI/mzjnJRXmBkLrbOKdS8RT2XNhpAAAAAAAAAAAAAAAAAAAAAAABAGlSIQNreRC1kdOnVtXudaXozA4n50XoVTD+q9J9T1hHpQ8whiECr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0hA0omsDbfD18D30R00HkkqYoF4RuiWER24a3bRIKs6kARU64iAgKv4S1XfRogo+2vwv09JVrOfRuLGD0K+d0/vlv1VDq8fRTUrYNyAAAAAAAAAAAAAAAAAQAAACICA0omsDbfD18D30R00HkkqYoF4RuiWER24a3bRIKs6kARFEBcZb0AAAAAAAAAAAAAAAABAAAAIgIDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYUVH9FdgAAAAAAAAAAAAAAAAEAAAAAAAA=", + }, + { + name: "Bitcoincash Lite PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoincash Lite PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoincash Lite PSBT (Unsigned)", + type: "psbt", + data: "cHNidP8BANYCAAAAAtXfdTBXaO3hAaMVPLavKMxhzcqBZRvfo2qnxEBDSeXtAAAAAAD/////AWwmXH9/BmqsmzByVuaOTbCQFWkakkLlHO5gfQAfp/MBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHAQMEQQAAAAEEaVIhA/b0B2S9XWPyAKJ3iIOs916W8VCVyZgmPAhycNDJfn5/IQNf+3q8cBWeBGn0uYmm1eF4WikEFp/wULL0aP5dPV278iED4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1tTriIGA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyFMwYrggAAAAAAAAAAAEAAAAAAAAAIgYD4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1sU9lzYaQAAAAAAAAAAAQAAAAAAAAAiBgP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+fxTy7wOJAAAAAAAAAAABAAAAAAAAAAABASDQBwAAAAAAABepFCCzcJTYKlE0Uf8MzZ2yOroFvF7zhwEDBEEAAAABBCMhAzbvIo/+m47/+6BSwy0zRmDdH4Nmz4/kSuWqZytrYpCVrAABAGlSIQLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCSEC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqshA0TYhBNt9VAgKGX/vGIYx/nIj+bOOclFeYGQuts4p1LxU64iAgLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCRTy7wOJAAAAAAAAAAAAAAAAAAAAACICAtcv0NDZApNDStX8oWDyeOA8YUSXqk5CXPRU4sEzD5arFMwYrggAAAAAAAAAAAAAAAAAAAAAIgIDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvEU9lzYaQAAAAAAAAAAAAAAAAAAAAAAAQBpUiEDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYhAq/hLVd9GiCj7a/C/T0lWs59G4sYPQr53T++W/VUOrx9IQNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAEVOuIgICr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0U1K2DcgAAAAAAAAAAAAAAAAEAAAAiAgNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAERRAXGW9AAAAAAAAAAAAAAAAAQAAACICA2t5ELWR06dW1e51pejMDifnRehVMP6r0n1PWEelDzCGFFR/RXYAAAAAAAAAAAAAAAABAAAAAAAA", + }, + { + name: "Bitcoincash Lite TX (Extracted)", + type: "tx", + data: "0200000002d5df75305768ede101a3153cb6af28cc61cdca81651bdfa36aa7c4404349e5ed00000000fdfd0000473044022025ddc3f6c950fd36dbfe61c2796f5cc3fd2f5717008e95790d93ef677d763206022001c96b3c37e6d569e7a1e420f74f07f94cae977c7902b6890dd1c8249753e4a441483045022100d0bc1fcbe664c60416dde798dde204cfeb26dac440e1d5f0c1c80f2e68c10f2002200ca74e1e0a7d4cde01855150cce2954ee149b669aeb609447874538afc3cb596414c69522103f6f40764bd5d63f200a2778883acf75e96f15095c998263c087270d0c97e7e7f21035ffb7abc70159e0469f4b989a6d5e1785a2904169ff050b2f468fe5d3d5dbbf22103e1524d7f6fc57ab3eacbb659b787106780a475d1db483952c2310b7e9a38975b53aeffffffff016c265c7f7f066aac9b307256e68e4db09015691a9242e51cee607d001fa7f3010000006c473044022012964548c82a4666f9882fc9246ed555b784ea2eae1384dc90d4b9e091b165b20220345bd50dc888ffbd921998a42833b677e1e07b12f1bf6a6946bc9d6ad0b925cc4123210336ef228ffe9b8efffba052c32d334660dd1f8366cf8fe44ae5aa672b6b629095acffffffff04840300000000000017a914d909474404c124a3d04c3fbff61faa49cf43c58b87840300000000000017a9144efd761e9be61caa421c8aac4a902ad6f2a54bcf87840300000000000017a914d24d3816be8a250cbdde7eaa674f80170cda944e870000000000000000116a0f736574656320617374726f6e6f6d7900000000", + }, + { + name: "Bitcoincash PSBT (Finalized)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoincash PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoincash PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoincash PSBT (Unsigned)", + type: "psbt", + data: "cHNidP8BANYCAAAAAtXfdTBXaO3hAaMVPLavKMxhzcqBZRvfo2qnxEBDSeXtAAAAAAD/////AWwmXH9/BmqsmzByVuaOTbCQFWkakkLlHO5gfQAfp/MBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEAvgIAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAa0gwRQIhAPUYu8uFyBaFI1ULQglnUKkejtCi+T+7pFx0kqIkfccmAiB61WKxWM5NedPC63rgpXP5qEE9lcP/FhHCl/fxzoKhnwEhA70MNLI3Pjh1dc3bED7AORbDEETyUI4mH+NZeiaA7L0f/////wHQBwAAAAAAABepFFZ817RPnzoHwxOPN7+YS2D7uvJDhwAAAAABAwRBAAAAAQRpUiED9vQHZL1dY/IAoneIg6z3XpbxUJXJmCY8CHJw0Ml+fn8hA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyIQPhUk1/b8V6s+rLtlm3hxBngKR10dtIOVLCMQt+mjiXW1OuIgYDX/t6vHAVngRp9LmJptXheFopBBaf8FCy9Gj+XT1du/IUzBiuCAAAAAAAAAAAAQAAAAAAAAAiBgPhUk1/b8V6s+rLtlm3hxBngKR10dtIOVLCMQt+mjiXWxT2XNhpAAAAAAAAAAABAAAAAAAAACIGA/b0B2S9XWPyAKJ3iIOs916W8VCVyZgmPAhycNDJfn5/FPLvA4kAAAAAAAAAAAEAAAAAAAAAAAEA4AIAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAa0gwRQIhAIdRicMpSLwA2YG6QE5+jM0PbMf8tLLZ6vEeykTsbq1ZAiAZQdl89fyB1qK+q7zbNU9xhJwCpNTeFQHjMEZB7qMLRwEhA70MNLI3Pjh1dc3bED7AORbDEETyUI4mH+NZeiaA7L0f/////wLQBwAAAAAAABl2qRSIOtjRr/34pzy9r3I3tcWrnsLDJois0AcAAAAAAAAXqRQgs3CU2CpRNFH/DM2dsjq6Bbxe84cAAAAAAQMEQQAAAAEEIyEDNu8ij/6bjv/7oFLDLTNGYN0fg2bPj+RK5apnK2tikJWsAAEAaVIhAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJIQLXL9DQ2QKTQ0rV/KFg8njgPGFEl6pOQlz0VOLBMw+WqyEDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvFTriICAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJFPLvA4kAAAAAAAAAAAAAAAAAAAAAIgIC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqsUzBiuCAAAAAAAAAAAAAAAAAAAAAAiAgNE2IQTbfVQIChl/7xiGMf5yI/mzjnJRXmBkLrbOKdS8RT2XNhpAAAAAAAAAAAAAAAAAAAAAAABAGlSIQNreRC1kdOnVtXudaXozA4n50XoVTD+q9J9T1hHpQ8whiECr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0hA0omsDbfD18D30R00HkkqYoF4RuiWER24a3bRIKs6kARU64iAgKv4S1XfRogo+2vwv09JVrOfRuLGD0K+d0/vlv1VDq8fRTUrYNyAAAAAAAAAAAAAAAAAQAAACICA0omsDbfD18D30R00HkkqYoF4RuiWER24a3bRIKs6kARFEBcZb0AAAAAAAAAAAAAAAABAAAAIgIDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYUVH9FdgAAAAAAAAAAAAAAAAEAAAAAAAA=", + }, + { + name: "Bitcoincash TX (Extracted)", + type: "tx", + data: "0200000002d5df75305768ede101a3153cb6af28cc61cdca81651bdfa36aa7c4404349e5ed00000000fdfd0000473044022025ddc3f6c950fd36dbfe61c2796f5cc3fd2f5717008e95790d93ef677d763206022001c96b3c37e6d569e7a1e420f74f07f94cae977c7902b6890dd1c8249753e4a441483045022100d0bc1fcbe664c60416dde798dde204cfeb26dac440e1d5f0c1c80f2e68c10f2002200ca74e1e0a7d4cde01855150cce2954ee149b669aeb609447874538afc3cb596414c69522103f6f40764bd5d63f200a2778883acf75e96f15095c998263c087270d0c97e7e7f21035ffb7abc70159e0469f4b989a6d5e1785a2904169ff050b2f468fe5d3d5dbbf22103e1524d7f6fc57ab3eacbb659b787106780a475d1db483952c2310b7e9a38975b53aeffffffff016c265c7f7f066aac9b307256e68e4db09015691a9242e51cee607d001fa7f3010000006c473044022012964548c82a4666f9882fc9246ed555b784ea2eae1384dc90d4b9e091b165b20220345bd50dc888ffbd921998a42833b677e1e07b12f1bf6a6946bc9d6ad0b925cc4123210336ef228ffe9b8efffba052c32d334660dd1f8366cf8fe44ae5aa672b6b629095acffffffff04840300000000000017a914d909474404c124a3d04c3fbff61faa49cf43c58b87840300000000000017a9144efd761e9be61caa421c8aac4a902ad6f2a54bcf87840300000000000017a914d24d3816be8a250cbdde7eaa674f80170cda944e870000000000000000116a0f736574656320617374726f6e6f6d7900000000", + }, + { + name: "Bitcoingold Lite PSBT (Finalized)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoingold Lite PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoingold Lite PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoingold Lite PSBT (Unsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoingold Lite TX (Extracted)", + type: "tx", + data: "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", + }, + { + name: "Bitcoingold PSBT (Finalized)", + type: "psbt", + data: "cHNidP8BAP1zAQIAAAAE1d91MFdo7eEBoxU8tq8ozGHNyoFlG9+jaqfEQENJ5e0AAAAAAP/////ZrJ/8C45dE8o8AXqI8g0isxHPSazKqNvLTtJveVWdmwEAAAAA/////w6oPib2sAMmwUJCVhLc+iBCMDIdyHmXryeTcc5Fxth3AgAAAAD/////uEowcd9r50/zStLQP3RlA7HmnVNAnijdgMJw2EO8ZqkDAAAAAP////8GhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFAVBJxIdN/MiZs2WfEhUBJdqZ63wh4QDAAAAAAAAIgAgukjj+YdEY5Q/kBkqRfGuiVt3k2KnYpr3rWqdeoNePU+EAwAAAAAAABepFPxkGJFgS95wVikwC26N5fZ905Jih4QDAAAAAAAAF6kU9s9lApZzz5LgsOaQjFq5B5Uxai2HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEAvgIAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAa0gwRQIhAPUYu8uFyBaFI1ULQglnUKkejtCi+T+7pFx0kqIkfccmAiB61WKxWM5NedPC63rgpXP5qEE9lcP/FhHCl/fxzoKhnwEhA70MNLI3Pjh1dc3bED7AORbDEETyUI4mH+NZeiaA7L0f/////wHQBwAAAAAAABepFFZ817RPnzoHwxOPN7+YS2D7uvJDhwAAAAABB/wARzBEAiBDay33Nq61jmRuRWL/cQTIEd4Trx5MGKpn1MuGeCHZ0AIgbSkCvtx4wEG19rIOQ4bN0iR48Tsfz6Uo8d2iAcfThhxBRzBEAiBSBe2UM4ec7L8nGF3+ARFSjw43WTxjoRpZnbBGdqCFFgIgPb00KhjZ/1mLJlaIPI6mz55PxTWkl1ZgbloZdJroz3FBTGlSIQP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+fyEDX/t6vHAVngRp9LmJptXheFopBBaf8FCy9Gj+XT1du/IhA+FSTX9vxXqz6su2WbeHEGeApHXR20g5UsIxC36aOJdbU64AAQEg0AcAAAAAAAAXqRQOJrJdDOrm+c/z7azKoNGnDadgD4cBByMiACBG1IAKE5MzAZYIU5ntShcAtML9OMUhiMOjqR9yHzyWAAEI/f4ABABIMEUCIQDxGI0x5c9P8DGrBVCzEOCnt5no0nrhnUD4enIAg64LdwIgMfXyMTaWwvWI1IrVdDrRZpBHXWcHMRrDNaroOH7V+rhBSDBFAiEA+f/aMe9bav3gXz4he5eU2+EyVaRbFGwOTaZu1Qu+eD0CIDWYqmbe3X02dyoCbUz06JR4DIOgPrJ6k2uEO7NGCS1QQWlSIQKlhfP6tJte+VNG2TIiGiIb1V7BkfFVM+DycLNYJXTwNSECxPeGbP1ZlrwQaKljE8oV6cy16YRYOgc0Dd2uevAUYFshAiNFMbyRGaNqeUbpWut0kV3Qh8e0T1F7ju63P4mg/xqZU64AAQEr0AcAAAAAAAAiACDbBCfxgitHd2cOZnPCivAvbaHVr+cacfXJBkRwsin6/QEI/f4ABABIMEUCIQDqCwBk0m1PtqIs7Y3SW5cBOfuXRE7XXKEWlAg4S/C5hwIgRakB5vTxOVmBSJz+ySJSgkDALyeIVMW3eM56tPW3tnxBSDBFAiEAsPq8+zVn1dIBGrb74eSfejTAjrTkxYfhuy1mpKe41KECIFZoVnQBQif7H1HIMdtec3zGd87O7J9ESFaSbJwpvsMsQWlSIQNRnlcqtGhWDR+ND4dpnQmDCOFmkF9dyuQ5DwYPqo8c4yEDoFvCY5EiHWheGNqv82oelcNPmUUSU8Fs1CZQ2yeKeREhAugKCIhcNTZ2uCDNwpDm2BoKyVoD6Ku/S7eu6/tw/rQYU64AAQD9IwECAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAGpHMEQCIG9NHKYqk7mpGxzmo8tVXBZUm0Fsf3KpH72D8IqTJbidAiBP9jDMrOmfNmhu8+ZdzC8RE9HiLX6ICkNoSTGk1uMrHwEhA70MNLI3Pjh1dc3bED7AORbDEETyUI4mH+NZeiaA7L0f/////wTQBwAAAAAAABl2qRSIOtjRr/34pzy9r3I3tcWrnsLDJois0AcAAAAAAAAZdqkUiDrY0a/9+Kc8va9yN7XFq57CwyaIrNAHAAAAAAAAGXapFIg62NGv/finPL2vcje1xauewsMmiKzQBwAAAAAAABepFCCzcJTYKlE0Uf8MzZ2yOroFvF7zhwAAAAABB2xHMEQCIAMHbAnAnCibtuW6R3+Ceq/XE8FbH+Vn1EIJcXWiIC3cAiAyHUyEaSP0Uw48NKQMOGzK0DFYapGbY/XBZDXGs05tsUEjIQM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlawAAQBpUiECzE0PpBHKwkRIb46ywI4DX/dBD0YKNZyn+IEJkb07QgkhAtcv0NDZApNDStX8oWDyeOA8YUSXqk5CXPRU4sEzD5arIQNE2IQTbfVQIChl/7xiGMf5yI/mzjnJRXmBkLrbOKdS8VOuIgICzE0PpBHKwkRIb46ywI4DX/dBD0YKNZyn+IEJkb07QgkU8u8DiQAAAAAAAAAAAAAAAAAAAAAiAgLXL9DQ2QKTQ0rV/KFg8njgPGFEl6pOQlz0VOLBMw+WqxTMGK4IAAAAAAAAAAAAAAAAAAAAACICA0TYhBNt9VAgKGX/vGIYx/nIj+bOOclFeYGQuts4p1LxFPZc2GkAAAAAAAAAAAAAAAAAAAAAAAEAIgAgKSsFI1GjxvgNUbrmQsyIIRgok9vu2ryPXQ6Wd0dgJsEBAWlSIQMuEfmFUmhf6QfzH55yYMkG6N5wDww8ny8UEGI9zf0ZwCEDVFdXzjXPHt+xO54sSi+c4Aq4w2vuEryiM3zlg/0orsghAqPPtmZf5E91ILahtN4aTUZkOzhesf0eCrcO+5ZUKXVUU64iAgKjz7ZmX+RPdSC2obTeGk1GZDs4XrH9Hgq3DvuWVCl1VBT2XNhpAAAAAAAAAAAKAAAAAQAAACICAy4R+YVSaF/pB/MfnnJgyQbo3nAPDDyfLxQQYj3N/RnAFPLvA4kAAAAAAAAAAAoAAAABAAAAIgIDVFdXzjXPHt+xO54sSi+c4Aq4w2vuEryiM3zlg/0orsgUzBiuCAAAAAAAAAAACgAAAAEAAAAAAQFpUiEC1tEUC9LA+RTLMMmSqi/NKD9HGpKBzuyexsW8RI5oaQAhA7hVqHWO2mhjZIRFqdPPuVOIrKF0YhrZjwmaHE+TJv7HIQKV97Un0upTek1CgwQQq/Q0BzG/myDlSXIAGTO5qiNTbFOuIgIClfe1J9LqU3pNQoMEEKv0NAcxv5sg5UlyABkzuaojU2wU9lzYaQAAAAAAAAAAFAAAAAIAAAAiAgLW0RQL0sD5FMswyZKqL80oP0cakoHO7J7GxbxEjmhpABTy7wOJAAAAAAAAAAAUAAAAAgAAACICA7hVqHWO2mhjZIRFqdPPuVOIrKF0YhrZjwmaHE+TJv7HFMwYrggAAAAAAAAAABQAAAACAAAAAAEAaVIhAnW3o2P1KjiHgGZA82Y3dkWJBy4XbWtqh9fHVBB1dkylIQJMuJ9uP8jjgLzgDGp+FiT0wO5c8HY0i11yRZ15t46VDCEDTFl0wN7rjobIrI9s+lId2D1ITT+RAM/uDWr17RQgKLpTriICAky4n24/yOOAvOAMan4WJPTA7lzwdjSLXXJFnXm3jpUMFNStg3IAAAAAAAAAAAAAAAADAAAAIgICdbejY/UqOIeAZkDzZjd2RYkHLhdta2qH18dUEHV2TKUUVH9FdgAAAAAAAAAAAAAAAAMAAAAiAgNMWXTA3uuOhsisj2z6Uh3YPUhNP5EAz+4NavXtFCAouhRAXGW9AAAAAAAAAAAAAAAAAwAAAAAAAA==", + }, + { + name: "Bitcoingold PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoingold PSBT (Halfsigned)", + type: "psbt", + data: "cHNidP8BAP1zAQIAAAAE1d91MFdo7eEBoxU8tq8ozGHNyoFlG9+jaqfEQENJ5e0AAAAAAP/////ZrJ/8C45dE8o8AXqI8g0isxHPSazKqNvLTtJveVWdmwEAAAAA/////w6oPib2sAMmwUJCVhLc+iBCMDIdyHmXryeTcc5Fxth3AgAAAAD/////uEowcd9r50/zStLQP3RlA7HmnVNAnijdgMJw2EO8ZqkDAAAAAP////8GhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFAVBJxIdN/MiZs2WfEhUBJdqZ63wh4QDAAAAAAAAIgAgukjj+YdEY5Q/kBkqRfGuiVt3k2KnYpr3rWqdeoNePU+EAwAAAAAAABepFPxkGJFgS95wVikwC26N5fZ905Jih4QDAAAAAAAAF6kU9s9lApZzz5LgsOaQjFq5B5Uxai2HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEAvgIAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAa0gwRQIhAPUYu8uFyBaFI1ULQglnUKkejtCi+T+7pFx0kqIkfccmAiB61WKxWM5NedPC63rgpXP5qEE9lcP/FhHCl/fxzoKhnwEhA70MNLI3Pjh1dc3bED7AORbDEETyUI4mH+NZeiaA7L0f/////wHQBwAAAAAAABepFFZ817RPnzoHwxOPN7+YS2D7uvJDhwAAAAAiAgP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+f0cwRAIgQ2st9zautY5kbkVi/3EEyBHeE68eTBiqZ9TLhngh2dACIG0pAr7ceMBBtfayDkOGzdIkePE7H8+lKPHdogHH04YcQQEDBEEAAAABBGlSIQP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+fyEDX/t6vHAVngRp9LmJptXheFopBBaf8FCy9Gj+XT1du/IhA+FSTX9vxXqz6su2WbeHEGeApHXR20g5UsIxC36aOJdbU64iBgNf+3q8cBWeBGn0uYmm1eF4WikEFp/wULL0aP5dPV278hTMGK4IAAAAAAAAAAABAAAAAAAAACIGA+FSTX9vxXqz6su2WbeHEGeApHXR20g5UsIxC36aOJdbFPZc2GkAAAAAAAAAAAEAAAAAAAAAIgYD9vQHZL1dY/IAoneIg6z3XpbxUJXJmCY8CHJw0Ml+fn8U8u8DiQAAAAAAAAAAAQAAAAAAAAAAAQEg0AcAAAAAAAAXqRQOJrJdDOrm+c/z7azKoNGnDadgD4ciAgKlhfP6tJte+VNG2TIiGiIb1V7BkfFVM+DycLNYJXTwNUgwRQIhAPEYjTHlz0/wMasFULMQ4Ke3mejSeuGdQPh6cgCDrgt3AiAx9fIxNpbC9YjUitV0OtFmkEddZwcxGsM1qug4ftX6uEEBAwRBAAAAAQQiACBG1IAKE5MzAZYIU5ntShcAtML9OMUhiMOjqR9yHzyWAAEFaVIhAqWF8/q0m175U0bZMiIaIhvVXsGR8VUz4PJws1gldPA1IQLE94Zs/VmWvBBoqWMTyhXpzLXphFg6BzQN3a568BRgWyECI0UxvJEZo2p5Rula63SRXdCHx7RPUXuO7rc/iaD/GplTriIGAiNFMbyRGaNqeUbpWut0kV3Qh8e0T1F7ju63P4mg/xqZFPZc2GkAAAAAAAAAAAsAAAABAAAAIgYCpYXz+rSbXvlTRtkyIhoiG9VewZHxVTPg8nCzWCV08DUU8u8DiQAAAAAAAAAACwAAAAEAAAAiBgLE94Zs/VmWvBBoqWMTyhXpzLXphFg6BzQN3a568BRgWxTMGK4IAAAAAAAAAAALAAAAAQAAAAABASvQBwAAAAAAACIAINsEJ/GCK0d3Zw5mc8KK8C9todWv5xpx9ckGRHCyKfr9IgIDUZ5XKrRoVg0fjQ+HaZ0JgwjhZpBfXcrkOQ8GD6qPHONIMEUCIQDqCwBk0m1PtqIs7Y3SW5cBOfuXRE7XXKEWlAg4S/C5hwIgRakB5vTxOVmBSJz+ySJSgkDALyeIVMW3eM56tPW3tnxBAQMEQQAAAAEFaVIhA1GeVyq0aFYNH40Ph2mdCYMI4WaQX13K5DkPBg+qjxzjIQOgW8JjkSIdaF4Y2q/zah6Vw0+ZRRJTwWzUJlDbJ4p5ESEC6AoIiFw1Nna4IM3CkObYGgrJWgPoq79Lt67r+3D+tBhTriIGAugKCIhcNTZ2uCDNwpDm2BoKyVoD6Ku/S7eu6/tw/rQYFPZc2GkAAAAAAAAAABUAAAACAAAAIgYDUZ5XKrRoVg0fjQ+HaZ0JgwjhZpBfXcrkOQ8GD6qPHOMU8u8DiQAAAAAAAAAAFQAAAAIAAAAiBgOgW8JjkSIdaF4Y2q/zah6Vw0+ZRRJTwWzUJlDbJ4p5ERTMGK4IAAAAAAAAAAAVAAAAAgAAAAABAP0jAQIAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAakcwRAIgb00cpiqTuakbHOajy1VcFlSbQWx/cqkfvYPwipMluJ0CIE/2MMys6Z82aG7z5l3MLxET0eItfogKQ2hJMaTW4ysfASEDvQw0sjc+OHV1zdsQPsA5FsMQRPJQjiYf41l6JoDsvR//////BNAHAAAAAAAAGXapFIg62NGv/finPL2vcje1xauewsMmiKzQBwAAAAAAABl2qRSIOtjRr/34pzy9r3I3tcWrnsLDJois0AcAAAAAAAAZdqkUiDrY0a/9+Kc8va9yN7XFq57CwyaIrNAHAAAAAAAAF6kUILNwlNgqUTRR/wzNnbI6ugW8XvOHAAAAACICAzbvIo/+m47/+6BSwy0zRmDdH4Nmz4/kSuWqZytrYpCVRzBEAiADB2wJwJwom7blukd/gnqv1xPBWx/lZ9RCCXF1oiAt3AIgMh1MhGkj9FMOPDSkDDhsytAxWGqRm2P1wWQ1xrNObbFBAQMEQQAAAAEEIyEDNu8ij/6bjv/7oFLDLTNGYN0fg2bPj+RK5apnK2tikJWsAAEAaVIhAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJIQLXL9DQ2QKTQ0rV/KFg8njgPGFEl6pOQlz0VOLBMw+WqyEDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvFTriICAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJFPLvA4kAAAAAAAAAAAAAAAAAAAAAIgIC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqsUzBiuCAAAAAAAAAAAAAAAAAAAAAAiAgNE2IQTbfVQIChl/7xiGMf5yI/mzjnJRXmBkLrbOKdS8RT2XNhpAAAAAAAAAAAAAAAAAAAAAAABACIAICkrBSNRo8b4DVG65kLMiCEYKJPb7tq8j10OlndHYCbBAQFpUiEDLhH5hVJoX+kH8x+ecmDJBujecA8MPJ8vFBBiPc39GcAhA1RXV841zx7fsTueLEovnOAKuMNr7hK8ojN85YP9KK7IIQKjz7ZmX+RPdSC2obTeGk1GZDs4XrH9Hgq3DvuWVCl1VFOuIgICo8+2Zl/kT3UgtqG03hpNRmQ7OF6x/R4Ktw77llQpdVQU9lzYaQAAAAAAAAAACgAAAAEAAAAiAgMuEfmFUmhf6QfzH55yYMkG6N5wDww8ny8UEGI9zf0ZwBTy7wOJAAAAAAAAAAAKAAAAAQAAACICA1RXV841zx7fsTueLEovnOAKuMNr7hK8ojN85YP9KK7IFMwYrggAAAAAAAAAAAoAAAABAAAAAAEBaVIhAtbRFAvSwPkUyzDJkqovzSg/RxqSgc7snsbFvESOaGkAIQO4Vah1jtpoY2SERanTz7lTiKyhdGIa2Y8JmhxPkyb+xyEClfe1J9LqU3pNQoMEEKv0NAcxv5sg5UlyABkzuaojU2xTriICApX3tSfS6lN6TUKDBBCr9DQHMb+bIOVJcgAZM7mqI1NsFPZc2GkAAAAAAAAAABQAAAACAAAAIgIC1tEUC9LA+RTLMMmSqi/NKD9HGpKBzuyexsW8RI5oaQAU8u8DiQAAAAAAAAAAFAAAAAIAAAAiAgO4Vah1jtpoY2SERanTz7lTiKyhdGIa2Y8JmhxPkyb+xxTMGK4IAAAAAAAAAAAUAAAAAgAAAAABAGlSIQJ1t6Nj9So4h4BmQPNmN3ZFiQcuF21raofXx1QQdXZMpSECTLifbj/I44C84AxqfhYk9MDuXPB2NItdckWdebeOlQwhA0xZdMDe646GyKyPbPpSHdg9SE0/kQDP7g1q9e0UICi6U64iAgJMuJ9uP8jjgLzgDGp+FiT0wO5c8HY0i11yRZ15t46VDBTUrYNyAAAAAAAAAAAAAAAAAwAAACICAnW3o2P1KjiHgGZA82Y3dkWJBy4XbWtqh9fHVBB1dkylFFR/RXYAAAAAAAAAAAAAAAADAAAAIgIDTFl0wN7rjobIrI9s+lId2D1ITT+RAM/uDWr17RQgKLoUQFxlvQAAAAAAAAAAAAAAAAMAAAAAAAA=", + }, + { + name: "Bitcoingold PSBT (Unsigned)", + type: "psbt", + data: "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", + }, + { + name: "Bitcoingold TX (Extracted)", + type: "tx", + data: "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", + }, + { + name: "Dash Lite PSBT (Finalized)", + type: "psbt", + data: "cHNidP8BANYBAAAAAnzOEu/8LqVkxCJzM/0wVEfg3ns656X8x1Hv//PqE3fhAAAAAAD/////Q0P053icjhyiKz//jAorgodKqlv5a0Unr/vgYL+rA6wBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHAQf8AEcwRAIgd3T3UzbiFD9ViC5fW0qZCdxcqXsACN+VfjrnQNOtTUECIGmC8iksQMV1sLOxV2hyMckuaFamYO+GsadRTwbG7qZ1AUcwRAIgFTgEICUPtILM1ZidZJ/jkThwG82hvOyxWy9LuMtMtsQCIGYJjuYWdPyoCu3KeAdYxA/MS9fBMzszoLYTfXl3yZixAUxpUiED9vQHZL1dY/IAoneIg6z3XpbxUJXJmCY8CHJw0Ml+fn8hA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyIQPhUk1/b8V6s+rLtlm3hxBngKR10dtIOVLCMQt+mjiXW1OuAAEBINAHAAAAAAAAF6kUILNwlNgqUTRR/wzNnbI6ugW8XvOHAQdsRzBEAiAPmE66M5KL/DR3I1dcU21Ofzw0a3ETt2PkJNPghfAFkQIgG+nI4qATYsv2FDETjO51TrQIvJVbqizIiXb5dpfLIi0BIyEDNu8ij/6bjv/7oFLDLTNGYN0fg2bPj+RK5apnK2tikJWsAAEAaVIhAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJIQLXL9DQ2QKTQ0rV/KFg8njgPGFEl6pOQlz0VOLBMw+WqyEDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvFTriICAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJFPLvA4kAAAAAAAAAAAAAAAAAAAAAIgIC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqsUzBiuCAAAAAAAAAAAAAAAAAAAAAAiAgNE2IQTbfVQIChl/7xiGMf5yI/mzjnJRXmBkLrbOKdS8RT2XNhpAAAAAAAAAAAAAAAAAAAAAAABAGlSIQNreRC1kdOnVtXudaXozA4n50XoVTD+q9J9T1hHpQ8whiECr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0hA0omsDbfD18D30R00HkkqYoF4RuiWER24a3bRIKs6kARU64iAgKv4S1XfRogo+2vwv09JVrOfRuLGD0K+d0/vlv1VDq8fRTUrYNyAAAAAAAAAAAAAAAAAQAAACICA0omsDbfD18D30R00HkkqYoF4RuiWER24a3bRIKs6kARFEBcZb0AAAAAAAAAAAAAAAABAAAAIgIDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYUVH9FdgAAAAAAAAAAAAAAAAEAAAAAAAA=", + }, + { + name: "Dash Lite PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Dash Lite PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Dash Lite PSBT (Unsigned)", + type: "psbt", + data: "cHNidP8BANYBAAAAAnzOEu/8LqVkxCJzM/0wVEfg3ns656X8x1Hv//PqE3fhAAAAAAD/////Q0P053icjhyiKz//jAorgodKqlv5a0Unr/vgYL+rA6wBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHAQMEAQAAAAEEaVIhA/b0B2S9XWPyAKJ3iIOs916W8VCVyZgmPAhycNDJfn5/IQNf+3q8cBWeBGn0uYmm1eF4WikEFp/wULL0aP5dPV278iED4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1tTriIGA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyFMwYrggAAAAAAAAAAAEAAAAAAAAAIgYD4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1sU9lzYaQAAAAAAAAAAAQAAAAAAAAAiBgP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+fxTy7wOJAAAAAAAAAAABAAAAAAAAAAABASDQBwAAAAAAABepFCCzcJTYKlE0Uf8MzZ2yOroFvF7zhwEDBAEAAAABBCMhAzbvIo/+m47/+6BSwy0zRmDdH4Nmz4/kSuWqZytrYpCVrAABAGlSIQLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCSEC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqshA0TYhBNt9VAgKGX/vGIYx/nIj+bOOclFeYGQuts4p1LxU64iAgLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCRTy7wOJAAAAAAAAAAAAAAAAAAAAACICAtcv0NDZApNDStX8oWDyeOA8YUSXqk5CXPRU4sEzD5arFMwYrggAAAAAAAAAAAAAAAAAAAAAIgIDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvEU9lzYaQAAAAAAAAAAAAAAAAAAAAAAAQBpUiEDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYhAq/hLVd9GiCj7a/C/T0lWs59G4sYPQr53T++W/VUOrx9IQNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAEVOuIgICr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0U1K2DcgAAAAAAAAAAAAAAAAEAAAAiAgNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAERRAXGW9AAAAAAAAAAAAAAAAAQAAACICA2t5ELWR06dW1e51pejMDifnRehVMP6r0n1PWEelDzCGFFR/RXYAAAAAAAAAAAAAAAABAAAAAAAA", + }, + { + name: "Dash Lite TX (Extracted)", + type: "tx", + data: "01000000027cce12effc2ea564c4227333fd305447e0de7b3ae7a5fcc751effff3ea1377e100000000fc0047304402207774f75336e2143f55882e5f5b4a9909dc5ca97b0008df957e3ae740d3ad4d4102206982f2292c40c575b0b3b157687231c92e6856a660ef86b1a7514f06c6eea67501473044022015380420250fb482ccd5989d649fe39138701bcda1bcecb15b2f4bb8cb4cb6c4022066098ee61674fca80aedca780758c40fcc4bd7c1333b33a0b6137d7977c998b1014c69522103f6f40764bd5d63f200a2778883acf75e96f15095c998263c087270d0c97e7e7f21035ffb7abc70159e0469f4b989a6d5e1785a2904169ff050b2f468fe5d3d5dbbf22103e1524d7f6fc57ab3eacbb659b787106780a475d1db483952c2310b7e9a38975b53aeffffffff4343f4e7789c8e1ca22b3fff8c0a2b82874aaa5bf96b4527affbe060bfab03ac010000006c47304402200f984eba33928bfc347723575c536d4e7f3c346b7113b763e424d3e085f0059102201be9c8e2a01362cbf61431138cee754eb408bc955baa2cc88976f97697cb222d0123210336ef228ffe9b8efffba052c32d334660dd1f8366cf8fe44ae5aa672b6b629095acffffffff04840300000000000017a914d909474404c124a3d04c3fbff61faa49cf43c58b87840300000000000017a9144efd761e9be61caa421c8aac4a902ad6f2a54bcf87840300000000000017a914d24d3816be8a250cbdde7eaa674f80170cda944e870000000000000000116a0f736574656320617374726f6e6f6d7900000000", + }, + { + name: "Dash PSBT (Finalized)", + type: "psbt", + data: "cHNidP8BANYBAAAAAnzOEu/8LqVkxCJzM/0wVEfg3ns656X8x1Hv//PqE3fhAAAAAAD/////Q0P053icjhyiKz//jAorgodKqlv5a0Unr/vgYL+rA6wBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEAvgEAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAa0gwRQIhAPgzk573ViMHluiX3f+QFzSlryObFIEGKBZNex1+acf9AiBCbT2kKbhsehXKhr1tLhbgYPwkvMQnjpbmp0MFK/DtfAEhA70MNLI3Pjh1dc3bED7AORbDEETyUI4mH+NZeiaA7L0f/////wHQBwAAAAAAABepFFZ817RPnzoHwxOPN7+YS2D7uvJDhwAAAAABB/wARzBEAiB3dPdTNuIUP1WILl9bSpkJ3FypewAI35V+OudA061NQQIgaYLyKSxAxXWws7FXaHIxyS5oVqZg74axp1FPBsbupnUBRzBEAiAVOAQgJQ+0gszVmJ1kn+OROHAbzaG87LFbL0u4y0y2xAIgZgmO5hZ0/KgK7cp4B1jED8xL18EzOzOgthN9eXfJmLEBTGlSIQP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+fyEDX/t6vHAVngRp9LmJptXheFopBBaf8FCy9Gj+XT1du/IhA+FSTX9vxXqz6su2WbeHEGeApHXR20g5UsIxC36aOJdbU64AAQDgAQAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAABrSDBFAiEAucaAv8b0tIw1+uPKcLj2CKcKePqfM0bi97FBcSCP+dsCIEcgLFCFq14QztseU/pTipsfivAApfPpamsciz/bbAjrASEDvQw0sjc+OHV1zdsQPsA5FsMQRPJQjiYf41l6JoDsvR//////AtAHAAAAAAAAGXapFIg62NGv/finPL2vcje1xauewsMmiKzQBwAAAAAAABepFCCzcJTYKlE0Uf8MzZ2yOroFvF7zhwAAAAABB2xHMEQCIA+YTrozkov8NHcjV1xTbU5/PDRrcRO3Y+Qk0+CF8AWRAiAb6cjioBNiy/YUMROM7nVOtAi8lVuqLMiJdvl2l8siLQEjIQM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlawAAQBpUiECzE0PpBHKwkRIb46ywI4DX/dBD0YKNZyn+IEJkb07QgkhAtcv0NDZApNDStX8oWDyeOA8YUSXqk5CXPRU4sEzD5arIQNE2IQTbfVQIChl/7xiGMf5yI/mzjnJRXmBkLrbOKdS8VOuIgICzE0PpBHKwkRIb46ywI4DX/dBD0YKNZyn+IEJkb07QgkU8u8DiQAAAAAAAAAAAAAAAAAAAAAiAgLXL9DQ2QKTQ0rV/KFg8njgPGFEl6pOQlz0VOLBMw+WqxTMGK4IAAAAAAAAAAAAAAAAAAAAACICA0TYhBNt9VAgKGX/vGIYx/nIj+bOOclFeYGQuts4p1LxFPZc2GkAAAAAAAAAAAAAAAAAAAAAAAEAaVIhA2t5ELWR06dW1e51pejMDifnRehVMP6r0n1PWEelDzCGIQKv4S1XfRogo+2vwv09JVrOfRuLGD0K+d0/vlv1VDq8fSEDSiawNt8PXwPfRHTQeSSpigXhG6JYRHbhrdtEgqzqQBFTriICAq/hLVd9GiCj7a/C/T0lWs59G4sYPQr53T++W/VUOrx9FNStg3IAAAAAAAAAAAAAAAABAAAAIgIDSiawNt8PXwPfRHTQeSSpigXhG6JYRHbhrdtEgqzqQBEUQFxlvQAAAAAAAAAAAAAAAAEAAAAiAgNreRC1kdOnVtXudaXozA4n50XoVTD+q9J9T1hHpQ8whhRUf0V2AAAAAAAAAAAAAAAAAQAAAAAAAA==", + }, + { + name: "Dash PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Dash PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Dash PSBT (Unsigned)", + type: "psbt", + data: "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", + }, + { + name: "Dash TX (Extracted)", + type: "tx", + data: "01000000027cce12effc2ea564c4227333fd305447e0de7b3ae7a5fcc751effff3ea1377e100000000fc0047304402207774f75336e2143f55882e5f5b4a9909dc5ca97b0008df957e3ae740d3ad4d4102206982f2292c40c575b0b3b157687231c92e6856a660ef86b1a7514f06c6eea67501473044022015380420250fb482ccd5989d649fe39138701bcda1bcecb15b2f4bb8cb4cb6c4022066098ee61674fca80aedca780758c40fcc4bd7c1333b33a0b6137d7977c998b1014c69522103f6f40764bd5d63f200a2778883acf75e96f15095c998263c087270d0c97e7e7f21035ffb7abc70159e0469f4b989a6d5e1785a2904169ff050b2f468fe5d3d5dbbf22103e1524d7f6fc57ab3eacbb659b787106780a475d1db483952c2310b7e9a38975b53aeffffffff4343f4e7789c8e1ca22b3fff8c0a2b82874aaa5bf96b4527affbe060bfab03ac010000006c47304402200f984eba33928bfc347723575c536d4e7f3c346b7113b763e424d3e085f0059102201be9c8e2a01362cbf61431138cee754eb408bc955baa2cc88976f97697cb222d0123210336ef228ffe9b8efffba052c32d334660dd1f8366cf8fe44ae5aa672b6b629095acffffffff04840300000000000017a914d909474404c124a3d04c3fbff61faa49cf43c58b87840300000000000017a9144efd761e9be61caa421c8aac4a902ad6f2a54bcf87840300000000000017a914d24d3816be8a250cbdde7eaa674f80170cda944e870000000000000000116a0f736574656320617374726f6e6f6d7900000000", + }, + { + name: "Dogecoin Lite PSBT (Finalized)", + type: "psbt", + data: "cHNidP8BANYBAAAAAnzOEu/8LqVkxCJzM/0wVEfg3ns656X8x1Hv//PqE3fhAAAAAAD/////Q0P053icjhyiKz//jAorgodKqlv5a0Unr/vgYL+rA6wBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHAQf8AEcwRAIgd3T3UzbiFD9ViC5fW0qZCdxcqXsACN+VfjrnQNOtTUECIGmC8iksQMV1sLOxV2hyMckuaFamYO+GsadRTwbG7qZ1AUcwRAIgFTgEICUPtILM1ZidZJ/jkThwG82hvOyxWy9LuMtMtsQCIGYJjuYWdPyoCu3KeAdYxA/MS9fBMzszoLYTfXl3yZixAUxpUiED9vQHZL1dY/IAoneIg6z3XpbxUJXJmCY8CHJw0Ml+fn8hA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyIQPhUk1/b8V6s+rLtlm3hxBngKR10dtIOVLCMQt+mjiXW1OuAAEBINAHAAAAAAAAF6kUILNwlNgqUTRR/wzNnbI6ugW8XvOHAQdsRzBEAiAPmE66M5KL/DR3I1dcU21Ofzw0a3ETt2PkJNPghfAFkQIgG+nI4qATYsv2FDETjO51TrQIvJVbqizIiXb5dpfLIi0BIyEDNu8ij/6bjv/7oFLDLTNGYN0fg2bPj+RK5apnK2tikJWsAAEAaVIhAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJIQLXL9DQ2QKTQ0rV/KFg8njgPGFEl6pOQlz0VOLBMw+WqyEDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvFTriICAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJFPLvA4kAAAAAAAAAAAAAAAAAAAAAIgIC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqsUzBiuCAAAAAAAAAAAAAAAAAAAAAAiAgNE2IQTbfVQIChl/7xiGMf5yI/mzjnJRXmBkLrbOKdS8RT2XNhpAAAAAAAAAAAAAAAAAAAAAAABAGlSIQNreRC1kdOnVtXudaXozA4n50XoVTD+q9J9T1hHpQ8whiECr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0hA0omsDbfD18D30R00HkkqYoF4RuiWER24a3bRIKs6kARU64iAgKv4S1XfRogo+2vwv09JVrOfRuLGD0K+d0/vlv1VDq8fRTUrYNyAAAAAAAAAAAAAAAAAQAAACICA0omsDbfD18D30R00HkkqYoF4RuiWER24a3bRIKs6kARFEBcZb0AAAAAAAAAAAAAAAABAAAAIgIDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYUVH9FdgAAAAAAAAAAAAAAAAEAAAAAAAA=", + }, + { + name: "Dogecoin Lite PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Dogecoin Lite PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Dogecoin Lite PSBT (Unsigned)", + type: "psbt", + data: "cHNidP8BANYBAAAAAnzOEu/8LqVkxCJzM/0wVEfg3ns656X8x1Hv//PqE3fhAAAAAAD/////Q0P053icjhyiKz//jAorgodKqlv5a0Unr/vgYL+rA6wBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHAQMEAQAAAAEEaVIhA/b0B2S9XWPyAKJ3iIOs916W8VCVyZgmPAhycNDJfn5/IQNf+3q8cBWeBGn0uYmm1eF4WikEFp/wULL0aP5dPV278iED4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1tTriIGA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyFMwYrggAAAAAAAAAAAEAAAAAAAAAIgYD4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1sU9lzYaQAAAAAAAAAAAQAAAAAAAAAiBgP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+fxTy7wOJAAAAAAAAAAABAAAAAAAAAAABASDQBwAAAAAAABepFCCzcJTYKlE0Uf8MzZ2yOroFvF7zhwEDBAEAAAABBCMhAzbvIo/+m47/+6BSwy0zRmDdH4Nmz4/kSuWqZytrYpCVrAABAGlSIQLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCSEC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqshA0TYhBNt9VAgKGX/vGIYx/nIj+bOOclFeYGQuts4p1LxU64iAgLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCRTy7wOJAAAAAAAAAAAAAAAAAAAAACICAtcv0NDZApNDStX8oWDyeOA8YUSXqk5CXPRU4sEzD5arFMwYrggAAAAAAAAAAAAAAAAAAAAAIgIDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvEU9lzYaQAAAAAAAAAAAAAAAAAAAAAAAQBpUiEDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYhAq/hLVd9GiCj7a/C/T0lWs59G4sYPQr53T++W/VUOrx9IQNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAEVOuIgICr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0U1K2DcgAAAAAAAAAAAAAAAAEAAAAiAgNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAERRAXGW9AAAAAAAAAAAAAAAAAQAAACICA2t5ELWR06dW1e51pejMDifnRehVMP6r0n1PWEelDzCGFFR/RXYAAAAAAAAAAAAAAAABAAAAAAAA", + }, + { + name: "Dogecoin Lite TX (Extracted)", + type: "tx", + data: "01000000027cce12effc2ea564c4227333fd305447e0de7b3ae7a5fcc751effff3ea1377e100000000fc0047304402207774f75336e2143f55882e5f5b4a9909dc5ca97b0008df957e3ae740d3ad4d4102206982f2292c40c575b0b3b157687231c92e6856a660ef86b1a7514f06c6eea67501473044022015380420250fb482ccd5989d649fe39138701bcda1bcecb15b2f4bb8cb4cb6c4022066098ee61674fca80aedca780758c40fcc4bd7c1333b33a0b6137d7977c998b1014c69522103f6f40764bd5d63f200a2778883acf75e96f15095c998263c087270d0c97e7e7f21035ffb7abc70159e0469f4b989a6d5e1785a2904169ff050b2f468fe5d3d5dbbf22103e1524d7f6fc57ab3eacbb659b787106780a475d1db483952c2310b7e9a38975b53aeffffffff4343f4e7789c8e1ca22b3fff8c0a2b82874aaa5bf96b4527affbe060bfab03ac010000006c47304402200f984eba33928bfc347723575c536d4e7f3c346b7113b763e424d3e085f0059102201be9c8e2a01362cbf61431138cee754eb408bc955baa2cc88976f97697cb222d0123210336ef228ffe9b8efffba052c32d334660dd1f8366cf8fe44ae5aa672b6b629095acffffffff04840300000000000017a914d909474404c124a3d04c3fbff61faa49cf43c58b87840300000000000017a9144efd761e9be61caa421c8aac4a902ad6f2a54bcf87840300000000000017a914d24d3816be8a250cbdde7eaa674f80170cda944e870000000000000000116a0f736574656320617374726f6e6f6d7900000000", + }, + { + name: "Dogecoin PSBT (Finalized)", + type: "psbt", + data: "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", + }, + { + name: "Dogecoin PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Dogecoin PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Dogecoin PSBT (Unsigned)", + type: "psbt", + data: "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", + }, + { + name: "Dogecoin TX (Extracted)", + type: "tx", + data: "01000000027cce12effc2ea564c4227333fd305447e0de7b3ae7a5fcc751effff3ea1377e100000000fc0047304402207774f75336e2143f55882e5f5b4a9909dc5ca97b0008df957e3ae740d3ad4d4102206982f2292c40c575b0b3b157687231c92e6856a660ef86b1a7514f06c6eea67501473044022015380420250fb482ccd5989d649fe39138701bcda1bcecb15b2f4bb8cb4cb6c4022066098ee61674fca80aedca780758c40fcc4bd7c1333b33a0b6137d7977c998b1014c69522103f6f40764bd5d63f200a2778883acf75e96f15095c998263c087270d0c97e7e7f21035ffb7abc70159e0469f4b989a6d5e1785a2904169ff050b2f468fe5d3d5dbbf22103e1524d7f6fc57ab3eacbb659b787106780a475d1db483952c2310b7e9a38975b53aeffffffff4343f4e7789c8e1ca22b3fff8c0a2b82874aaa5bf96b4527affbe060bfab03ac010000006c47304402200f984eba33928bfc347723575c536d4e7f3c346b7113b763e424d3e085f0059102201be9c8e2a01362cbf61431138cee754eb408bc955baa2cc88976f97697cb222d0123210336ef228ffe9b8efffba052c32d334660dd1f8366cf8fe44ae5aa672b6b629095acffffffff04840300000000000017a914d909474404c124a3d04c3fbff61faa49cf43c58b87840300000000000017a9144efd761e9be61caa421c8aac4a902ad6f2a54bcf87840300000000000017a914d24d3816be8a250cbdde7eaa674f80170cda944e870000000000000000116a0f736574656320617374726f6e6f6d7900000000", + }, + { + name: "Ecash Lite PSBT (Finalized)", + type: "psbt", + data: "cHNidP8BANYCAAAAAtXfdTBXaO3hAaMVPLavKMxhzcqBZRvfo2qnxEBDSeXtAAAAAAD/////AWwmXH9/BmqsmzByVuaOTbCQFWkakkLlHO5gfQAfp/MBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHAQf9/QAARzBEAiAl3cP2yVD9Ntv+YcJ5b1zD/S9XFwCOlXkNk+9nfXYyBgIgAclrPDfm1WnnoeQg908H+Uyul3x5AraJDdHIJJdT5KRBSDBFAiEA0Lwfy+ZkxgQW3eeY3eIEz+sm2sRA4dXwwcgPLmjBDyACIAynTh4KfUzeAYVRUMzilU7hSbZprrYJRHh0U4r8PLWWQUxpUiED9vQHZL1dY/IAoneIg6z3XpbxUJXJmCY8CHJw0Ml+fn8hA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyIQPhUk1/b8V6s+rLtlm3hxBngKR10dtIOVLCMQt+mjiXW1OuAAEBINAHAAAAAAAAF6kUILNwlNgqUTRR/wzNnbI6ugW8XvOHAQdsRzBEAiASlkVIyCpGZvmIL8kkbtVVt4TqLq4ThNyQ1LngkbFlsgIgNFvVDciI/72SGZikKDO2d+HgexLxv2ppRrydatC5JcxBIyEDNu8ij/6bjv/7oFLDLTNGYN0fg2bPj+RK5apnK2tikJWsAAEAaVIhAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJIQLXL9DQ2QKTQ0rV/KFg8njgPGFEl6pOQlz0VOLBMw+WqyEDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvFTriICAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJFPLvA4kAAAAAAAAAAAAAAAAAAAAAIgIC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqsUzBiuCAAAAAAAAAAAAAAAAAAAAAAiAgNE2IQTbfVQIChl/7xiGMf5yI/mzjnJRXmBkLrbOKdS8RT2XNhpAAAAAAAAAAAAAAAAAAAAAAABAGlSIQNreRC1kdOnVtXudaXozA4n50XoVTD+q9J9T1hHpQ8whiECr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0hA0omsDbfD18D30R00HkkqYoF4RuiWER24a3bRIKs6kARU64iAgKv4S1XfRogo+2vwv09JVrOfRuLGD0K+d0/vlv1VDq8fRTUrYNyAAAAAAAAAAAAAAAAAQAAACICA0omsDbfD18D30R00HkkqYoF4RuiWER24a3bRIKs6kARFEBcZb0AAAAAAAAAAAAAAAABAAAAIgIDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYUVH9FdgAAAAAAAAAAAAAAAAEAAAAAAAA=", + }, + { + name: "Ecash Lite PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Ecash Lite PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Ecash Lite PSBT (Unsigned)", + type: "psbt", + data: "cHNidP8BANYCAAAAAtXfdTBXaO3hAaMVPLavKMxhzcqBZRvfo2qnxEBDSeXtAAAAAAD/////AWwmXH9/BmqsmzByVuaOTbCQFWkakkLlHO5gfQAfp/MBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHAQMEQQAAAAEEaVIhA/b0B2S9XWPyAKJ3iIOs916W8VCVyZgmPAhycNDJfn5/IQNf+3q8cBWeBGn0uYmm1eF4WikEFp/wULL0aP5dPV278iED4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1tTriIGA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyFMwYrggAAAAAAAAAAAEAAAAAAAAAIgYD4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1sU9lzYaQAAAAAAAAAAAQAAAAAAAAAiBgP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+fxTy7wOJAAAAAAAAAAABAAAAAAAAAAABASDQBwAAAAAAABepFCCzcJTYKlE0Uf8MzZ2yOroFvF7zhwEDBEEAAAABBCMhAzbvIo/+m47/+6BSwy0zRmDdH4Nmz4/kSuWqZytrYpCVrAABAGlSIQLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCSEC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqshA0TYhBNt9VAgKGX/vGIYx/nIj+bOOclFeYGQuts4p1LxU64iAgLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCRTy7wOJAAAAAAAAAAAAAAAAAAAAACICAtcv0NDZApNDStX8oWDyeOA8YUSXqk5CXPRU4sEzD5arFMwYrggAAAAAAAAAAAAAAAAAAAAAIgIDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvEU9lzYaQAAAAAAAAAAAAAAAAAAAAAAAQBpUiEDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYhAq/hLVd9GiCj7a/C/T0lWs59G4sYPQr53T++W/VUOrx9IQNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAEVOuIgICr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0U1K2DcgAAAAAAAAAAAAAAAAEAAAAiAgNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAERRAXGW9AAAAAAAAAAAAAAAAAQAAACICA2t5ELWR06dW1e51pejMDifnRehVMP6r0n1PWEelDzCGFFR/RXYAAAAAAAAAAAAAAAABAAAAAAAA", + }, + { + name: "Ecash Lite TX (Extracted)", + type: "tx", + data: "0200000002d5df75305768ede101a3153cb6af28cc61cdca81651bdfa36aa7c4404349e5ed00000000fdfd0000473044022025ddc3f6c950fd36dbfe61c2796f5cc3fd2f5717008e95790d93ef677d763206022001c96b3c37e6d569e7a1e420f74f07f94cae977c7902b6890dd1c8249753e4a441483045022100d0bc1fcbe664c60416dde798dde204cfeb26dac440e1d5f0c1c80f2e68c10f2002200ca74e1e0a7d4cde01855150cce2954ee149b669aeb609447874538afc3cb596414c69522103f6f40764bd5d63f200a2778883acf75e96f15095c998263c087270d0c97e7e7f21035ffb7abc70159e0469f4b989a6d5e1785a2904169ff050b2f468fe5d3d5dbbf22103e1524d7f6fc57ab3eacbb659b787106780a475d1db483952c2310b7e9a38975b53aeffffffff016c265c7f7f066aac9b307256e68e4db09015691a9242e51cee607d001fa7f3010000006c473044022012964548c82a4666f9882fc9246ed555b784ea2eae1384dc90d4b9e091b165b20220345bd50dc888ffbd921998a42833b677e1e07b12f1bf6a6946bc9d6ad0b925cc4123210336ef228ffe9b8efffba052c32d334660dd1f8366cf8fe44ae5aa672b6b629095acffffffff04840300000000000017a914d909474404c124a3d04c3fbff61faa49cf43c58b87840300000000000017a9144efd761e9be61caa421c8aac4a902ad6f2a54bcf87840300000000000017a914d24d3816be8a250cbdde7eaa674f80170cda944e870000000000000000116a0f736574656320617374726f6e6f6d7900000000", + }, + { + name: "Ecash PSBT (Finalized)", + type: "psbt", + data: "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", + }, + { + name: "Ecash PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Ecash PSBT (Halfsigned)", + type: "psbt", + data: "cHNidP8BANYCAAAAAtXfdTBXaO3hAaMVPLavKMxhzcqBZRvfo2qnxEBDSeXtAAAAAAD/////AWwmXH9/BmqsmzByVuaOTbCQFWkakkLlHO5gfQAfp/MBAAAAAP////8EhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFE79dh6b5hyqQhyKrEqQKtbypUvPh4QDAAAAAAAAF6kU0k04Fr6KJQy93n6qZ0+AFwzalE6HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEAvgIAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAa0gwRQIhAPUYu8uFyBaFI1ULQglnUKkejtCi+T+7pFx0kqIkfccmAiB61WKxWM5NedPC63rgpXP5qEE9lcP/FhHCl/fxzoKhnwEhA70MNLI3Pjh1dc3bED7AORbDEETyUI4mH+NZeiaA7L0f/////wHQBwAAAAAAABepFFZ817RPnzoHwxOPN7+YS2D7uvJDhwAAAAAiAgP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+f0cwRAIgJd3D9slQ/Tbb/mHCeW9cw/0vVxcAjpV5DZPvZ312MgYCIAHJazw35tVp56HkIPdPB/lMrpd8eQK2iQ3RyCSXU+SkQQEDBEEAAAABBGlSIQP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+fyEDX/t6vHAVngRp9LmJptXheFopBBaf8FCy9Gj+XT1du/IhA+FSTX9vxXqz6su2WbeHEGeApHXR20g5UsIxC36aOJdbU64iBgNf+3q8cBWeBGn0uYmm1eF4WikEFp/wULL0aP5dPV278hTMGK4IAAAAAAAAAAABAAAAAAAAACIGA+FSTX9vxXqz6su2WbeHEGeApHXR20g5UsIxC36aOJdbFPZc2GkAAAAAAAAAAAEAAAAAAAAAIgYD9vQHZL1dY/IAoneIg6z3XpbxUJXJmCY8CHJw0Ml+fn8U8u8DiQAAAAAAAAAAAQAAAAAAAAAAAQDgAgAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAABrSDBFAiEAh1GJwylIvADZgbpATn6MzQ9sx/y0stnq8R7KROxurVkCIBlB2Xz1/IHWor6rvNs1T3GEnAKk1N4VAeMwRkHuowtHASEDvQw0sjc+OHV1zdsQPsA5FsMQRPJQjiYf41l6JoDsvR//////AtAHAAAAAAAAGXapFIg62NGv/finPL2vcje1xauewsMmiKzQBwAAAAAAABepFCCzcJTYKlE0Uf8MzZ2yOroFvF7zhwAAAAAiAgM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlUcwRAIgEpZFSMgqRmb5iC/JJG7VVbeE6i6uE4TckNS54JGxZbICIDRb1Q3IiP+9khmYpCgztnfh4HsS8b9qaUa8nWrQuSXMQQEDBEEAAAABBCMhAzbvIo/+m47/+6BSwy0zRmDdH4Nmz4/kSuWqZytrYpCVrAABAGlSIQLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCSEC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqshA0TYhBNt9VAgKGX/vGIYx/nIj+bOOclFeYGQuts4p1LxU64iAgLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCRTy7wOJAAAAAAAAAAAAAAAAAAAAACICAtcv0NDZApNDStX8oWDyeOA8YUSXqk5CXPRU4sEzD5arFMwYrggAAAAAAAAAAAAAAAAAAAAAIgIDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvEU9lzYaQAAAAAAAAAAAAAAAAAAAAAAAQBpUiEDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYhAq/hLVd9GiCj7a/C/T0lWs59G4sYPQr53T++W/VUOrx9IQNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAEVOuIgICr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0U1K2DcgAAAAAAAAAAAAAAAAEAAAAiAgNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAERRAXGW9AAAAAAAAAAAAAAAAAQAAACICA2t5ELWR06dW1e51pejMDifnRehVMP6r0n1PWEelDzCGFFR/RXYAAAAAAAAAAAAAAAABAAAAAAAA", + }, + { + name: "Ecash PSBT (Unsigned)", + type: "psbt", + data: "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", + }, + { + name: "Ecash TX (Extracted)", + type: "tx", + data: "0200000002d5df75305768ede101a3153cb6af28cc61cdca81651bdfa36aa7c4404349e5ed00000000fdfd0000473044022025ddc3f6c950fd36dbfe61c2796f5cc3fd2f5717008e95790d93ef677d763206022001c96b3c37e6d569e7a1e420f74f07f94cae977c7902b6890dd1c8249753e4a441483045022100d0bc1fcbe664c60416dde798dde204cfeb26dac440e1d5f0c1c80f2e68c10f2002200ca74e1e0a7d4cde01855150cce2954ee149b669aeb609447874538afc3cb596414c69522103f6f40764bd5d63f200a2778883acf75e96f15095c998263c087270d0c97e7e7f21035ffb7abc70159e0469f4b989a6d5e1785a2904169ff050b2f468fe5d3d5dbbf22103e1524d7f6fc57ab3eacbb659b787106780a475d1db483952c2310b7e9a38975b53aeffffffff016c265c7f7f066aac9b307256e68e4db09015691a9242e51cee607d001fa7f3010000006c473044022012964548c82a4666f9882fc9246ed555b784ea2eae1384dc90d4b9e091b165b20220345bd50dc888ffbd921998a42833b677e1e07b12f1bf6a6946bc9d6ad0b925cc4123210336ef228ffe9b8efffba052c32d334660dd1f8366cf8fe44ae5aa672b6b629095acffffffff04840300000000000017a914d909474404c124a3d04c3fbff61faa49cf43c58b87840300000000000017a9144efd761e9be61caa421c8aac4a902ad6f2a54bcf87840300000000000017a914d24d3816be8a250cbdde7eaa674f80170cda944e870000000000000000116a0f736574656320617374726f6e6f6d7900000000", + }, + { + name: "Litecoin Lite PSBT (Finalized)", + type: "psbt", + data: "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", + }, + { + name: "Litecoin Lite PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Litecoin Lite PSBT (Halfsigned)", + type: "psbt", + data: "cHNidP8BAP1zAQEAAAAEfM4S7/wupWTEInMz/TBUR+DeezrnpfzHUe//8+oTd+EAAAAAAP////+5x7KI/Wqg0UFZluKl2tmk4HDBKeF5J39T4y9gLxgGRgEAAAAA/////x9X2VYK6QcWALaWUzGS3Bd5kWT9P6EoBKf360IBxNXdAgAAAAD/////s+R4ljpxQ/cE8YzkwP7OMzyDM5Yy5wvdhjrCqJkVAmwDAAAAAP////8GhAMAAAAAAAAXqRTZCUdEBMEko9BMP7/2H6pJz0PFi4eEAwAAAAAAABepFAVBJxIdN/MiZs2WfEhUBJdqZ63wh4QDAAAAAAAAIgAgukjj+YdEY5Q/kBkqRfGuiVt3k2KnYpr3rWqdeoNePU+EAwAAAAAAABepFPxkGJFgS95wVikwC26N5fZ905Jih4QDAAAAAAAAF6kU9s9lApZzz5LgsOaQjFq5B5Uxai2HAAAAAAAAAAARag9zZXRlYyBhc3Ryb25vbXkAAAAATwEEiLIeAAAAAAAAAAAAOpIuKfDI6w2ypgSEy9y2MfaxB8nKrj/9zz59LsH2vNADEhSHFfNh2raFpmnUJDHl1tP5c0BNq5yf0blQsnmtdjQEzBiuCE8BBIiyHgAAAAAAAAAAAG0dZW093ZHBlMBFZaNgNwKiEBbO0UomXziYLWJ15ntkA9O6wjE6fGshy7EbFLDRA0H5IsCkA6i9jIfw3IIPNa9uBPZc2GlPAQSIsh4AAAAAAAAAAADLBP1jqzTZD+ZGa4gOKgLM+KhjN0MSmRr4kRsaqrRDNAM27yKP/puO//ugUsMtM0Zg3R+DZs+P5Erlqmcra2KQlQTy7wOJAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHIgID9vQHZL1dY/IAoneIg6z3XpbxUJXJmCY8CHJw0Ml+fn9HMEQCIHS/JsC2QdCDkrs5uLMjNLQQyKGxQ6PUVHtXKFtLPBFDAiBW/dVaPaHl88OX7kjlO91U8Wkd56H30djhGjZTlNU7KgEBAwQBAAAAAQRpUiED9vQHZL1dY/IAoneIg6z3XpbxUJXJmCY8CHJw0Ml+fn8hA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyIQPhUk1/b8V6s+rLtlm3hxBngKR10dtIOVLCMQt+mjiXW1OuIgYDX/t6vHAVngRp9LmJptXheFopBBaf8FCy9Gj+XT1du/IUzBiuCAAAAAAAAAAAAQAAAAAAAAAiBgPhUk1/b8V6s+rLtlm3hxBngKR10dtIOVLCMQt+mjiXWxT2XNhpAAAAAAAAAAABAAAAAAAAACIGA/b0B2S9XWPyAKJ3iIOs916W8VCVyZgmPAhycNDJfn5/FPLvA4kAAAAAAAAAAAEAAAAAAAAAAAEBINAHAAAAAAAAF6kUDiayXQzq5vnP8+2syqDRpw2nYA+HIgICpYXz+rSbXvlTRtkyIhoiG9VewZHxVTPg8nCzWCV08DVHMEQCIBekJEmX/3QgmdhHhyLwV6e/GaGyyRfnBe+YQUBHfMBAAiATwIY6I4UDMF82nugSXrndA03iDG/fQOzDyis+L2FN6wEBAwQBAAAAAQQiACBG1IAKE5MzAZYIU5ntShcAtML9OMUhiMOjqR9yHzyWAAEFaVIhAqWF8/q0m175U0bZMiIaIhvVXsGR8VUz4PJws1gldPA1IQLE94Zs/VmWvBBoqWMTyhXpzLXphFg6BzQN3a568BRgWyECI0UxvJEZo2p5Rula63SRXdCHx7RPUXuO7rc/iaD/GplTriIGAiNFMbyRGaNqeUbpWut0kV3Qh8e0T1F7ju63P4mg/xqZFPZc2GkAAAAAAAAAAAsAAAABAAAAIgYCpYXz+rSbXvlTRtkyIhoiG9VewZHxVTPg8nCzWCV08DUU8u8DiQAAAAAAAAAACwAAAAEAAAAiBgLE94Zs/VmWvBBoqWMTyhXpzLXphFg6BzQN3a568BRgWxTMGK4IAAAAAAAAAAALAAAAAQAAAAABASvQBwAAAAAAACIAINsEJ/GCK0d3Zw5mc8KK8C9todWv5xpx9ckGRHCyKfr9IgIDUZ5XKrRoVg0fjQ+HaZ0JgwjhZpBfXcrkOQ8GD6qPHONIMEUCIQDUS5A+vpZKLDwUW8ejgfp1pG5fbqvPFwN+ldx93ebdcAIgekKb8MAMxscUpC7SX1q3MN3y5qlVgbYjHRQYmygeoakBAQMEAQAAAAEFaVIhA1GeVyq0aFYNH40Ph2mdCYMI4WaQX13K5DkPBg+qjxzjIQOgW8JjkSIdaF4Y2q/zah6Vw0+ZRRJTwWzUJlDbJ4p5ESEC6AoIiFw1Nna4IM3CkObYGgrJWgPoq79Lt67r+3D+tBhTriIGAugKCIhcNTZ2uCDNwpDm2BoKyVoD6Ku/S7eu6/tw/rQYFPZc2GkAAAAAAAAAABUAAAACAAAAIgYDUZ5XKrRoVg0fjQ+HaZ0JgwjhZpBfXcrkOQ8GD6qPHOMU8u8DiQAAAAAAAAAAFQAAAAIAAAAiBgOgW8JjkSIdaF4Y2q/zah6Vw0+ZRRJTwWzUJlDbJ4p5ERTMGK4IAAAAAAAAAAAVAAAAAgAAAAABASDQBwAAAAAAABepFCCzcJTYKlE0Uf8MzZ2yOroFvF7zhyICAzbvIo/+m47/+6BSwy0zRmDdH4Nmz4/kSuWqZytrYpCVRzBEAiBv1hCFQBarmSEvaz2oX/nDn17e5Kl2wzEMvA4VeaUBqAIgcs5cBxsA3enJ2PvXiGre0sQouL1FLudynIdZ1kHMIUsBAQMEAQAAAAEEIyEDNu8ij/6bjv/7oFLDLTNGYN0fg2bPj+RK5apnK2tikJWsAAEAaVIhAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJIQLXL9DQ2QKTQ0rV/KFg8njgPGFEl6pOQlz0VOLBMw+WqyEDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvFTriICAsxND6QRysJESG+OssCOA1/3QQ9GCjWcp/iBCZG9O0IJFPLvA4kAAAAAAAAAAAAAAAAAAAAAIgIC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqsUzBiuCAAAAAAAAAAAAAAAAAAAAAAiAgNE2IQTbfVQIChl/7xiGMf5yI/mzjnJRXmBkLrbOKdS8RT2XNhpAAAAAAAAAAAAAAAAAAAAAAABACIAICkrBSNRo8b4DVG65kLMiCEYKJPb7tq8j10OlndHYCbBAQFpUiEDLhH5hVJoX+kH8x+ecmDJBujecA8MPJ8vFBBiPc39GcAhA1RXV841zx7fsTueLEovnOAKuMNr7hK8ojN85YP9KK7IIQKjz7ZmX+RPdSC2obTeGk1GZDs4XrH9Hgq3DvuWVCl1VFOuIgICo8+2Zl/kT3UgtqG03hpNRmQ7OF6x/R4Ktw77llQpdVQU9lzYaQAAAAAAAAAACgAAAAEAAAAiAgMuEfmFUmhf6QfzH55yYMkG6N5wDww8ny8UEGI9zf0ZwBTy7wOJAAAAAAAAAAAKAAAAAQAAACICA1RXV841zx7fsTueLEovnOAKuMNr7hK8ojN85YP9KK7IFMwYrggAAAAAAAAAAAoAAAABAAAAAAEBaVIhAtbRFAvSwPkUyzDJkqovzSg/RxqSgc7snsbFvESOaGkAIQO4Vah1jtpoY2SERanTz7lTiKyhdGIa2Y8JmhxPkyb+xyEClfe1J9LqU3pNQoMEEKv0NAcxv5sg5UlyABkzuaojU2xTriICApX3tSfS6lN6TUKDBBCr9DQHMb+bIOVJcgAZM7mqI1NsFPZc2GkAAAAAAAAAABQAAAACAAAAIgIC1tEUC9LA+RTLMMmSqi/NKD9HGpKBzuyexsW8RI5oaQAU8u8DiQAAAAAAAAAAFAAAAAIAAAAiAgO4Vah1jtpoY2SERanTz7lTiKyhdGIa2Y8JmhxPkyb+xxTMGK4IAAAAAAAAAAAUAAAAAgAAAAABAGlSIQJ1t6Nj9So4h4BmQPNmN3ZFiQcuF21raofXx1QQdXZMpSECTLifbj/I44C84AxqfhYk9MDuXPB2NItdckWdebeOlQwhA0xZdMDe646GyKyPbPpSHdg9SE0/kQDP7g1q9e0UICi6U64iAgJMuJ9uP8jjgLzgDGp+FiT0wO5c8HY0i11yRZ15t46VDBTUrYNyAAAAAAAAAAAAAAAAAwAAACICAnW3o2P1KjiHgGZA82Y3dkWJBy4XbWtqh9fHVBB1dkylFFR/RXYAAAAAAAAAAAAAAAADAAAAIgIDTFl0wN7rjobIrI9s+lId2D1ITT+RAM/uDWr17RQgKLoUQFxlvQAAAAAAAAAAAAAAAAMAAAAAAAA=", + }, + { + name: "Litecoin Lite PSBT (Unsigned)", + type: "psbt", + data: "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", + }, + { + name: "Litecoin Lite TX (Extracted)", + type: "tx", + data: "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", + }, + { + name: "Litecoin PSBT (Finalized)", + type: "psbt", + data: "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", + }, + { + name: "Litecoin PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Litecoin PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Litecoin PSBT (Unsigned)", + type: "psbt", + data: "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", + }, + { + name: "Litecoin TX (Extracted)", + type: "tx", + data: "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", + }, + { + name: "Zcash Lite PSBT (Finalized)", + type: "psbt", + data: "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", + }, + { + name: "Zcash Lite PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Zcash Lite PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Zcash Lite PSBT (Unsigned)", + type: "psbt", + data: "cHNidP8BAOkEAACAhSAviQLtlQpvo/8G0sIsp8eDS7BnrnsjMczx1I6EegxUdd0ZdQAAAAAA/////xRIluQF4mkl4MdUnXeLV8c3RJljypmea2Gj7i4SmqQYAQAAAAD/////BIQDAAAAAAAAF6kU2QlHRATBJKPQTD+/9h+qSc9DxYuHhAMAAAAAAAAXqRRO/XYem+YcqkIciqxKkCrW8qVLz4eEAwAAAAAAABepFNJNOBa+iiUMvd5+qmdPgBcM2pROhwAAAAAAAAAAEWoPc2V0ZWMgYXN0cm9ub215AAAAAAAAAAAAAAAAAAAAAAAAAE8BBIiyHgAAAAAAAAAAADqSLinwyOsNsqYEhMvctjH2sQfJyq4//c8+fS7B9rzQAxIUhxXzYdq2haZp1CQx5dbT+XNATaucn9G5ULJ5rXY0BMwYrghPAQSIsh4AAAAAAAAAAABtHWVtPd2RwZTARWWjYDcCohAWztFKJl84mC1ideZ7ZAPTusIxOnxrIcuxGxSw0QNB+SLApAOovYyH8NyCDzWvbgT2XNhpTwEEiLIeAAAAAAAAAAAAywT9Y6s02Q/mRmuIDioCzPioYzdDEpka+JEbGqq0QzQDNu8ij/6bjv/7oFLDLTNGYN0fg2bPj+RK5apnK2tikJUE8u8DiQj8BUJJVEdPAATwTexNAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHAQMEAQAAAAEEaVIhA/b0B2S9XWPyAKJ3iIOs916W8VCVyZgmPAhycNDJfn5/IQNf+3q8cBWeBGn0uYmm1eF4WikEFp/wULL0aP5dPV278iED4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1tTriIGA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyFMwYrggAAAAAAAAAAAEAAAAAAAAAIgYD4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1sU9lzYaQAAAAAAAAAAAQAAAAAAAAAiBgP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+fxTy7wOJAAAAAAAAAAABAAAAAAAAAAABASDQBwAAAAAAABepFCCzcJTYKlE0Uf8MzZ2yOroFvF7zhwEDBAEAAAABBCMhAzbvIo/+m47/+6BSwy0zRmDdH4Nmz4/kSuWqZytrYpCVrAABAGlSIQLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCSEC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqshA0TYhBNt9VAgKGX/vGIYx/nIj+bOOclFeYGQuts4p1LxU64iAgLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCRTy7wOJAAAAAAAAAAAAAAAAAAAAACICAtcv0NDZApNDStX8oWDyeOA8YUSXqk5CXPRU4sEzD5arFMwYrggAAAAAAAAAAAAAAAAAAAAAIgIDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvEU9lzYaQAAAAAAAAAAAAAAAAAAAAAAAQBpUiEDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYhAq/hLVd9GiCj7a/C/T0lWs59G4sYPQr53T++W/VUOrx9IQNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAEVOuIgICr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0U1K2DcgAAAAAAAAAAAAAAAAEAAAAiAgNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAERRAXGW9AAAAAAAAAAAAAAAAAQAAACICA2t5ELWR06dW1e51pejMDifnRehVMP6r0n1PWEelDzCGFFR/RXYAAAAAAAAAAAAAAAABAAAAAAAA", + }, + { + name: "Zcash Lite TX (Extracted)", + type: "tx", + data: "0400008085202f8902ed950a6fa3ff06d2c22ca7c7834bb067ae7b2331ccf1d48e847a0c5475dd197500000000fdfd0000473044022062b22ff49dea9ffaacf06ab4a38ea3c655127a5887e9da5e9afea43496cb1a29022004f8455ddca8c1563250ed08ddc1014edc16f7ef6c5b7707ee7d931e09543c74014830450221009540f61ff6f751a8b3af6879d4a7962a6c5f0135c239a6dd2e5c57c9afcc27af022052d8e04bc825137514b77b8164f2ccaf8717b57c5cc453ce43054e0f10be7f93014c69522103f6f40764bd5d63f200a2778883acf75e96f15095c998263c087270d0c97e7e7f21035ffb7abc70159e0469f4b989a6d5e1785a2904169ff050b2f468fe5d3d5dbbf22103e1524d7f6fc57ab3eacbb659b787106780a475d1db483952c2310b7e9a38975b53aeffffffff144896e405e26925e0c7549d778b57c737449963ca999e6b61a3ee2e129aa418010000006d483045022100fd365630d2236decb096b5bf33342163982354c60e80ee4e47724749f06419a902202c45bd8b310a6304cfc0f19999236196a53e8fd354efddff341aabda0601fc650123210336ef228ffe9b8efffba052c32d334660dd1f8366cf8fe44ae5aa672b6b629095acffffffff04840300000000000017a914d909474404c124a3d04c3fbff61faa49cf43c58b87840300000000000017a9144efd761e9be61caa421c8aac4a902ad6f2a54bcf87840300000000000017a914d24d3816be8a250cbdde7eaa674f80170cda944e870000000000000000116a0f736574656320617374726f6e6f6d7900000000000000000000000000000000000000", + }, + { + name: "Zcash PSBT (Finalized)", + type: "psbt", + data: "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", + }, + { + name: "Zcash PSBT (Fullsigned)", + type: "psbt", + data: "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", + }, + { + name: "Zcash PSBT (Halfsigned)", + type: "psbt", + data: "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", + }, + { + name: "Zcash PSBT (Unsigned)", + type: "psbt", + data: "cHNidP8BAOkEAACAhSAviQLtlQpvo/8G0sIsp8eDS7BnrnsjMczx1I6EegxUdd0ZdQAAAAAA/////xRIluQF4mkl4MdUnXeLV8c3RJljypmea2Gj7i4SmqQYAQAAAAD/////BIQDAAAAAAAAF6kU2QlHRATBJKPQTD+/9h+qSc9DxYuHhAMAAAAAAAAXqRRO/XYem+YcqkIciqxKkCrW8qVLz4eEAwAAAAAAABepFNJNOBa+iiUMvd5+qmdPgBcM2pROhwAAAAAAAAAAEWoPc2V0ZWMgYXN0cm9ub215AAAAAAAAAAAAAAAAAAAAAAAAAE8BBIiyHgAAAAAAAAAAADqSLinwyOsNsqYEhMvctjH2sQfJyq4//c8+fS7B9rzQAxIUhxXzYdq2haZp1CQx5dbT+XNATaucn9G5ULJ5rXY0BMwYrghPAQSIsh4AAAAAAAAAAABtHWVtPd2RwZTARWWjYDcCohAWztFKJl84mC1ideZ7ZAPTusIxOnxrIcuxGxSw0QNB+SLApAOovYyH8NyCDzWvbgT2XNhpTwEEiLIeAAAAAAAAAAAAywT9Y6s02Q/mRmuIDioCzPioYzdDEpka+JEbGqq0QzQDNu8ij/6bjv/7oFLDLTNGYN0fg2bPj+RK5apnK2tikJUE8u8DiQj8BUJJVEdPAATwTexNAAEBINAHAAAAAAAAF6kUVnzXtE+fOgfDE483v5hLYPu68kOHAQMEAQAAAAEEaVIhA/b0B2S9XWPyAKJ3iIOs916W8VCVyZgmPAhycNDJfn5/IQNf+3q8cBWeBGn0uYmm1eF4WikEFp/wULL0aP5dPV278iED4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1tTriIGA1/7erxwFZ4EafS5iabV4XhaKQQWn/BQsvRo/l09XbvyFMwYrggAAAAAAAAAAAEAAAAAAAAAIgYD4VJNf2/FerPqy7ZZt4cQZ4CkddHbSDlSwjELfpo4l1sU9lzYaQAAAAAAAAAAAQAAAAAAAAAiBgP29AdkvV1j8gCid4iDrPdelvFQlcmYJjwIcnDQyX5+fxTy7wOJAAAAAAAAAAABAAAAAAAAAAABASDQBwAAAAAAABepFCCzcJTYKlE0Uf8MzZ2yOroFvF7zhwEDBAEAAAABBCMhAzbvIo/+m47/+6BSwy0zRmDdH4Nmz4/kSuWqZytrYpCVrAABAGlSIQLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCSEC1y/Q0NkCk0NK1fyhYPJ44DxhRJeqTkJc9FTiwTMPlqshA0TYhBNt9VAgKGX/vGIYx/nIj+bOOclFeYGQuts4p1LxU64iAgLMTQ+kEcrCREhvjrLAjgNf90EPRgo1nKf4gQmRvTtCCRTy7wOJAAAAAAAAAAAAAAAAAAAAACICAtcv0NDZApNDStX8oWDyeOA8YUSXqk5CXPRU4sEzD5arFMwYrggAAAAAAAAAAAAAAAAAAAAAIgIDRNiEE231UCAoZf+8YhjH+ciP5s45yUV5gZC62zinUvEU9lzYaQAAAAAAAAAAAAAAAAAAAAAAAQBpUiEDa3kQtZHTp1bV7nWl6MwOJ+dF6FUw/qvSfU9YR6UPMIYhAq/hLVd9GiCj7a/C/T0lWs59G4sYPQr53T++W/VUOrx9IQNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAEVOuIgICr+EtV30aIKPtr8L9PSVazn0bixg9CvndP75b9VQ6vH0U1K2DcgAAAAAAAAAAAAAAAAEAAAAiAgNKJrA23w9fA99EdNB5JKmKBeEbolhEduGt20SCrOpAERRAXGW9AAAAAAAAAAAAAAAAAQAAACICA2t5ELWR06dW1e51pejMDifnRehVMP6r0n1PWEelDzCGFFR/RXYAAAAAAAAAAAAAAAABAAAAAAAA", + }, + { + name: "Zcash TX (Extracted)", + type: "tx", + data: "0400008085202f8902ed950a6fa3ff06d2c22ca7c7834bb067ae7b2331ccf1d48e847a0c5475dd197500000000fdfd0000473044022062b22ff49dea9ffaacf06ab4a38ea3c655127a5887e9da5e9afea43496cb1a29022004f8455ddca8c1563250ed08ddc1014edc16f7ef6c5b7707ee7d931e09543c74014830450221009540f61ff6f751a8b3af6879d4a7962a6c5f0135c239a6dd2e5c57c9afcc27af022052d8e04bc825137514b77b8164f2ccaf8717b57c5cc453ce43054e0f10be7f93014c69522103f6f40764bd5d63f200a2778883acf75e96f15095c998263c087270d0c97e7e7f21035ffb7abc70159e0469f4b989a6d5e1785a2904169ff050b2f468fe5d3d5dbbf22103e1524d7f6fc57ab3eacbb659b787106780a475d1db483952c2310b7e9a38975b53aeffffffff144896e405e26925e0c7549d778b57c737449963ca999e6b61a3ee2e129aa418010000006d483045022100fd365630d2236decb096b5bf33342163982354c60e80ee4e47724749f06419a902202c45bd8b310a6304cfc0f19999236196a53e8fd354efddff341aabda0601fc650123210336ef228ffe9b8efffba052c32d334660dd1f8366cf8fe44ae5aa672b6b629095acffffffff04840300000000000017a914d909474404c124a3d04c3fbff61faa49cf43c58b87840300000000000017a9144efd761e9be61caa421c8aac4a902ad6f2a54bcf87840300000000000017a914d24d3816be8a250cbdde7eaa674f80170cda944e870000000000000000116a0f736574656320617374726f6e6f6d7900000000000000000000000000000000000000", + }, +]; diff --git a/packages/webui/webpack.config.js b/packages/webui/webpack.config.js index 4f2165968ff..bbd718d4bd5 100644 --- a/packages/webui/webpack.config.js +++ b/packages/webui/webpack.config.js @@ -27,6 +27,12 @@ module.exports = { }, resolve: { extensions: [".ts", ".js"], + alias: { + // Use webui's local wasm build (with parse_node enabled) instead of wasm-utxo's default build. + // Both paths are needed: js/wasm for ts-loader project references, dist/esm/js/wasm for module resolution. + [path.resolve(__dirname, "../wasm-utxo/js/wasm")]: path.resolve(__dirname, "wasm"), + [path.resolve(__dirname, "../wasm-utxo/dist/esm/js/wasm")]: path.resolve(__dirname, "wasm"), + }, }, output: { filename: "bundle.js",