dcr-ts 0.2.0 → 0.3.0

package/dist/index.d.cts

@@ -367,7 +367,16 @@ declare function pubKeyHashEd25519Address(hash: Uint8Array, network: Network): s
 declare function pubKeyHashSchnorrAddress(hash: Uint8Array, network: Network): string;
 /** Encode a compressed public key as a pay-to-pubkey (secp256k1 ECDSA) address. */
 declare function pubKeyAddress(compressedPubKey: Uint8Array, network: Network): string;
-/** Encode a 32-byte Ed25519 public key as a pay-to-pubkey address. */
+/**
+ * Encode a 32-byte Ed25519 public key as a pay-to-pubkey address.
+ *
+ * This is the one address kind where a decoded string is not a stable identity.
+ * Identifier bytes `0x01` and `0x81` name the same address — same key, same
+ * pkScript — and only the `0x01` form is emitted here, so `encode(decode(x))`
+ * does not always give back `x`. dcrd behaves identically; see
+ * {@link decodeAddress}. Compare the key bytes, or re-encode first, rather than
+ * comparing address strings.
+ */
 declare function pubKeyEd25519Address(pubKey: Uint8Array, network: Network): string;
 /** Encode a compressed public key as a pay-to-pubkey (secp256k1 Schnorr) address. */
 declare function pubKeySchnorrAddress(compressedPubKey: Uint8Array, network: Network): string;
@@ -392,6 +401,17 @@ declare function addressFromScript(redeemScript: Uint8Array, network: Network):
 /**
  * Decode and validate an address. When `network` is given the address must
  * belong to it; otherwise the network is inferred from the version prefix.
+ *
+ * "Given" means a `Network`: omit the argument to infer, but anything else
+ * supplied for it — including a partial network missing its prefixes — is
+ * rejected with `invalid-argument` rather than treated as an omission. A network
+ * is matched by comparing its five address version prefixes rather than by object
+ * identity, so a second copy of this package, a `structuredClone` or a
+ * config-file round trip all work.
+ *
+ * One decoded string is not canonical: for the Ed25519 pay-to-pubkey kind the
+ * identifier bytes `0x01` and `0x81` decode to the same key and the same
+ * pkScript, and re-encoding always emits the `0x01` form. dcrd does the same.
  */
 declare function decodeAddress(address: string, network?: Network): DecodedAddress;
 /** True when `address` is a well-formed address (optionally for `network`). */
@@ -671,7 +691,21 @@ type Wordlist = readonly string[];
 declare const englishWordlist: Wordlist;
 /** Generate a new mnemonic. `strength` is entropy bits (128–256, default 128). */
 declare function generateMnemonic(strength?: number, wordlist?: Wordlist): string;
-/** Validate a mnemonic's checksum and wordlist membership. */
+/**
+ * Validate a mnemonic's checksum and wordlist membership.
+ *
+ * Answers `false` for a non-string rather than throwing, which is what a
+ * predicate is for and what {@link mnemonicToMasterKey} already relies on. The
+ * check is written out here so that answer is a decision rather than an
+ * accident: `@scure` reaches the same `false` by catching its own `TypeError`
+ * out of `nfkd`, which would stop being true if it ever reordered those checks.
+ *
+ * The wordlist is the exception, and throws as it does at every other entry in
+ * this module. It is the caller's configuration rather than the subject being
+ * predicated, so answering `false` for a malformed one would report a bad phrase
+ * for what is a bad argument — the confusion `assertMnemonicString` exists to
+ * avoid on the other parameter.
+ */
 declare function validateMnemonic(mnemonic: string, wordlist?: Wordlist): boolean;
 /** Recover the raw entropy behind a mnemonic. */
 declare function mnemonicToEntropy(mnemonic: string, wordlist?: Wordlist): Uint8Array;
