@bitgo-beta/sdk-coin-kaspa 0.0.1-beta.21 → 0.0.1-beta.211

package/dist/src/lib/sighash.js

@@ -1,38 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SCRIPT_PUBLIC_KEY_VERSION = exports.OP_CHECKSIG_SCHNORR = exports.SIGHASH_ANYONECANPAY = exports.SIGHASH_SINGLE = exports.SIGHASH_NONE = exports.SIGHASH_ALL = void 0;
 exports.buildP2PKScriptPublicKey = buildP2PKScriptPublicKey;
 exports.compressedToXOnly = compressedToXOnly;
 exports.computeKaspaSigningHash = computeKaspaSigningHash;
+exports.computeKaspaEcdsaSigningHash = computeKaspaEcdsaSigningHash;
 /**
  * Kaspa transaction sighash computation.
  *
- * BIP-143-like scheme using Blake2b-256. All integer fields are little-endian.
+ * BIP-143-like scheme using keyed Blake2b-256. All integer fields are
+ * little-endian.
+ *
+ * ALL hashes (intermediate and final) use the same keyed Blake2b-256 hasher:
+ *   blake2b_256(data, key="TransactionSigningHash")
  *
  * Reference (authoritative implementation):
+ * https://github.com/kaspanet/rusty-kaspa/blob/master/crypto/hashes/src/hashers.rs
  * https://github.com/kaspanet/rusty-kaspa/blob/master/consensus/core/src/hashing/sighash.rs
  */
 const blakejs_1 = require("blakejs");