@@ -686,14 +720,21 @@ declare function entropyToMnemonic(entropy: Uint8Array, wordlist?: Wordlist): st
  * checksum verified first. The word count *is* enforced: BIP39 is defined only
  * for 12, 15, 18, 21 or 24 words.
  *
- * Both failures are checked here rather than caught from `@scure`, and the two
- * checks are exhaustive: `mnemonicToSeedSync` reaches the caller's input only
- * through `nfkd`, which rejects a non-string, and `normalize`, which rejects a
- * word count outside the five. Its salt is `"mnemonic" + passphrase`, a
- * concatenation that always yields a string, and its PBKDF2 parameters are
- * constants — so nothing else in it can throw. Catching instead would report
- * `invalid-mnemonic` for a future `@scure` failure that has nothing to do with
- * the mnemonic, which is the one direction that wastes the most debugging time.
+ * Both mnemonic failures are checked here rather than caught from `@scure`, and
+ * the two checks are exhaustive for that argument: `mnemonicToSeedSync` reaches
+ * it only through `nfkd`, which rejects a non-string, and `normalize`, which
+ * rejects a word count outside the five. Its PBKDF2 parameters are constants, so
+ * nothing else in it can throw. Catching instead would report `invalid-mnemonic`
+ * for a future `@scure` failure that has nothing to do with the mnemonic, which
+ * is the one direction that wastes the most debugging time.
+ *
+ * The passphrase is checked here for the opposite reason: `@scure` never rejects
+ * it. Its salt is `"mnemonic" + passphrase`, a concatenation that stringifies
+ * whatever it is given, so `null` silently meant the passphrase `"null"` — and
+ * through {@link mnemonicToMasterKey}, a different wallet with nothing raised.
+ * `passphrase ?? null` is ordinary JavaScript, and a database column that is
+ * NULL for "no passphrase" is the ordinary way to arrive at it. Only literal
+ * `undefined` reaches the default.
  */
 declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Uint8Array;
 /**
@@ -931,6 +972,11 @@ interface P2PKHInputToSign {
  * 50 inputs and 26x at 500; end to end the gain is smaller (1.7x at 250) because
  * ECDSA dominates.
  *
+ * Every `idx` in `toSign` must be distinct. A repeat is rejected with
+ * `invalid-argument` before anything is written, because letting the later entry
+ * win silently dropped a signing the caller asked for; see the comment on the
+ * check itself.
+ *
  * The prefix hash is taken **before** any signature script is assigned, which is
  * also why this is correct: the prefix commits to no witness data, so writing
  * signature scripts cannot invalidate it. For other hash types the cache is

package/dist/index.d.ts

@@ -367,7 +367,16 @@ declare function pubKeyHashEd25519Address(hash: Uint8Array, network: Network): s
 declare function pubKeyHashSchnorrAddress(hash: Uint8Array, network: Network): string;
 /** Encode a compressed public key as a pay-to-pubkey (secp256k1 ECDSA) address. */
 declare function pubKeyAddress(compressedPubKey: Uint8Array, network: Network): string;
-/** Encode a 32-byte Ed25519 public key as a pay-to-pubkey address. */
+/**
+ * Encode a 32-byte Ed25519 public key as a pay-to-pubkey address.
+ *
+ * This is the one address kind where a decoded string is not a stable identity.
+ * Identifier bytes `0x01` and `0x81` name the same address — same key, same
+ * pkScript — and only the `0x01` form is emitted here, so `encode(decode(x))`
+ * does not always give back `x`. dcrd behaves identically; see
+ * {@link decodeAddress}. Compare the key bytes, or re-encode first, rather than
+ * comparing address strings.
+ */
 declare function pubKeyEd25519Address(pubKey: Uint8Array, network: Network): string;
 /** Encode a compressed public key as a pay-to-pubkey (secp256k1 Schnorr) address. */
 declare function pubKeySchnorrAddress(compressedPubKey: Uint8Array, network: Network): string;
@@ -392,6 +401,17 @@ declare function addressFromScript(redeemScript: Uint8Array, network: Network):
 /**
  * Decode and validate an address. When `network` is given the address must
  * belong to it; otherwise the network is inferred from the version prefix.
+ *
+ * "Given" means a `Network`: omit the argument to infer, but anything else
+ * supplied for it — including a partial network missing its prefixes — is
+ * rejected with `invalid-argument` rather than treated as an omission. A network
+ * is matched by comparing its five address version prefixes rather than by object
+ * identity, so a second copy of this package, a `structuredClone` or a
+ * config-file round trip all work.
+ *
+ * One decoded string is not canonical: for the Ed25519 pay-to-pubkey kind the
+ * identifier bytes `0x01` and `0x81` decode to the same key and the same
+ * pkScript, and re-encoding always emits the `0x01` form. dcrd does the same.
  */
 declare function decodeAddress(address: string, network?: Network): DecodedAddress;
 /** True when `address` is a well-formed address (optionally for `network`). */
@@ -671,7 +691,21 @@ type Wordlist = readonly string[];
 declare const englishWordlist: Wordlist;
 /** Generate a new mnemonic. `strength` is entropy bits (128–256, default 128). */
 declare function generateMnemonic(strength?: number, wordlist?: Wordlist): string;
-/** Validate a mnemonic's checksum and wordlist membership. */
+/**
+ * Validate a mnemonic's checksum and wordlist membership.
+ *
+ * Answers `false` for a non-string rather than throwing, which is what a
+ * predicate is for and what {@link mnemonicToMasterKey} already relies on. The
+ * check is written out here so that answer is a decision rather than an
+ * accident: `@scure` reaches the same `false` by catching its own `TypeError`
+ * out of `nfkd`, which would stop being true if it ever reordered those checks.
+ *
+ * The wordlist is the exception, and throws as it does at every other entry in
+ * this module. It is the caller's configuration rather than the subject being
+ * predicated, so answering `false` for a malformed one would report a bad phrase
+ * for what is a bad argument — the confusion `assertMnemonicString` exists to
+ * avoid on the other parameter.
+ */
 declare function validateMnemonic(mnemonic: string, wordlist?: Wordlist): boolean;
 /** Recover the raw entropy behind a mnemonic. */
 declare function mnemonicToEntropy(mnemonic: string, wordlist?: Wordlist): Uint8Array;
@@ -686,14 +720,21 @@ declare function entropyToMnemonic(entropy: Uint8Array, wordlist?: Wordlist): st
  * checksum verified first. The word count *is* enforced: BIP39 is defined only
  * for 12, 15, 18, 21 or 24 words.
  *