-// SigHash type flags
-exports.SIGHASH_ALL = 0x01;
-exports.SIGHASH_NONE = 0x02;
-exports.SIGHASH_SINGLE = 0x04;
-exports.SIGHASH_ANYONECANPAY = 0x80;
-// Script constants
-exports.OP_CHECKSIG_SCHNORR = 0xab; // Kaspa Schnorr checksig opcode
-exports.SCRIPT_PUBLIC_KEY_VERSION = 0; // Standard P2PK version
-function blake2b256(data) {
-    return Buffer.from((0, blakejs_1.blake2b)(data, undefined, 32));
+const crypto_1 = require("crypto");
+const constants_1 = require("./constants");
+/**
+ * The Blake2b key used for ALL sighash operations in Kaspa.
+ * Defined in rusty-kaspa crypto/hashes/src/hashers.rs:
+ *   blake2b_hasher! { struct TransactionSigningHash => b"TransactionSigningHash", ... }
+ * which resolves to:
+ *   blake2b_simd::Params::new().hash_length(32).key(b"TransactionSigningHash").to_state()
+ */
+const SIGNING_HASH_KEY = Buffer.from('TransactionSigningHash', 'ascii');
+function kblake2b(data) {
+    return Buffer.from((0, blakejs_1.blake2b)(data, SIGNING_HASH_KEY, 32));
 }
 /**
- * Build P2PK Schnorr scriptPublicKey from a 32-byte x-only public key.
- * Format: DATA_32(0x20) + xOnlyPubKey(32 bytes) + OP_CHECKSIG_SCHNORR(0xAB)
+ * Build a Kaspa P2PK scriptPublicKey.
+ *
+ * @param pubKey - For SCHNORR: 32-byte x-only key.
+ *                 For ECDSA:   33-byte compressed key.
+ * @param type   - Address type (default: SCHNORR / v0).
+ *
+ * Resulting script formats (per rusty-kaspa crypto/txscript/src/standard.rs):
+ *   SCHNORR (v0): OP_DATA_32(0x20) || xOnlyPubKey(32B)      || OpCheckSig(0xAC)
+ *   ECDSA   (v1): OP_DATA_33(0x21) || compressedPubKey(33B) || OpCheckSigECDSA(0xAB)
  */
-function buildP2PKScriptPublicKey(xOnlyPubKey) {
-    if (xOnlyPubKey.length !== 32) {
-        throw new Error(`Expected 32-byte x-only pubkey, got ${xOnlyPubKey.length}`);
+function buildP2PKScriptPublicKey(pubKey, type = constants_1.KaspaScriptType.SCHNORR) {
+    if (type === constants_1.KaspaScriptType.SCHNORR) {
+        if (pubKey.length !== 32) {
+            throw new Error(`SCHNORR script expects 32-byte x-only pubkey, got ${pubKey.length}`);
+        }
+        return Buffer.concat([Buffer.from([0x20]), pubKey, Buffer.from([constants_1.OP_CHECKSIG_SCHNORR])]);
+    }
+    else {
+        if (pubKey.length !== 33) {
+            throw new Error(`ECDSA script expects 33-byte compressed pubkey, got ${pubKey.length}`);
+        }
+        return Buffer.concat([Buffer.from([0x21]), pubKey, Buffer.from([constants_1.OP_CHECKSIG_ECDSA])]);
     }
-    return Buffer.concat([Buffer.from([0x20]), xOnlyPubKey, Buffer.from([exports.OP_CHECKSIG_SCHNORR])]);
 }
 /**
  * Derive x-only public key from 33-byte compressed public key.
@@ -51,23 +73,28 @@ function hashPreviousOutputs(inputs) {
         buf.writeUInt32LE(inp.transactionIndex, 32);
         return buf;
     });
-    return blake2b256(Buffer.concat(parts));
+    return kblake2b(Buffer.concat(parts));
 }
 function hashSequences(inputs) {
     const buf = Buffer.alloc(inputs.length * 8);
     inputs.forEach((inp, i) => {
         buf.writeBigUInt64LE(BigInt(inp.sequence || '0'), i * 8);
     });
-    return blake2b256(buf);
+    return kblake2b(buf);
 }
 function hashSigOpCounts(inputs) {
     const bytes = inputs.map((inp) => inp.sigOpCount ?? 1);
-    return blake2b256(Buffer.from(bytes));
+    return kblake2b(Buffer.from(bytes));
 }
+/**
+ * Serialize one output for hashing.
+ * Matches hash_output() + hash_script_public_key() in rusty-kaspa:
+ *   write_u64(value) + write_u16(spk.version) + write_var_bytes(spk.script)
+ * where write_var_bytes = write_u64(len) + write(bytes).
+ */
 function serializeOutput(output) {
     const scriptBytes = Buffer.from(output.scriptPublicKey || '', 'hex');
-    const spkVersion = 0; // standard P2PK
-    // value (u64 LE, 8) + spk_version (u16 LE, 2) + script_length (u64 LE, 8) + script
+    const spkVersion = 0;
     const buf = Buffer.alloc(8 + 2 + 8 + scriptBytes.length);
     let offset = 0;
     buf.writeBigUInt64LE(BigInt(output.amount), offset);
@@ -81,58 +108,65 @@ function serializeOutput(output) {
 }
 function hashOutputs(tx, inputIndex, sigHashType) {
     const baseType = sigHashType & 0x1f;
-    if (baseType === exports.SIGHASH_NONE) {
-        return Buffer.alloc(32); // zero hash
+    if (baseType === constants_1.SIGHASH_NONE) {
+        return Buffer.alloc(32);
     }
-    if (baseType === exports.SIGHASH_SINGLE) {
+    if (baseType === constants_1.SIGHASH_SINGLE) {
         if (inputIndex >= tx.outputs.length) {
             return Buffer.alloc(32);
         }
-        return blake2b256(serializeOutput(tx.outputs[inputIndex]));
+        return kblake2b(serializeOutput(tx.outputs[inputIndex]));
     }
     // SIGHASH_ALL
-    const parts = tx.outputs.map(serializeOutput);
-    return blake2b256(Buffer.concat(parts));
+    return kblake2b(Buffer.concat(tx.outputs.map(serializeOutput)));
 }
 function hashPayload(tx) {
     const subnetId = Buffer.from(tx.subnetworkId || '0000000000000000000000000000000000000000', 'hex');
-    // If subnetwork is native (all zeros), payloadHash is zero
+    // Native subnetwork (all zeros) with empty payload → zero hash
     if (subnetId.every((b) => b === 0)) {
         return Buffer.alloc(32);
     }
-    return blake2b256(Buffer.from(tx.payload || '', 'hex'));
+    // write_var_bytes(payload): u64 length prefix + payload bytes
+    const payloadBytes = Buffer.from(tx.payload || '', 'hex');
+    const lenBuf = Buffer.alloc(8);
+    lenBuf.writeBigUInt64LE(BigInt(payloadBytes.length));
+    return kblake2b(Buffer.concat([lenBuf, payloadBytes]));
 }
 /**
- * Compute the Kaspa sighash for a specific input.
+ * Compute the Kaspa Schnorr sighash for a specific input.
+ *
+ * Matches calc_schnorr_signature_hash() in rusty-kaspa sighash.rs exactly.
+ * All intermediate and the final hash use keyed Blake2b-256 with
+ * key = "TransactionSigningHash".
  *
- * @param tx        Full transaction data
- * @param inputIndex Index of the input being signed
- * @param sigHashType SigHash type flags (use SIGHASH_ALL = 0x01 for standard)
+ * @param tx         Full transaction data — inputs must carry amount + scriptPublicKey
+ * @param inputIndex 0-based index of the input being signed
+ * @param sigHashType SigHash type flags (SIGHASH_ALL = 0x01 for standard)
  */
-function computeKaspaSigningHash(tx, inputIndex, sigHashType = exports.SIGHASH_ALL) {
-    const anyoneCanPay = !!(sigHashType & exports.SIGHASH_ANYONECANPAY);
+function computeKaspaSigningHash(tx, inputIndex, sigHashType = constants_1.SIGHASH_ALL) {
+    const anyoneCanPay = !!(sigHashType & constants_1.SIGHASH_ANYONECANPAY);
     const baseType = sigHashType & 0x1f;
     const input = tx.inputs[inputIndex];
     if (!input) {
         throw new Error(`Input index ${inputIndex} out of range`);
     }
-    // Conditional intermediate hashes
+    // Intermediate hashes
     const prevOutputsHash = anyoneCanPay ? Buffer.alloc(32) : hashPreviousOutputs(tx.inputs);
-    const seqHash = anyoneCanPay || baseType === exports.SIGHASH_SINGLE || baseType === exports.SIGHASH_NONE
+    const seqHash = anyoneCanPay || baseType === constants_1.SIGHASH_SINGLE || baseType === constants_1.SIGHASH_NONE
         ? Buffer.alloc(32)
         : hashSequences(tx.inputs);
     const sigOpHash = anyoneCanPay ? Buffer.alloc(32) : hashSigOpCounts(tx.inputs);
     const outsHash = hashOutputs(tx, inputIndex, sigHashType);
     const payloadHash = hashPayload(tx);
-    // Parse the current input's script public key
+    // Current input's scriptPublicKey (from the UTXO being spent)
     const scriptBytes = Buffer.from(input.scriptPublicKey || '', 'hex');
-    const spkVersion = 0; // standard P2PK
+    const spkVersion = 0;
     const subnetId = Buffer.from(tx.subnetworkId || '0000000000000000000000000000000000000000', 'hex');
-    // Build the preimage
+    // Build the preimage — field order matches calc_schnorr_signature_hash() exactly
     const fixedSize = 2 + 32 + 32 + 32 + 32 + 4 + 2 + 8 + 8 + 8 + 1 + 32 + 8 + 20 + 8 + 32 + 1;
     const preimage = Buffer.alloc(fixedSize + scriptBytes.length);
     let offset = 0;
-    // 1. version
+    // 1. tx.version (u16 LE)
     preimage.writeUInt16LE(tx.version ?? 0, offset);
     offset += 2;
     // 2. previousOutputsHash
@@ -144,40 +178,40 @@ function computeKaspaSigningHash(tx, inputIndex, sigHashType = exports.SIGHASH_A
     // 4. sigOpCountsHash
     sigOpHash.copy(preimage, offset);
     offset += 32;
-    // 5. current input's previous outpoint txId
+    // 5. input.previousOutpoint.transactionId (32 bytes)
     Buffer.from(input.transactionId, 'hex').copy(preimage, offset);
     offset += 32;
-    // 6. current input's previous outpoint index
+    // 6. input.previousOutpoint.index (u32 LE)
     preimage.writeUInt32LE(input.transactionIndex, offset);
     offset += 4;
-    // 7. scriptPublicKey version
+    // 7. scriptPublicKey.version (u16 LE)
     preimage.writeUInt16LE(spkVersion, offset);
     offset += 2;
-    // 8. scriptPublicKey length (u64 LE)
+    // 8. scriptPublicKey.script length (u64 LE) — write_var_bytes length prefix
     preimage.writeBigUInt64LE(BigInt(scriptBytes.length), offset);
     offset += 8;
-    // 9. scriptPublicKey bytes
+    // 9. scriptPublicKey.script bytes
     scriptBytes.copy(preimage, offset);
     offset += scriptBytes.length;
-    // 10. value (amount in sompi, u64 LE)
+    // 10. input UTXO amount (u64 LE)
     preimage.writeBigUInt64LE(BigInt(input.amount), offset);
     offset += 8;
-    // 11. sequence (u64 LE)
+    // 11. input.sequence (u64 LE)
     preimage.writeBigUInt64LE(BigInt(input.sequence || '0'), offset);
     offset += 8;
-    // 12. sigOpCount (u8)
+    // 12. input.sigOpCount (u8)
     preimage.writeUInt8(input.sigOpCount ?? 1, offset);
     offset += 1;
     // 13. outputsHash
     outsHash.copy(preimage, offset);
     offset += 32;
-    // 14. locktime (u64 LE)
+    // 14. tx.lockTime (u64 LE)
     preimage.writeBigUInt64LE(BigInt(tx.lockTime || '0'), offset);
     offset += 8;
-    // 15. subnetworkId (20 bytes)
+    // 15. tx.subnetworkId (20 bytes)
     subnetId.copy(preimage, offset);
     offset += 20;
-    // 16. gas (u64 LE) — always 0 for native KASPA
+    // 16. tx.gas (u64 LE) — always 0 for native KASPA
     preimage.writeBigUInt64LE(0n, offset);
     offset += 8;
     // 17. payloadHash
@@ -186,6 +220,31 @@ function computeKaspaSigningHash(tx, inputIndex, sigHashType = exports.SIGHASH_A
     // 18. sigHashType (u8)
     preimage.writeUInt8(sigHashType, offset);
     offset += 1;
-    return blake2b256(preimage.slice(0, offset));
+    return kblake2b(preimage.slice(0, offset));
+}
+/**
+ * SHA-256 domain separator for ECDSA signing.
+ * Matches TransactionSigningHashECDSA in rusty-kaspa/crypto/hashes/src/hashers.rs:
+ *   sha256_hasher! { struct TransactionSigningHashECDSA => "TransactionSigningHashECDSA" }
+ * The hasher is seeded with SHA256("TransactionSigningHashECDSA") before any data.
+ */
+const ECDSA_DOMAIN_SEP = Buffer.from((0, crypto_1.createHash)('sha256').update('TransactionSigningHashECDSA').digest());
+/**
+ * Compute the Kaspa ECDSA sighash for a specific input.
+ *
+ * ECDSA signing uses a two-step hash defined in rusty-kaspa sighash.rs:
+ *   1. schnorr_hash  = blake2b256_keyed("TransactionSigningHash", preimage)
+ *   2. ecdsa_hash    = SHA256( SHA256("TransactionSigningHashECDSA") || schnorr_hash )
+ *
+ * This differs from the Schnorr hash — using the Schnorr hash for ECDSA signing
+ * will produce a locally-valid signature that the network always rejects.
+ *
+ * @param tx         Full transaction data with UTXO amount + scriptPublicKey on inputs
+ * @param inputIndex 0-based index of the input being signed
+ * @param sigHashType SigHash type flags (SIGHASH_ALL = 0x01)
+ */
+function computeKaspaEcdsaSigningHash(tx, inputIndex, sigHashType = constants_1.SIGHASH_ALL) {
+    const schnorrHash = computeKaspaSigningHash(tx, inputIndex, sigHashType);
+    return Buffer.from((0, crypto_1.createHash)('sha256').update(ECDSA_DOMAIN_SEP).update(schnorrHash).digest());
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sighash.js","sourceRoot":"","sources":["../../../src/lib/sighash.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Kaspa transaction sighash computation.\n *\n * BIP-143-like scheme using Blake2b-256. All integer fields are little-endian.\n *\n * Reference (authoritative implementation):\n * https://github.com/kaspanet/rusty-kaspa/blob/master/consensus/core/src/hashing/sighash.rs\n */\nimport { blake2b } from 'blakejs';\nimport { KaspaTransactionData, KaspaUtxoInput, KaspaTransactionOutput } from './iface';\n\n// SigHash type flags\nexport const SIGHASH_ALL = 0x01;\nexport const SIGHASH_NONE = 0x02;\nexport const SIGHASH_SINGLE = 0x04;\nexport const SIGHASH_ANYONECANPAY = 0x80;\n\n// Script constants\nexport const OP_CHECKSIG_SCHNORR = 0xab; // Kaspa Schnorr checksig opcode\nexport const SCRIPT_PUBLIC_KEY_VERSION = 0; // Standard P2PK version\n\nfunction blake2b256(data: Buffer): Buffer {\n  return Buffer.from(blake2b(data, undefined, 32));\n}\n\n/**\n * Build P2PK Schnorr scriptPublicKey from a 32-byte x-only public key.\n * Format: DATA_32(0x20) + xOnlyPubKey(32 bytes) + OP_CHECKSIG_SCHNORR(0xAB)\n */\nexport function buildP2PKScriptPublicKey(xOnlyPubKey: Buffer): Buffer {\n  if (xOnlyPubKey.length !== 32) {\n    throw new Error(`Expected 32-byte x-only pubkey, got ${xOnlyPubKey.length}`);\n  }\n  return Buffer.concat([Buffer.from([0x20]), xOnlyPubKey, Buffer.from([OP_CHECKSIG_SCHNORR])]);\n}\n\n/**\n * Derive x-only public key from 33-byte compressed public key.\n */\nexport function compressedToXOnly(compressedPubKey: Buffer): Buffer {\n  if (compressedPubKey.length !== 33) {\n    throw new Error(`Expected 33-byte compressed pubkey, got ${compressedPubKey.length}`);\n  }\n  return compressedPubKey.slice(1); // drop the 02/03 prefix byte\n}\n\n// --- Intermediate hash helpers ---\n\nfunction hashPreviousOutputs(inputs: KaspaUtxoInput[]): Buffer {\n  const parts = inputs.map((inp) => {\n    const buf = Buffer.alloc(36);\n    Buffer.from(inp.transactionId, 'hex').copy(buf, 0);\n    buf.writeUInt32LE(inp.transactionIndex, 32);\n    return buf;\n  });\n  return blake2b256(Buffer.concat(parts));\n}\n\nfunction hashSequences(inputs: KaspaUtxoInput[]): Buffer {\n  const buf = Buffer.alloc(inputs.length * 8);\n  inputs.forEach((inp, i) => {\n    buf.writeBigUInt64LE(BigInt(inp.sequence || '0'), i * 8);\n  });\n  return blake2b256(buf);\n}\n\nfunction hashSigOpCounts(inputs: KaspaUtxoInput[]): Buffer {\n  const bytes = inputs.map((inp) => inp.sigOpCount ?? 1);\n  return blake2b256(Buffer.from(bytes));\n}\n\nfunction serializeOutput(output: KaspaTransactionOutput): Buffer {\n  const scriptBytes = Buffer.from(output.scriptPublicKey || '', 'hex');\n  const spkVersion = 0; // standard P2PK\n  // value (u64 LE, 8) + spk_version (u16 LE, 2) + script_length (u64 LE, 8) + script\n  const buf = Buffer.alloc(8 + 2 + 8 + scriptBytes.length);\n  let offset = 0;\n  buf.writeBigUInt64LE(BigInt(output.amount), offset);\n  offset += 8;\n  buf.writeUInt16LE(spkVersion, offset);\n  offset += 2;\n  buf.writeBigUInt64LE(BigInt(scriptBytes.length), offset);\n  offset += 8;\n  scriptBytes.copy(buf, offset);\n  return buf;\n}\n\nfunction hashOutputs(tx: KaspaTransactionData, inputIndex: number, sigHashType: number): Buffer {\n  const baseType = sigHashType & 0x1f;\n  if (baseType === SIGHASH_NONE) {\n    return Buffer.alloc(32); // zero hash\n  }\n  if (baseType === SIGHASH_SINGLE) {\n    if (inputIndex >= tx.outputs.length) {\n      return Buffer.alloc(32);\n    }\n    return blake2b256(serializeOutput(tx.outputs[inputIndex]));\n  }\n  // SIGHASH_ALL\n  const parts = tx.outputs.map(serializeOutput);\n  return blake2b256(Buffer.concat(parts));\n}\n\nfunction hashPayload(tx: KaspaTransactionData): Buffer {\n  const subnetId = Buffer.from(tx.subnetworkId || '0000000000000000000000000000000000000000', 'hex');\n  // If subnetwork is native (all zeros), payloadHash is zero\n  if (subnetId.every((b) => b === 0)) {\n    return Buffer.alloc(32);\n  }\n  return blake2b256(Buffer.from(tx.payload || '', 'hex'));\n}\n\n/**\n * Compute the Kaspa sighash for a specific input.\n *\n * @param tx        Full transaction data\n * @param inputIndex Index of the input being signed\n * @param sigHashType SigHash type flags (use SIGHASH_ALL = 0x01 for standard)\n */\nexport function computeKaspaSigningHash(\n  tx: KaspaTransactionData,\n  inputIndex: number,\n  sigHashType: number = SIGHASH_ALL\n): Buffer {\n  const anyoneCanPay = !!(sigHashType & SIGHASH_ANYONECANPAY);\n  const baseType = sigHashType & 0x1f;\n\n  const input = tx.inputs[inputIndex];\n  if (!input) {\n    throw new Error(`Input index ${inputIndex} out of range`);\n  }\n\n  // Conditional intermediate hashes\n  const prevOutputsHash = anyoneCanPay ? Buffer.alloc(32) : hashPreviousOutputs(tx.inputs);\n  const seqHash =\n    anyoneCanPay || baseType === SIGHASH_SINGLE || baseType === SIGHASH_NONE\n      ? Buffer.alloc(32)\n      : hashSequences(tx.inputs);\n  const sigOpHash = anyoneCanPay ? Buffer.alloc(32) : hashSigOpCounts(tx.inputs);\n  const outsHash = hashOutputs(tx, inputIndex, sigHashType);\n  const payloadHash = hashPayload(tx);\n\n  // Parse the current input's script public key\n  const scriptBytes = Buffer.from(input.scriptPublicKey || '', 'hex');\n  const spkVersion = 0; // standard P2PK\n  const subnetId = Buffer.from(tx.subnetworkId || '0000000000000000000000000000000000000000', 'hex');\n\n  // Build the preimage\n  const fixedSize = 2 + 32 + 32 + 32 + 32 + 4 + 2 + 8 + 8 + 8 + 1 + 32 + 8 + 20 + 8 + 32 + 1;\n  const preimage = Buffer.alloc(fixedSize + scriptBytes.length);\n  let offset = 0;\n\n  // 1. version\n  preimage.writeUInt16LE(tx.version ?? 0, offset);\n  offset += 2;\n\n  // 2. previousOutputsHash\n  prevOutputsHash.copy(preimage, offset);\n  offset += 32;\n\n  // 3. sequencesHash\n  seqHash.copy(preimage, offset);\n  offset += 32;\n\n  // 4. sigOpCountsHash\n  sigOpHash.copy(preimage, offset);\n  offset += 32;\n\n  // 5. current input's previous outpoint txId\n  Buffer.from(input.transactionId, 'hex').copy(preimage, offset);\n  offset += 32;\n\n  // 6. current input's previous outpoint index\n  preimage.writeUInt32LE(input.transactionIndex, offset);\n  offset += 4;\n\n  // 7. scriptPublicKey version\n  preimage.writeUInt16LE(spkVersion, offset);\n  offset += 2;\n\n  // 8. scriptPublicKey length (u64 LE)\n  preimage.writeBigUInt64LE(BigInt(scriptBytes.length), offset);\n  offset += 8;\n\n  // 9. scriptPublicKey bytes\n  scriptBytes.copy(preimage, offset);\n  offset += scriptBytes.length;\n\n  // 10. value (amount in sompi, u64 LE)\n  preimage.writeBigUInt64LE(BigInt(input.amount), offset);\n  offset += 8;\n\n  // 11. sequence (u64 LE)\n  preimage.writeBigUInt64LE(BigInt(input.sequence || '0'), offset);\n  offset += 8;\n\n  // 12. sigOpCount (u8)\n  preimage.writeUInt8(input.sigOpCount ?? 1, offset);\n  offset += 1;\n\n  // 13. outputsHash\n  outsHash.copy(preimage, offset);\n  offset += 32;\n\n  // 14. locktime (u64 LE)\n  preimage.writeBigUInt64LE(BigInt(tx.lockTime || '0'), offset);\n  offset += 8;\n\n  // 15. subnetworkId (20 bytes)\n  subnetId.copy(preimage, offset);\n  offset += 20;\n\n  // 16. gas (u64 LE) — always 0 for native KASPA\n  preimage.writeBigUInt64LE(0n, offset);\n  offset += 8;\n\n  // 17. payloadHash\n  payloadHash.copy(preimage, offset);\n  offset += 32;\n\n  // 18. sigHashType (u8)\n  preimage.writeUInt8(sigHashType, offset);\n  offset += 1;\n\n  return blake2b256(preimage.slice(0, offset));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sighash.js","sourceRoot":"","sources":["../../../src/lib/sighash.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Kaspa transaction sighash computation.\n *\n * BIP-143-like scheme using keyed Blake2b-256. All integer fields are\n * little-endian.\n *\n * ALL hashes (intermediate and final) use the same keyed Blake2b-256 hasher:\n *   blake2b_256(data, key=\"TransactionSigningHash\")\n *\n * Reference (authoritative implementation):\n * https://github.com/kaspanet/rusty-kaspa/blob/master/crypto/hashes/src/hashers.rs\n * https://github.com/kaspanet/rusty-kaspa/blob/master/consensus/core/src/hashing/sighash.rs\n */\nimport { blake2b } from 'blakejs';\nimport { createHash } from 'crypto';\nimport { KaspaTransactionData, KaspaUtxoInput, KaspaTransactionOutput } from './iface';\nimport {\n  SIGHASH_ALL,\n  SIGHASH_NONE,\n  SIGHASH_SINGLE,\n  SIGHASH_ANYONECANPAY,\n  OP_CHECKSIG_SCHNORR,\n  OP_CHECKSIG_ECDSA,\n  KaspaScriptType,\n} from './constants';\n\n/**\n * The Blake2b key used for ALL sighash operations in Kaspa.\n * Defined in rusty-kaspa crypto/hashes/src/hashers.rs:\n *   blake2b_hasher! { struct TransactionSigningHash => b\"TransactionSigningHash\", ... }\n * which resolves to:\n *   blake2b_simd::Params::new().hash_length(32).key(b\"TransactionSigningHash\").to_state()\n */\nconst SIGNING_HASH_KEY = Buffer.from('TransactionSigningHash', 'ascii');\n\nfunction kblake2b(data: Buffer): Buffer {\n  return Buffer.from(blake2b(data, SIGNING_HASH_KEY, 32));\n}\n\n/**\n * Build a Kaspa P2PK scriptPublicKey.\n *\n * @param pubKey - For SCHNORR: 32-byte x-only key.\n *                 For ECDSA:   33-byte compressed key.\n * @param type   - Address type (default: SCHNORR / v0).\n *\n * Resulting script formats (per rusty-kaspa crypto/txscript/src/standard.rs):\n *   SCHNORR (v0): OP_DATA_32(0x20) || xOnlyPubKey(32B)      || OpCheckSig(0xAC)\n *   ECDSA   (v1): OP_DATA_33(0x21) || compressedPubKey(33B) || OpCheckSigECDSA(0xAB)\n */\nexport function buildP2PKScriptPublicKey(pubKey: Buffer, type: KaspaScriptType = KaspaScriptType.SCHNORR): Buffer {\n  if (type === KaspaScriptType.SCHNORR) {\n    if (pubKey.length !== 32) {\n      throw new Error(`SCHNORR script expects 32-byte x-only pubkey, got ${pubKey.length}`);\n    }\n    return Buffer.concat([Buffer.from([0x20]), pubKey, Buffer.from([OP_CHECKSIG_SCHNORR])]);\n  } else {\n    if (pubKey.length !== 33) {\n      throw new Error(`ECDSA script expects 33-byte compressed pubkey, got ${pubKey.length}`);\n    }\n    return Buffer.concat([Buffer.from([0x21]), pubKey, Buffer.from([OP_CHECKSIG_ECDSA])]);\n  }\n}\n\n/**\n * Derive x-only public key from 33-byte compressed public key.\n */\nexport function compressedToXOnly(compressedPubKey: Buffer): Buffer {\n  if (compressedPubKey.length !== 33) {\n    throw new Error(`Expected 33-byte compressed pubkey, got ${compressedPubKey.length}`);\n  }\n  return compressedPubKey.slice(1); // drop the 02/03 prefix byte\n}\n\n// --- Intermediate hash helpers ---\n\nfunction hashPreviousOutputs(inputs: KaspaUtxoInput[]): Buffer {\n  const parts = inputs.map((inp) => {\n    const buf = Buffer.alloc(36);\n    Buffer.from(inp.transactionId, 'hex').copy(buf, 0);\n    buf.writeUInt32LE(inp.transactionIndex, 32);\n    return buf;\n  });\n  return kblake2b(Buffer.concat(parts));\n}\n\nfunction hashSequences(inputs: KaspaUtxoInput[]): Buffer {\n  const buf = Buffer.alloc(inputs.length * 8);\n  inputs.forEach((inp, i) => {\n    buf.writeBigUInt64LE(BigInt(inp.sequence || '0'), i * 8);\n  });\n  return kblake2b(buf);\n}\n\nfunction hashSigOpCounts(inputs: KaspaUtxoInput[]): Buffer {\n  const bytes = inputs.map((inp) => inp.sigOpCount ?? 1);\n  return kblake2b(Buffer.from(bytes));\n}\n\n/**\n * Serialize one output for hashing.\n * Matches hash_output() + hash_script_public_key() in rusty-kaspa:\n *   write_u64(value) + write_u16(spk.version) + write_var_bytes(spk.script)\n * where write_var_bytes = write_u64(len) + write(bytes).\n */\nfunction serializeOutput(output: KaspaTransactionOutput): Buffer {\n  const scriptBytes = Buffer.from(output.scriptPublicKey || '', 'hex');\n  const spkVersion = 0;\n  const buf = Buffer.alloc(8 + 2 + 8 + scriptBytes.length);\n  let offset = 0;\n  buf.writeBigUInt64LE(BigInt(output.amount), offset);\n  offset += 8;\n  buf.writeUInt16LE(spkVersion, offset);\n  offset += 2;\n  buf.writeBigUInt64LE(BigInt(scriptBytes.length), offset);\n  offset += 8;\n  scriptBytes.copy(buf, offset);\n  return buf;\n}\n\nfunction hashOutputs(tx: KaspaTransactionData, inputIndex: number, sigHashType: number): Buffer {\n  const baseType = sigHashType & 0x1f;\n  if (baseType === SIGHASH_NONE) {\n    return Buffer.alloc(32);\n  }\n  if (baseType === SIGHASH_SINGLE) {\n    if (inputIndex >= tx.outputs.length) {\n      return Buffer.alloc(32);\n    }\n    return kblake2b(serializeOutput(tx.outputs[inputIndex]));\n  }\n  // SIGHASH_ALL\n  return kblake2b(Buffer.concat(tx.outputs.map(serializeOutput)));\n}\n\nfunction hashPayload(tx: KaspaTransactionData): Buffer {\n  const subnetId = Buffer.from(tx.subnetworkId || '0000000000000000000000000000000000000000', 'hex');\n  // Native subnetwork (all zeros) with empty payload → zero hash\n  if (subnetId.every((b) => b === 0)) {\n    return Buffer.alloc(32);\n  }\n  // write_var_bytes(payload): u64 length prefix + payload bytes\n  const payloadBytes = Buffer.from(tx.payload || '', 'hex');\n  const lenBuf = Buffer.alloc(8);\n  lenBuf.writeBigUInt64LE(BigInt(payloadBytes.length));\n  return kblake2b(Buffer.concat([lenBuf, payloadBytes]));\n}\n\n/**\n * Compute the Kaspa Schnorr sighash for a specific input.\n *\n * Matches calc_schnorr_signature_hash() in rusty-kaspa sighash.rs exactly.\n * All intermediate and the final hash use keyed Blake2b-256 with\n * key = \"TransactionSigningHash\".\n *\n * @param tx         Full transaction data — inputs must carry amount + scriptPublicKey\n * @param inputIndex 0-based index of the input being signed\n * @param sigHashType SigHash type flags (SIGHASH_ALL = 0x01 for standard)\n */\nexport function computeKaspaSigningHash(\n  tx: KaspaTransactionData,\n  inputIndex: number,\n  sigHashType: number = SIGHASH_ALL\n): Buffer {\n  const anyoneCanPay = !!(sigHashType & SIGHASH_ANYONECANPAY);\n  const baseType = sigHashType & 0x1f;\n\n  const input = tx.inputs[inputIndex];\n  if (!input) {\n    throw new Error(`Input index ${inputIndex} out of range`);\n  }\n\n  // Intermediate hashes\n  const prevOutputsHash = anyoneCanPay ? Buffer.alloc(32) : hashPreviousOutputs(tx.inputs);\n  const seqHash =\n    anyoneCanPay || baseType === SIGHASH_SINGLE || baseType === SIGHASH_NONE\n      ? Buffer.alloc(32)\n      : hashSequences(tx.inputs);\n  const sigOpHash = anyoneCanPay ? Buffer.alloc(32) : hashSigOpCounts(tx.inputs);\n  const outsHash = hashOutputs(tx, inputIndex, sigHashType);\n  const payloadHash = hashPayload(tx);\n\n  // Current input's scriptPublicKey (from the UTXO being spent)\n  const scriptBytes = Buffer.from(input.scriptPublicKey || '', 'hex');\n  const spkVersion = 0;\n  const subnetId = Buffer.from(tx.subnetworkId || '0000000000000000000000000000000000000000', 'hex');\n\n  // Build the preimage — field order matches calc_schnorr_signature_hash() exactly\n  const fixedSize = 2 + 32 + 32 + 32 + 32 + 4 + 2 + 8 + 8 + 8 + 1 + 32 + 8 + 20 + 8 + 32 + 1;\n  const preimage = Buffer.alloc(fixedSize + scriptBytes.length);\n  let offset = 0;\n\n  // 1. tx.version (u16 LE)\n  preimage.writeUInt16LE(tx.version ?? 0, offset);\n  offset += 2;\n  // 2. previousOutputsHash\n  prevOutputsHash.copy(preimage, offset);\n  offset += 32;\n  // 3. sequencesHash\n  seqHash.copy(preimage, offset);\n  offset += 32;\n  // 4. sigOpCountsHash\n  sigOpHash.copy(preimage, offset);\n  offset += 32;\n  // 5. input.previousOutpoint.transactionId (32 bytes)\n  Buffer.from(input.transactionId, 'hex').copy(preimage, offset);\n  offset += 32;\n  // 6. input.previousOutpoint.index (u32 LE)\n  preimage.writeUInt32LE(input.transactionIndex, offset);\n  offset += 4;\n  // 7. scriptPublicKey.version (u16 LE)\n  preimage.writeUInt16LE(spkVersion, offset);\n  offset += 2;\n  // 8. scriptPublicKey.script length (u64 LE) — write_var_bytes length prefix\n  preimage.writeBigUInt64LE(BigInt(scriptBytes.length), offset);\n  offset += 8;\n  // 9. scriptPublicKey.script bytes\n  scriptBytes.copy(preimage, offset);\n  offset += scriptBytes.length;\n  // 10. input UTXO amount (u64 LE)\n  preimage.writeBigUInt64LE(BigInt(input.amount), offset);\n  offset += 8;\n  // 11. input.sequence (u64 LE)\n  preimage.writeBigUInt64LE(BigInt(input.sequence || '0'), offset);\n  offset += 8;\n  // 12. input.sigOpCount (u8)\n  preimage.writeUInt8(input.sigOpCount ?? 1, offset);\n  offset += 1;\n  // 13. outputsHash\n  outsHash.copy(preimage, offset);\n  offset += 32;\n  // 14. tx.lockTime (u64 LE)\n  preimage.writeBigUInt64LE(BigInt(tx.lockTime || '0'), offset);\n  offset += 8;\n  // 15. tx.subnetworkId (20 bytes)\n  subnetId.copy(preimage, offset);\n  offset += 20;\n  // 16. tx.gas (u64 LE) — always 0 for native KASPA\n  preimage.writeBigUInt64LE(0n, offset);\n  offset += 8;\n  // 17. payloadHash\n  payloadHash.copy(preimage, offset);\n  offset += 32;\n  // 18. sigHashType (u8)\n  preimage.writeUInt8(sigHashType, offset);\n  offset += 1;\n\n  return kblake2b(preimage.slice(0, offset));\n}\n\n/**\n * SHA-256 domain separator for ECDSA signing.\n * Matches TransactionSigningHashECDSA in rusty-kaspa/crypto/hashes/src/hashers.rs:\n *   sha256_hasher! { struct TransactionSigningHashECDSA => \"TransactionSigningHashECDSA\" }\n * The hasher is seeded with SHA256(\"TransactionSigningHashECDSA\") before any data.\n */\nconst ECDSA_DOMAIN_SEP: Buffer = Buffer.from(createHash('sha256').update('TransactionSigningHashECDSA').digest());\n\n/**\n * Compute the Kaspa ECDSA sighash for a specific input.\n *\n * ECDSA signing uses a two-step hash defined in rusty-kaspa sighash.rs:\n *   1. schnorr_hash  = blake2b256_keyed(\"TransactionSigningHash\", preimage)\n *   2. ecdsa_hash    = SHA256( SHA256(\"TransactionSigningHashECDSA\") || schnorr_hash )\n *\n * This differs from the Schnorr hash — using the Schnorr hash for ECDSA signing\n * will produce a locally-valid signature that the network always rejects.\n *\n * @param tx         Full transaction data with UTXO amount + scriptPublicKey on inputs\n * @param inputIndex 0-based index of the input being signed\n * @param sigHashType SigHash type flags (SIGHASH_ALL = 0x01)\n */\nexport function computeKaspaEcdsaSigningHash(\n  tx: KaspaTransactionData,\n  inputIndex: number,\n  sigHashType: number = SIGHASH_ALL\n): Buffer {\n  const schnorrHash = computeKaspaSigningHash(tx, inputIndex, sigHashType);\n  return Buffer.from(createHash('sha256').update(ECDSA_DOMAIN_SEP).update(schnorrHash).digest());\n}\n"]}

package/dist/src/lib/transaction.d.ts

@@ -1,5 +1,6 @@
 import { BaseKey, BaseTransaction } from '@bitgo-beta/sdk-core';
 import { KaspaTransactionData, TransactionExplanation } from './iface';
+import { Pskt } from './pskt';
 export declare class Transaction extends BaseTransaction {
     protected _txData: KaspaTransactionData;
     constructor(coin: string, txData?: KaspaTransactionData);
@@ -7,16 +8,60 @@ export declare class Transaction extends BaseTransaction {
     get id(): string;
     get txData(): KaspaTransactionData;
     /**
-     * Sign all inputs with the given private key using Schnorr signatures.
+     * Get the transaction fee in sompi.
+     * If fee was explicitly set, returns that. Otherwise computes from inputs - outputs.
+     */
+    get fee(): string;
+    /**
+     * Returns one sighash Buffer per input — the set of messages that must be
+     * signed for a multi-input MPCv2 ceremony.
+     *
+     * Kaspa uses a BIP-143-like sighash scheme (Blake2b) where each input commits
+     * to its own index, so input[i] has a distinct hash that cannot be re-used for
+     * input[j]. A correct multi-input MPCv2 flow runs one DKLS session per input
+     * in parallel and applies each resulting signature via addSignatureForInput().
+     *
+     * The hash type is automatically selected per input:
+     *   - Schnorr (scriptPublicKey ends 0xAC): keyed Blake2b-256
+     *   - ECDSA   (scriptPublicKey ends 0xAB): keyed Blake2b-256 + SHA256 double-hash
+     */
+    get signablePayloads(): Buffer[];
+    /**
+     * Apply a signature to a single specific input.
+     *
+     * Used in the multi-input MPCv2 flow where each input is signed by an
+     * independent DKLS session that commits to that input's sighash. Call this
+     * once per input with the signature produced for that input's signablePayloads[i].
      *
-     * @param privateKey 32-byte private key buffer
+     * @param index      0-based index of the input to sign
+     * @param publicKey  compressed secp256k1 public key (33 bytes hex) — not used in
+     *                   the scriptSig bytes but kept for symmetry with addSignature
+     * @param signature  64-byte signature buffer for input[index]
+     * @param sigHashType SigHash type (default: SIGHASH_ALL)
+     */
+    addSignatureForInput(index: number, publicKey: string, signature: Buffer, sigHashType?: number): void;
+    /**
+     * Sign all inputs with the given private key.
+     *
+     * Automatically selects the signature algorithm per input by inspecting each
+     * input's scriptPublicKey:
+     *   - Schnorr (last opcode 0xAC, v0 address): BIP-340 Schnorr + Blake2b sighash
+     *   - ECDSA   (last opcode 0xAB, v1 address): secp256k1 ECDSA + Blake2b+SHA256 sighash
+     *
+     * A single transaction may mix both address types and each input will be
+     * signed correctly without any extra parameters.
+     *
+     * @param privateKey  32-byte private key buffer
      * @param sigHashType SigHash type (default: SIGHASH_ALL = 0x01)
      */
     sign(privateKey: Buffer, sigHashType?: number): void;
     /**
-     * Verify that a Schnorr signature on a specific input is valid.
+     * Verify that the signature on a specific input is valid.
+     *
+     * Automatically selects the verification algorithm based on the input's
+     * scriptPublicKey (ECDSA for 0xAB, Schnorr for 0xAC), matching `sign()`.
      *
-     * @param publicKey 33-byte compressed public key (or 32-byte x-only)
+     * @param publicKey  33-byte compressed public key (or 32-byte x-only for Schnorr)
      * @param inputIndex Index of the input to verify
      * @param sigHashType SigHash type used when signing
      */
@@ -26,11 +71,26 @@ export declare class Transaction extends BaseTransaction {
      */
     explainTransaction(): TransactionExplanation;
     /**
-     * Serialize the transaction to a JSON string (broadcast format).
+     * Serialize the transaction to the Kaspa REST API JSON string.
+     *
+     * This is the wire format accepted by the Kaspa node REST API for broadcasting.
+     * Unsigned transactions (signatureScript = "") use this same structure; once
+     * all inputs are signed the same format is submitted to the node.
+     *
+     * Note: inputs in this format carry only `previousOutpoint`, `signatureScript`,
+     * `sequence`, and `sigOpCount`. The `amount` and `scriptPublicKey` fields needed
+     * for sighash computation are NOT present here — they live in `toJson()`.
      */
     toBroadcastFormat(): string;
     /**
-     * Serialize transaction to hex (JSON-encoded then hex-encoded).
+     * Serialize transaction to hex using the internal `KaspaTransactionData` format.
+     *
+     * This hex is used for SDK-internal round-trips (builder serialisation / deserialisation)
+     * because the internal format preserves `amount` and `scriptPublicKey` on inputs,
+     * which are required for sighash computation but are not present in the REST API format.
+     *
+     * Use `Buffer.from(tx.toBroadcastFormat()).toString('hex')` when you need the hex
+     * representation of the broadcast / HSM wire format.
      */
     toHex(): string;
     /**
@@ -49,5 +109,33 @@ export declare class Transaction extends BaseTransaction {
     get signature(): string[];
     /** @inheritDoc */
     canSign(_key: BaseKey): boolean;
+    /**
+     * Convert this transaction to a PSKT in SIGNER role.
+     *
+     * The PSKT is populated with UTXO data from each input so that sighash
+     * computation is possible immediately. Any existing `signatureScript` on an
+     * input is carried into the PSKT as `finalScriptSig`.
+     *
+     * Typical use:
+     * ```ts
+     * const pskt = tx.toPskt()
+     *   .sign(privateKey)
+     *   .toFinalizer()
+     *   .finalize()
+     *   .toExtractor();
+     * const broadcastJson = pskt.extract();
+     * ```
+     */
+    toPskt(): Pskt;
+    /**
+     * Reconstruct a Transaction from a PSKT (any role).
+     *
+     * `finalScriptSig` from each PSKT input is mapped to `signatureScript` so
+     * that the resulting transaction is signed if the PSKT has been finalised.
+     *
+     * @param coin  Coin name string (e.g. 'kaspa', 'tkaspa')
+     * @param pskt  A Pskt instance (typically at FINALIZER or EXTRACTOR role)
+     */
+    static fromPskt(coin: string, pskt: Pskt): Transaction;
 }
 //# sourceMappingURL=transaction.d.ts.map

package/dist/src/lib/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,eAAe,EAAmB,MAAM,sBAAsB,CAAC;AAEjF,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAGvE,qBAAa,WAAY,SAAQ,eAAe;IAC9C,SAAS,CAAC,OAAO,EAAE,oBAAoB,CAAC;gBAE5B,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,oBAAoB;IASvD,kBAAkB;IAClB,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,IAAI,MAAM,IAAI,oBAAoB,CAEjC;IAED;;;;;OAKG;IACH,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,GAAE,MAAoB,GAAG,IAAI;IAajE;;;;;;OAMG;IACH,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAE,MAAoB,GAAG,OAAO;IAgBlG;;OAEG;IACH,kBAAkB,IAAI,sBAAsB;IA8B5C;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAI3B;;OAEG;IACH,KAAK,IAAI,MAAM;IAIf;;OAEG;IACH,MAAM,IAAI,oBAAoB;IAI9B;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW;IAKtD;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,WAAW;IAK/E,kBAAkB;IAClB,IAAI,SAAS,IAAI,MAAM,EAAE,CAExB;IAED,kBAAkB;IAClB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;CAGhC"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,eAAe,EAAmB,MAAM,sBAAsB,CAAC;AAEjF,OAAO,EAAE,oBAAoB,EAAkB,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAGvF,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAY9B,qBAAa,WAAY,SAAQ,eAAe;IAC9C,SAAS,CAAC,OAAO,EAAE,oBAAoB,CAAC;gBAE5B,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,oBAAoB;IAWvD,kBAAkB;IAClB,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,IAAI,MAAM,IAAI,oBAAoB,CAEjC;IAED;;;OAGG;IACH,IAAI,GAAG,IAAI,MAAM,CAahB;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,gBAAgB,IAAI,MAAM,EAAE,CAS/B;IAED;;;;;;;;;;;;OAYG;IACH,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,GAAE,MAAoB,GAAG,IAAI;IAalH;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,GAAE,MAAoB,GAAG,IAAI;IAwBjE;;;;;;;;;OASG;IACH,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAE,MAAoB,GAAG,OAAO;IAyBlG;;OAEG;IACH,kBAAkB,IAAI,sBAAsB;IA8B5C;;;;;;;;;;OAUG;IACH,iBAAiB,IAAI,MAAM;IA0B3B;;;;;;;;;OASG;IACH,KAAK,IAAI,MAAM;IAIf;;OAEG;IACH,MAAM,IAAI,oBAAoB;IAI9B;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW;IAKtD;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,WAAW;IAK/E,kBAAkB;IAClB,IAAI,SAAS,IAAI,MAAM,EAAE,CAExB;IAED,kBAAkB;IAClB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;IAI/B;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,IAAI,IAAI;IAId;;;;;;;;OAQG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,WAAW;CAGvD"}