- * Both failures are checked here rather than caught from `@scure`, and the two
- * checks are exhaustive: `mnemonicToSeedSync` reaches the caller's input only
- * through `nfkd`, which rejects a non-string, and `normalize`, which rejects a
- * word count outside the five. Its salt is `"mnemonic" + passphrase`, a
- * concatenation that always yields a string, and its PBKDF2 parameters are
- * constants — so nothing else in it can throw. Catching instead would report
- * `invalid-mnemonic` for a future `@scure` failure that has nothing to do with
- * the mnemonic, which is the one direction that wastes the most debugging time.
+ * Both mnemonic failures are checked here rather than caught from `@scure`, and
+ * the two checks are exhaustive for that argument: `mnemonicToSeedSync` reaches
+ * it only through `nfkd`, which rejects a non-string, and `normalize`, which
+ * rejects a word count outside the five. Its PBKDF2 parameters are constants, so
+ * nothing else in it can throw. Catching instead would report `invalid-mnemonic`
+ * for a future `@scure` failure that has nothing to do with the mnemonic, which
+ * is the one direction that wastes the most debugging time.
+ *
+ * The passphrase is checked here for the opposite reason: `@scure` never rejects
+ * it. Its salt is `"mnemonic" + passphrase`, a concatenation that stringifies
+ * whatever it is given, so `null` silently meant the passphrase `"null"` — and
+ * through {@link mnemonicToMasterKey}, a different wallet with nothing raised.
+ * `passphrase ?? null` is ordinary JavaScript, and a database column that is
+ * NULL for "no passphrase" is the ordinary way to arrive at it. Only literal
+ * `undefined` reaches the default.
  */
 declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Uint8Array;
 /**
@@ -931,6 +972,11 @@ interface P2PKHInputToSign {
  * 50 inputs and 26x at 500; end to end the gain is smaller (1.7x at 250) because
  * ECDSA dominates.
  *
+ * Every `idx` in `toSign` must be distinct. A repeat is rejected with
+ * `invalid-argument` before anything is written, because letting the later entry
+ * win silently dropped a signing the caller asked for; see the comment on the
+ * check itself.
+ *
  * The prefix hash is taken **before** any signature script is assigned, which is
  * also why this is correct: the prefix commits to no witness data, so writing
  * signature scripts cannot invalidate it. For other hash types the cache is

package/dist/index.js

@@ -29,6 +29,9 @@ function err(code, who, message) {
 
 // src/bytes.ts
 function copyOf(src, off, n) {
+  if (!isBytes(src)) {
+    throw err("invalid-argument", "copyOf", `source must be a Uint8Array, got ${typeName(src)}`);
+  }
   if (!Number.isInteger(off) || !Number.isInteger(n) || off < 0 || n < 0) {
     throw err(
       "not-an-integer",
@@ -116,6 +119,7 @@ var Writer = class {
   // steps. Every input amount and output value in a transaction crosses one of
   // these, and the loop version measured ~33x slower on the primitive.
   u64(v) {
+    if (typeof v !== "bigint") throw err("invalid-argument", "Writer.u64", `value must be a bigint, got ${typeName(v)}`);
     if (v < 0n || v > 0xffffffffffffffffn) throw err("out-of-range", "Writer.u64", "value must fit in an unsigned 64-bit integer");
     this.ensure(8);
     this.view.setBigUint64(this.len, v, true);
@@ -124,6 +128,7 @@ var Writer = class {
   }
   /** Signed 64-bit little-endian (two's complement). Used for atom amounts. */
   i64(v) {
+    if (typeof v !== "bigint") throw err("invalid-argument", "Writer.i64", `value must be a bigint, got ${typeName(v)}`);
     if (v < -(1n << 63n) || v >= 1n << 63n) throw err("out-of-range", "Writer.i64", "value must fit in a signed 64-bit integer");
     this.ensure(8);
     this.view.setBigInt64(this.len, v, true);
@@ -131,6 +136,7 @@ var Writer = class {
     return this;
   }
   bytes(b) {
+    if (!isBytes(b)) throw err("invalid-argument", "Writer.bytes", `value must be a Uint8Array, got ${typeName(b)}`);
     this.ensure(b.length);
     this.buf.set(b, this.len);
     this.len += b.length;
@@ -773,6 +779,9 @@ for (let i = 0; i < ALPHABET.length; i++) {
   INDEX[ALPHABET.charCodeAt(i)] = i;
 }
 function base58Encode(bytes) {
+  if (!isBytes(bytes)) {
+    throw err("invalid-argument", "base58Encode", `input must be a Uint8Array, got ${typeName(bytes)}`);
+  }
   let zeros = 0;
   while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
   let num = 0n;
@@ -908,6 +917,7 @@ function publicKeyFromPrivate(privateKey, compressed = true) {
   return secp256k1.getPublicKey(privateKey, compressed);
 }
 function isValidPublicKey(key) {
+  if (!isBytes(key)) return false;
   try {
     secp256k1.ProjectivePoint.fromHex(key);
     return true;
@@ -1202,6 +1212,32 @@ for (const network of Object.values(networks)) {
     { network, kind: "pubkey-ecdsa", prefix: network.pubKeyAddrId }
   );
 }
+function eq2(a, b) {
+  return a[0] === b[0] && a[1] === b[1];
+}
+var ADDRESS_PREFIX_FIELDS = [
+  "pubKeyAddrId",
+  "pubKeyHashAddrId",
+  "pubKeyHashEdwardsAddrId",
+  "pubKeyHashSchnorrAddrId",
+  "scriptHashAddrId"
+];
+function assertNetwork(network, who) {
+  const shaped = typeof network === "object" && network !== null && typeof network.name === "string" && ADDRESS_PREFIX_FIELDS.every((f) => {
+    const p = network[f];
+    return Array.isArray(p) && p.length === 2 && typeof p[0] === "number" && typeof p[1] === "number";
+  });
+  if (!shaped) {
+    throw err(
+      "invalid-argument",
+      who,
+      `network must be a Network with its address prefixes, got ${typeName(network)} (pass mainnet, testnet3, simnet or regnet)`
+    );
+  }
+}
+function sameNetwork(a, b) {
+  return a === b || eq2(a.pubKeyAddrId, b.pubKeyAddrId) && eq2(a.pubKeyHashAddrId, b.pubKeyHashAddrId) && eq2(a.pubKeyHashEdwardsAddrId, b.pubKeyHashEdwardsAddrId) && eq2(a.pubKeyHashSchnorrAddrId, b.pubKeyHashSchnorrAddrId) && eq2(a.scriptHashAddrId, b.scriptHashAddrId);
+}
 function encode(prefix, payload) {
   const data = new Uint8Array(2 + payload.length);
   data[0] = prefix[0];
@@ -1209,19 +1245,28 @@ function encode(prefix, payload) {
   data.set(payload, 2);
   return checkEncode(data);
 }
+function assertHash20(hash, who) {
+  if (!isBytes(hash)) {
+    throw err("invalid-argument", who, `hash must be a Uint8Array, got ${typeName(hash)}`);
+  }
+}
 function pubKeyHashAddress(hash, network) {
+  assertHash20(hash, "pubKeyHashAddress");
   if (hash.length !== 20) throw err("bad-length", "pubKeyHashAddress", `hash must be 20 bytes, got ${hash.length}`);
   return encode(network.pubKeyHashAddrId, hash);
 }
 function scriptHashAddress(hash, network) {
+  assertHash20(hash, "scriptHashAddress");
   if (hash.length !== 20) throw err("bad-length", "scriptHashAddress", `hash must be 20 bytes, got ${hash.length}`);
   return encode(network.scriptHashAddrId, hash);
 }
 function pubKeyHashEd25519Address(hash, network) {
+  assertHash20(hash, "pubKeyHashEd25519Address");
   if (hash.length !== 20) throw err("bad-length", "pubKeyHashEd25519Address", `hash must be 20 bytes, got ${hash.length}`);
   return encode(network.pubKeyHashEdwardsAddrId, hash);
 }
 function pubKeyHashSchnorrAddress(hash, network) {
+  assertHash20(hash, "pubKeyHashSchnorrAddress");
   if (hash.length !== 20) throw err("bad-length", "pubKeyHashSchnorrAddress", `hash must be 20 bytes, got ${hash.length}`);
   return encode(network.pubKeyHashSchnorrAddrId, hash);
 }
@@ -1291,6 +1336,7 @@ function decodeAddress(address, network) {
   if (typeof address !== "string") {
     throw err("invalid-argument", "decodeAddress", `address must be a string, got ${typeName(address)}`);
   }
+  if (network !== void 0) assertNetwork(network, "decodeAddress");
   if (address.length > MAX_ADDRESS_LENGTH) {
     throw err(
       "input-too-long",
@@ -1302,21 +1348,18 @@ function decodeAddress(address, network) {
   if (data.length < 3) throw err("bad-length", "decodeAddress", `payload is ${data.length} bytes, too short to hold a prefix and data`);
   const prefix = [data[0], data[1]];
   const payload = data.subarray(2);
-  const match = PREFIXES.find(
-    (e) => e.prefix[0] === prefix[0] && e.prefix[1] === prefix[1] && (!network || e.network === network)
-  );
+  const match = PREFIXES.find((e) => e.prefix[0] === prefix[0] && e.prefix[1] === prefix[1]);
   if (!match) {
     const hex = `0x${prefix[0].toString(16).padStart(2, "0")}${prefix[1].toString(16).padStart(2, "0")}`;
-    const onAnotherNetwork = network && PREFIXES.find((e) => e.prefix[0] === prefix[0] && e.prefix[1] === prefix[1]);
-    if (onAnotherNetwork) {
-      throw err(
-        "wrong-network",
-        "decodeAddress",
-        `address is a ${onAnotherNetwork.kind} address for ${onAnotherNetwork.network.name}, not ${network.name}`
-      );
-    }
     throw err("unknown-prefix", "decodeAddress", `unknown address prefix ${hex}`);
   }
+  if (network && !sameNetwork(match.network, network)) {
+    throw err(
+      "wrong-network",
+      "decodeAddress",
+      `address is a ${match.kind} address for ${match.network.name}, not ${network.name}`
+    );
+  }
   if (match.kind === "pubkey-ecdsa") {
     if (payload.length !== 33) throw err("bad-length", "decodeAddress", `pay-to-pubkey payload must be 33 bytes, got ${payload.length}`);
     const { kind, pubKey } = decodePubKeyData(payload);
@@ -1339,13 +1382,7 @@ function isValidAddress(address, network) {
   }
 }
 function addressToScript(address, network) {
-  if (!network || typeof network.name !== "string") {
-    throw err(
-      "invalid-argument",
-      "addressToScript",
-      "a network is required (pass mainnet, testnet3, simnet or regnet)"
-    );
-  }
+  assertNetwork(network, "addressToScript");
   const d = decodeAddress(address, network);
   switch (d.kind) {
     case "pubkeyhash-ecdsa":
@@ -1388,7 +1425,7 @@ function encodeWif(privateKey, network, signatureType = 0 /* Ecdsa */) {
   if (!isBytes(privateKey)) throw err("invalid-argument", "encodeWif", "private key must be a Uint8Array");
   if (privateKey.length !== 32) throw err("bad-length", "encodeWif", `private key must be 32 bytes, got ${privateKey.length}`);
   if (!Number.isInteger(signatureType) || SignatureType[signatureType] === void 0) {
-    throw err("unsupported-signature-type", "encodeWif", `unknown signature type ${signatureType}`);
+    throw err("unsupported-signature-type", "encodeWif", `unknown signature type ${shown(signatureType)}`);
   }
   assertWifScalar(privateKey, signatureType, "encodeWif");
   const payload = new Uint8Array(3 + 32);
@@ -1488,6 +1525,9 @@ var ExtendedKey = class _ExtendedKey {
   cachedPoint = void 0;
   /** Derive a master key from a BIP32 seed (16–64 bytes). */
   static fromSeed(seed, network) {
+    if (!isBytes(seed)) {
+      throw err("invalid-argument", "ExtendedKey.fromSeed", `seed must be a Uint8Array, got ${typeName(seed)}`);
+    }
     if (seed.length < 16 || seed.length > 64) {
       throw err("out-of-range", "ExtendedKey.fromSeed", `seed must be 16..64 bytes, got ${seed.length}`);
     }
@@ -1648,6 +1688,9 @@ var ExtendedKey = class _ExtendedKey {
     return this.derivePathInner(path, true);
   }
   derivePathInner(path, strictBip32) {
+    if (typeof path !== "string") {
+      throw err("invalid-path", "ExtendedKey.derivePath", `path must be a string, got ${typeName(path)}`);
+    }
     const parts = path.trim().split("/");
     if (parts[0] === "m" || parts[0] === "M") parts.shift();
     let key = this;
@@ -1736,6 +1779,9 @@ var ExtendedKey = class _ExtendedKey {
    * key it just parsed. See {@link copyOf}.
    */
   static fromSerialized(data) {
+    if (!isBytes(data)) {
+      throw err("invalid-argument", "ExtendedKey.fromSerialized", `serialization must be a Uint8Array, got ${typeName(data)}`);
+    }
     if (data.length !== SERIALIZED_LENGTH) throw err("bad-length", "ExtendedKey.fromSerialized", `expected ${SERIALIZED_LENGTH} bytes, got ${data.length}`);
     const version = [data[0], data[1], data[2], data[3]];
     const depth = data[4];
@@ -1796,7 +1842,15 @@ function assertMnemonicString(mnemonic, who) {
     throw err("invalid-argument", who, `mnemonic must be a string, got ${typeof mnemonic}`);
   }
 }
+function assertPassphrase(passphrase, who) {
+  if (typeof passphrase !== "string") {
+    throw err("invalid-argument", who, `passphrase must be a string, got ${typeName(passphrase)}`);
+  }
+}
 function assertWordlist(wordlist, who) {
+  if (!Array.isArray(wordlist)) {
+    throw err("invalid-argument", who, `wordlist must be an array of 2048 words, got ${typeName(wordlist)}`);
+  }
   if (wordlist.length !== 2048) {
     throw err("invalid-argument", who, `wordlist must hold 2048 words, got ${wordlist.length}`);
   }
@@ -1813,6 +1867,8 @@ function generateMnemonic(strength = 128, wordlist$1 = wordlist) {
   return generateMnemonic$1(wordlist$1, strength);
 }
 function validateMnemonic(mnemonic, wordlist$1 = wordlist) {
+  assertWordlist(wordlist$1, "validateMnemonic");
+  if (typeof mnemonic !== "string") return false;
   return validateMnemonic$1(mnemonic, wordlist$1);
 }
 function mnemonicToEntropy(mnemonic, wordlist$1 = wordlist) {
@@ -1841,6 +1897,7 @@ function entropyToMnemonic(entropy, wordlist$1 = wordlist) {
 }
 function mnemonicToSeed(mnemonic, passphrase = "") {
   assertMnemonicString(mnemonic, "mnemonicToSeed");
+  assertPassphrase(passphrase, "mnemonicToSeed");
   const words = mnemonic.normalize("NFKD").split(" ").length;
   if (!MNEMONIC_WORD_COUNTS.includes(words)) {
     throw err(
@@ -1853,6 +1910,7 @@ function mnemonicToSeed(mnemonic, passphrase = "") {
 }
 function mnemonicToMasterKey(mnemonic, network, passphrase = "", wordlist$1 = wordlist) {
   assertMnemonicString(mnemonic, "mnemonicToMasterKey");
+  assertPassphrase(passphrase, "mnemonicToMasterKey");
   assertWordlist(wordlist$1, "mnemonicToMasterKey");
   if (!validateMnemonic(mnemonic, wordlist$1)) {
     throw err(
@@ -1952,6 +2010,20 @@ var Transaction = class _Transaction {
         `outpoint tree must be ${0 /* Regular */} (regular) or ${1 /* Stake */} (stake), got ${shown(previousOutPoint.tree)}`
       );
     }
+    if (opts.valueIn != null && typeof opts.valueIn !== "bigint") {
+      throw err(
+        "invalid-argument",
+        "tx.addInput",
+        `valueIn must be a bigint, got ${typeName(opts.valueIn)}`
+      );
+    }
+    if (opts.signatureScript && !isBytes(opts.signatureScript)) {
+      throw err(
+        "invalid-argument",
+        "tx.addInput",
+        `signatureScript must be a Uint8Array, got ${typeName(opts.signatureScript)}`
+      );
+    }
     this.inputs.push({
       previousOutPoint: {
         hash: copyOf(previousOutPoint.hash, 0, 32),
@@ -1968,6 +2040,13 @@ var Transaction = class _Transaction {
   }
   /** Add an output. The script is copied; see {@link addInput}. */
   addOutput(value, pkScript, version = 0) {
+    if (typeof value !== "bigint") {
+      throw err(
+        "invalid-argument",
+        "tx.addOutput",
+        `value must be a bigint, got ${typeName(value)}`
+      );
+    }
     if (!isBytes(pkScript)) {
       throw err(
         "invalid-argument",
@@ -2178,6 +2257,9 @@ function calcSignatureHash(subScript, hashType, tx, idx, cachedPrefix) {
   const prefixIsInputIndependent = masked === 1 /* All */ && !anyoneCanPay;
   let prefixHash;
   if (cachedPrefix !== void 0 && prefixIsInputIndependent) {
+    if (!isBytes(cachedPrefix)) {
+      throw err("invalid-argument", "sighash", `cachedPrefix must be a Uint8Array, got ${typeName(cachedPrefix)}`);
+    }
     if (cachedPrefix.length !== 32) {
       throw err("bad-length", "sighash", `cachedPrefix must be 32 bytes, got ${cachedPrefix.length}`);
     }
@@ -2239,6 +2321,9 @@ function signHash(hash, privateKey) {
 }
 function verifyHash(hash, derSignature, publicKey) {
   assertHash32(hash, "verifyHash");
+  if (!isBytes(publicKey)) {
+    throw err("invalid-argument", "verifyHash", `public key must be a Uint8Array, got ${typeName(publicKey)}`);
+  }
   try {
     const sig = secp256k1.Signature.fromDER(derSignature);
     const canonical = sig.toDERRawBytes();
@@ -2284,6 +2369,17 @@ function signP2PKHInput(tx, idx, subScript, privateKey, hashType = 1 /* All */,
 }
 function signP2PKHInputs(tx, toSign, hashType = 1 /* All */) {
   assertSignableSigHashType(hashType);
+  const seen = /* @__PURE__ */ new Set();
+  for (const { idx } of toSign) {
+    if (seen.has(idx)) {
+      throw err(
+        "invalid-argument",
+        "signP2PKHInputs",
+        `input index ${idx} is listed more than once`
+      );
+    }
+    seen.add(idx);
+  }
   const cachedPrefix = sigHashPrefixAll(tx);
   for (const { idx, subScript, privateKey, compressed = true } of toSign) {
     tx.inputs[idx].signatureScript = signatureScript(
@@ -2303,6 +2399,9 @@ function signP2PKHInputs(tx, toSign, hashType = 1 /* All */) {
 var ATOMS_PER_COIN = 100000000n;
 var COIN_DECIMALS = 8;
 function dcrToAtoms(dcr) {
+  if (typeof dcr !== "string") {
+    throw err("invalid-amount", "dcrToAtoms", `amount must be a string, got ${typeName(dcr)}`);
+  }
   const s = dcr.trim();
   if (!/^-?\d+(\.\d+)?$/.test(s)) throw err("invalid-amount", "dcrToAtoms", `cannot parse ${shown(dcr)}`);
   const negative = s.startsWith("-");
@@ -2316,6 +2415,9 @@ function dcrToAtoms(dcr) {
   return negative ? -atoms : atoms;
 }
 function atomsToDcr(atoms) {
+  if (typeof atoms !== "bigint") {
+    throw err("invalid-amount", "atomsToDcr", `atoms must be a bigint, got ${typeName(atoms)}`);
+  }
   const negative = atoms < 0n;
   const a = negative ? -atoms : atoms;
   const intPart = a / ATOMS_PER_COIN;