@bitgo-beta/sdk-coin-kaspa 0.0.1-beta.43 → 0.0.1-beta.430

package/dist/src/lib/transaction.js

@@ -4,8 +4,22 @@ exports.Transaction = void 0;
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
 const secp256k1_1 = require("@bitgo-beta/secp256k1");
 const sighash_1 = require("./sighash");
+const constants_1 = require("./constants");
+const pskt_1 = require("./pskt");
+/**
+ * Returns true when `input`'s scriptPublicKey belongs to a Kaspa ECDSA (v1)
+ * address — last opcode is OpCheckSigECDSA (0xAB).
+ * Schnorr (v0) scripts end with OpCheckSig (0xAC).
+ */
+function isEcdsaInput(input) {
+    if (!input.scriptPublicKey || input.scriptPublicKey.length < 2)
+        return false;
+    return parseInt(input.scriptPublicKey.slice(-2), 16) === constants_1.OP_CHECKSIG_ECDSA;
+}
 class Transaction extends sdk_core_1.BaseTransaction {
     constructor(coin, txData) {
+        // BaseTransaction expects a full statics CoinConfig; we only have the coin name string here.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         super({ coin });
         this._txData = txData || {
             version: 0,
@@ -24,7 +38,7 @@ class Transaction extends sdk_core_1.BaseTransaction {
      * Get the transaction fee in sompi.
      * If fee was explicitly set, returns that. Otherwise computes from inputs - outputs.
      */
-    get getFee() {
+    get fee() {
         if (this._txData.fee) {
             return this._txData.fee;
         }
@@ -39,81 +53,121 @@ class Transaction extends sdk_core_1.BaseTransaction {
         return (totalIn - totalOut).toString();
     }
     /**
-     * Returns the signable payload for TSS/MPC signing.
+     * Returns one sighash Buffer per input — the set of messages that must be
+     * signed for a multi-input MPCv2 ceremony.
      *
-     * For Kaspa, each input has its own sighash (BIP-143-like scheme with Blake2b).
-     * This returns the sighash for the first input, which is what TSS signs.
-     * For multi-input transactions, all inputs share the same key so the same
-     * Schnorr signature is applied to each input's individual sighash in addSignature().
+     * 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().
      *
-     * @see ADA's Transaction.signablePayload for the equivalent pattern
+     * 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 signablePayload() {
+    get signablePayloads() {
         if (this._txData.inputs.length === 0) {
-            throw new Error('Cannot compute signablePayload: no inputs');
+            throw new Error('Cannot compute signablePayloads: no inputs');
         }
-        return (0, sighash_1.computeKaspaSigningHash)(this._txData, 0, sighash_1.SIGHASH_ALL);
+        return this._txData.inputs.map((input, i) => isEcdsaInput(input)
+            ? (0, sighash_1.computeKaspaEcdsaSigningHash)(this._txData, i, constants_1.SIGHASH_ALL)
+            : (0, sighash_1.computeKaspaSigningHash)(this._txData, i, constants_1.SIGHASH_ALL));
     }
     /**
-     * Apply a Schnorr signature produced by TSS/MPC signing to all inputs.
+     * Apply a signature to a single specific input.
      *
-     * In TSS flow, the keyserver signs the first input's sighash. Since each input
-     * has a different sighash, we re-sign each input individually using the
-     * x-only public key derived from the compressed public key.
+     * 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 publicKey compressed secp256k1 public key (33 bytes hex)
-     * @param signature 64-byte Schnorr signature buffer (from TSS)
+     * @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)
      */
-    addSignature(publicKey, signature, sigHashType = sighash_1.SIGHASH_ALL) {
-        if (signature.length !== 64) {
-            throw new Error(`Expected 64-byte Schnorr signature, got ${signature.length}`);
+    addSignatureForInput(index, publicKey, signature, sigHashType = constants_1.SIGHASH_ALL) {
+        if (index < 0 || index >= this._txData.inputs.length) {
+            throw new Error(`Input index ${index} is out of range (tx has ${this._txData.inputs.length} inputs)`);
         }
-        for (let i = 0; i < this._txData.inputs.length; i++) {
-            // Each input gets the same signature format: 64-byte sig + sighash type byte
-            const sigWithType = Buffer.concat([signature, Buffer.from([sigHashType])]);
-            this._txData.inputs[i].signatureScript = sigWithType.toString('hex');
+        if (signature.length !== 64) {
+            throw new Error(`Expected 64-byte signature, got ${signature.length}`);
         }
+        // Kaspa script engine requires push-only signatureScripts.
+        // 0x41 = OP_DATA_65: push the next 65 bytes (64-byte sig + 1-byte sighash type) onto the stack.
+        const sigWithType = Buffer.concat([Buffer.from([0x41]), signature, Buffer.from([sigHashType])]);
+        this._txData.inputs[index].signatureScript = sigWithType.toString('hex');
     }
     /**
-     * Sign all inputs with the given private key using Schnorr signatures.
+     * 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
      *
-     * @param privateKey 32-byte private key buffer
+     * 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, sigHashType = sighash_1.SIGHASH_ALL) {
+    sign(privateKey, sigHashType = constants_1.SIGHASH_ALL) {
         if (privateKey.length !== 32) {
             throw new Error(`Expected 32-byte private key, got ${privateKey.length}`);
         }
         for (let i = 0; i < this._txData.inputs.length; i++) {
-            const sigHash = (0, sighash_1.computeKaspaSigningHash)(this._txData, i, sigHashType);
-            const sig = secp256k1_1.ecc.signSchnorr(sigHash, privateKey);
-            // 65-byte signature: 64-byte Schnorr sig + 1-byte sighash type
-            const sigWithType = Buffer.concat([Buffer.from(sig), Buffer.from([sigHashType])]);
+            const input = this._txData.inputs[i];
+            let sig;
+            let sigHash;
+            if (isEcdsaInput(input)) {
+                // v1 ECDSA address: double-hash + compact secp256k1 ECDSA signature
+                sigHash = (0, sighash_1.computeKaspaEcdsaSigningHash)(this._txData, i, sigHashType);
+                sig = secp256k1_1.ecc.sign(sigHash, privateKey);
+            }
+            else {
+                // v0 Schnorr address (default): Blake2b sighash + BIP-340 Schnorr signature
+                sigHash = (0, sighash_1.computeKaspaSigningHash)(this._txData, i, sigHashType);
+                sig = secp256k1_1.ecc.signSchnorr(sigHash, privateKey);
+            }
+            // Kaspa requires push-only signatureScripts: 0x41 (OP_DATA_65) + 64-byte sig + 1-byte sighash type
+            const sigWithType = Buffer.concat([Buffer.from([0x41]), Buffer.from(sig), Buffer.from([sigHashType])]);
             this._txData.inputs[i].signatureScript = sigWithType.toString('hex');
         }
     }
     /**
-     * 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
      */
-    verifySignature(publicKey, inputIndex, sigHashType = sighash_1.SIGHASH_ALL) {
+    verifySignature(publicKey, inputIndex, sigHashType = constants_1.SIGHASH_ALL) {
         const input = this._txData.inputs[inputIndex];
         if (!input?.signatureScript) {
             return false;
         }
         const sigBytes = Buffer.from(input.signatureScript, 'hex');
-        if (sigBytes.length < 65) {
+        // signatureScript layout: 0x41 (OP_DATA_65) + 64-byte sig + 1-byte sighash type = 66 bytes
+        if (sigBytes.length < 66) {
             return false;
         }
-        const sig = sigBytes.slice(0, 64);
-        const sigHash = (0, sighash_1.computeKaspaSigningHash)(this._txData, inputIndex, sigHashType);
-        // Accept 33-byte compressed or 32-byte x-only
-        const xOnlyPub = publicKey.length === 33 ? publicKey.slice(1) : publicKey;
-        return secp256k1_1.ecc.verifySchnorr(sigHash, xOnlyPub, sig);
+        const sig = sigBytes.slice(1, 65); // skip the 0x41 push opcode
+        if (isEcdsaInput(input)) {
+            const sigHash = (0, sighash_1.computeKaspaEcdsaSigningHash)(this._txData, inputIndex, sigHashType);
+            // ECDSA verification requires 33-byte compressed public key
+            const compressedPub = publicKey.length === 33 ? publicKey : Buffer.concat([Buffer.from([0x02]), publicKey]);
+            return secp256k1_1.ecc.verify(sigHash, compressedPub, sig);
+        }
+        else {
+            const sigHash = (0, sighash_1.computeKaspaSigningHash)(this._txData, inputIndex, sigHashType);
+            // Schnorr verification uses x-only (32-byte) public key
+            const xOnlyPub = publicKey.length === 33 ? publicKey.slice(1) : publicKey;
+            return secp256k1_1.ecc.verifySchnorr(sigHash, xOnlyPub, sig);
+        }
     }
     /**
      * Explain the transaction in a human-readable format.
@@ -144,16 +198,53 @@ class Transaction extends sdk_core_1.BaseTransaction {
         };
     }
     /**
-     * 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() {
-        return JSON.stringify(this._txData);
+        return JSON.stringify({
+            version: this._txData.version,
+            inputs: this._txData.inputs.map((input) => ({
+                previousOutpoint: {
+                    transactionId: input.transactionId,
+                    index: input.transactionIndex,
+                },
+                signatureScript: input.signatureScript || '',
+                sequence: Number(input.sequence ?? 0),
+                sigOpCount: input.sigOpCount ?? 1,
+            })),
+            outputs: this._txData.outputs.map((output) => ({
+                amount: Number(output.amount),
+                scriptPublicKey: {
+                    version: 0,
+                    scriptPublicKey: output.scriptPublicKey || '',
+                },
+            })),
+            lockTime: Number(this._txData.lockTime ?? 0),
+            subnetworkId: this._txData.subnetworkId ?? '0000000000000000000000000000000000000000',
+            gas: 0,
+            payload: this._txData.payload ?? '',
+        });
     }
     /**
-     * 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() {
-        return Buffer.from(this.toBroadcastFormat()).toString('hex');
+        return Buffer.from(JSON.stringify(this._txData)).toString('hex');
     }
     /**
      * Return transaction data as a plain object.
@@ -183,6 +274,38 @@ class Transaction extends sdk_core_1.BaseTransaction {
     canSign(_key) {
         return true;
     }
+    /**
+     * 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() {
+        return pskt_1.Pskt.fromTxData(this._txData);
+    }
+    /**
+     * 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, pskt) {
+        return new Transaction(coin, pskt.toTxData());
+    }
 }
 exports.Transaction = Transaction;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseKey, BaseTransaction, TransactionType } from '@bitgo-beta/sdk-core';\nimport { ecc } from '@bitgo-beta/secp256k1';\nimport { KaspaTransactionData, TransactionExplanation } from './iface';\nimport { computeKaspaSigningHash, SIGHASH_ALL } from './sighash';\n\nexport class Transaction extends BaseTransaction {\n  protected _txData: KaspaTransactionData;\n\n  constructor(coin: string, txData?: KaspaTransactionData) {\n    super({ coin } as any);\n    this._txData = txData || {\n      version: 0,\n      inputs: [],\n      outputs: [],\n    };\n  }\n\n  /** @inheritDoc */\n  get id(): string {\n    return this._txData.id || '';\n  }\n\n  get txData(): KaspaTransactionData {\n    return this._txData;\n  }\n\n  /**\n   * Get the transaction fee in sompi.\n   * If fee was explicitly set, returns that. Otherwise computes from inputs - outputs.\n   */\n  get getFee(): string {\n    if (this._txData.fee) {\n      return this._txData.fee;\n    }\n    let totalIn = BigInt(0);\n    let totalOut = BigInt(0);\n    for (const input of this._txData.inputs) {\n      totalIn += BigInt(input.amount);\n    }\n    for (const output of this._txData.outputs) {\n      totalOut += BigInt(output.amount);\n    }\n    return (totalIn - totalOut).toString();\n  }\n\n  /**\n   * Returns the signable payload for TSS/MPC signing.\n   *\n   * For Kaspa, each input has its own sighash (BIP-143-like scheme with Blake2b).\n   * This returns the sighash for the first input, which is what TSS signs.\n   * For multi-input transactions, all inputs share the same key so the same\n   * Schnorr signature is applied to each input's individual sighash in addSignature().\n   *\n   * @see ADA's Transaction.signablePayload for the equivalent pattern\n   */\n  get signablePayload(): Buffer {\n    if (this._txData.inputs.length === 0) {\n      throw new Error('Cannot compute signablePayload: no inputs');\n    }\n    return computeKaspaSigningHash(this._txData, 0, SIGHASH_ALL);\n  }\n\n  /**\n   * Apply a Schnorr signature produced by TSS/MPC signing to all inputs.\n   *\n   * In TSS flow, the keyserver signs the first input's sighash. Since each input\n   * has a different sighash, we re-sign each input individually using the\n   * x-only public key derived from the compressed public key.\n   *\n   * @param publicKey compressed secp256k1 public key (33 bytes hex)\n   * @param signature 64-byte Schnorr signature buffer (from TSS)\n   * @param sigHashType SigHash type (default: SIGHASH_ALL)\n   */\n  addSignature(publicKey: string, signature: Buffer, sigHashType: number = SIGHASH_ALL): void {\n    if (signature.length !== 64) {\n      throw new Error(`Expected 64-byte Schnorr signature, got ${signature.length}`);\n    }\n\n    for (let i = 0; i < this._txData.inputs.length; i++) {\n      // Each input gets the same signature format: 64-byte sig + sighash type byte\n      const sigWithType = Buffer.concat([signature, Buffer.from([sigHashType])]);\n      this._txData.inputs[i].signatureScript = sigWithType.toString('hex');\n    }\n  }\n\n  /**\n   * Sign all inputs with the given private key using Schnorr signatures.\n   *\n   * @param privateKey 32-byte private key buffer\n   * @param sigHashType SigHash type (default: SIGHASH_ALL = 0x01)\n   */\n  sign(privateKey: Buffer, sigHashType: number = SIGHASH_ALL): void {\n    if (privateKey.length !== 32) {\n      throw new Error(`Expected 32-byte private key, got ${privateKey.length}`);\n    }\n    for (let i = 0; i < this._txData.inputs.length; i++) {\n      const sigHash = computeKaspaSigningHash(this._txData, i, sigHashType);\n      const sig = ecc.signSchnorr(sigHash, privateKey);\n      // 65-byte signature: 64-byte Schnorr sig + 1-byte sighash type\n      const sigWithType = Buffer.concat([Buffer.from(sig), Buffer.from([sigHashType])]);\n      this._txData.inputs[i].signatureScript = sigWithType.toString('hex');\n    }\n  }\n\n  /**\n   * Verify that a Schnorr signature on a specific input is valid.\n   *\n   * @param publicKey 33-byte compressed public key (or 32-byte x-only)\n   * @param inputIndex Index of the input to verify\n   * @param sigHashType SigHash type used when signing\n   */\n  verifySignature(publicKey: Buffer, inputIndex: number, sigHashType: number = SIGHASH_ALL): boolean {\n    const input = this._txData.inputs[inputIndex];\n    if (!input?.signatureScript) {\n      return false;\n    }\n    const sigBytes = Buffer.from(input.signatureScript, 'hex');\n    if (sigBytes.length < 65) {\n      return false;\n    }\n    const sig = sigBytes.slice(0, 64);\n    const sigHash = computeKaspaSigningHash(this._txData, inputIndex, sigHashType);\n    // Accept 33-byte compressed or 32-byte x-only\n    const xOnlyPub = publicKey.length === 33 ? publicKey.slice(1) : publicKey;\n    return ecc.verifySchnorr(sigHash, xOnlyPub, sig);\n  }\n\n  /**\n   * Explain the transaction in a human-readable format.\n   */\n  explainTransaction(): TransactionExplanation {\n    let totalIn = BigInt(0);\n    let totalOut = BigInt(0);\n\n    for (const input of this._txData.inputs) {\n      totalIn += BigInt(input.amount);\n    }\n    for (const output of this._txData.outputs) {\n      totalOut += BigInt(output.amount);\n    }\n\n    const fee = (totalIn - totalOut).toString();\n\n    const outputs = this._txData.outputs.map((o) => ({\n      address: o.address,\n      amount: o.amount,\n    }));\n\n    return {\n      id: this._txData.id || '',\n      type: TransactionType.Send,\n      outputs,\n      outputAmount: totalOut.toString(),\n      changeOutputs: [],\n      changeAmount: '0',\n      fee: { fee: this._txData.fee || fee },\n      inputs: this._txData.inputs,\n    };\n  }\n\n  /**\n   * Serialize the transaction to a JSON string (broadcast format).\n   */\n  toBroadcastFormat(): string {\n    return JSON.stringify(this._txData);\n  }\n\n  /**\n   * Serialize transaction to hex (JSON-encoded then hex-encoded).\n   */\n  toHex(): string {\n    return Buffer.from(this.toBroadcastFormat()).toString('hex');\n  }\n\n  /**\n   * Return transaction data as a plain object.\n   */\n  toJson(): KaspaTransactionData {\n    return { ...this._txData };\n  }\n\n  /**\n   * Deserialize from hex.\n   */\n  static fromHex(coin: string, hex: string): Transaction {\n    const json = JSON.parse(Buffer.from(hex, 'hex').toString());\n    return new Transaction(coin, json);\n  }\n\n  /**\n   * Deserialize from JSON string or object.\n   */\n  static fromJson(coin: string, data: string | KaspaTransactionData): Transaction {\n    const txData: KaspaTransactionData = typeof data === 'string' ? JSON.parse(data) : data;\n    return new Transaction(coin, txData);\n  }\n\n  /** @inheritDoc */\n  get signature(): string[] {\n    return this._txData.inputs.map((i) => i.signatureScript || '');\n  }\n\n  /** @inheritDoc */\n  canSign(_key: BaseKey): boolean {\n    return true;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseKey, BaseTransaction, TransactionType } from '@bitgo-beta/sdk-core';\nimport { ecc } from '@bitgo-beta/secp256k1';\nimport { KaspaTransactionData, KaspaUtxoInput, TransactionExplanation } from './iface';\nimport { computeKaspaSigningHash, computeKaspaEcdsaSigningHash } from './sighash';\nimport { OP_CHECKSIG_ECDSA, SIGHASH_ALL } from './constants';\nimport { Pskt } from './pskt';\n\n/**\n * Returns true when `input`'s scriptPublicKey belongs to a Kaspa ECDSA (v1)\n * address — last opcode is OpCheckSigECDSA (0xAB).\n * Schnorr (v0) scripts end with OpCheckSig (0xAC).\n */\nfunction isEcdsaInput(input: KaspaUtxoInput): boolean {\n  if (!input.scriptPublicKey || input.scriptPublicKey.length < 2) return false;\n  return parseInt(input.scriptPublicKey.slice(-2), 16) === OP_CHECKSIG_ECDSA;\n}\n\nexport class Transaction extends BaseTransaction {\n  protected _txData: KaspaTransactionData;\n\n  constructor(coin: string, txData?: KaspaTransactionData) {\n    // BaseTransaction expects a full statics CoinConfig; we only have the coin name string here.\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    super({ coin } as any);\n    this._txData = txData || {\n      version: 0,\n      inputs: [],\n      outputs: [],\n    };\n  }\n\n  /** @inheritDoc */\n  get id(): string {\n    return this._txData.id || '';\n  }\n\n  get txData(): KaspaTransactionData {\n    return this._txData;\n  }\n\n  /**\n   * Get the transaction fee in sompi.\n   * If fee was explicitly set, returns that. Otherwise computes from inputs - outputs.\n   */\n  get fee(): string {\n    if (this._txData.fee) {\n      return this._txData.fee;\n    }\n    let totalIn = BigInt(0);\n    let totalOut = BigInt(0);\n    for (const input of this._txData.inputs) {\n      totalIn += BigInt(input.amount);\n    }\n    for (const output of this._txData.outputs) {\n      totalOut += BigInt(output.amount);\n    }\n    return (totalIn - totalOut).toString();\n  }\n\n  /**\n   * Returns one sighash Buffer per input — the set of messages that must be\n   * signed for a multi-input MPCv2 ceremony.\n   *\n   * Kaspa uses a BIP-143-like sighash scheme (Blake2b) where each input commits\n   * to its own index, so input[i] has a distinct hash that cannot be re-used for\n   * input[j]. A correct multi-input MPCv2 flow runs one DKLS session per input\n   * in parallel and applies each resulting signature via addSignatureForInput().\n   *\n   * The hash type is automatically selected per input:\n   *   - Schnorr (scriptPublicKey ends 0xAC): keyed Blake2b-256\n   *   - ECDSA   (scriptPublicKey ends 0xAB): keyed Blake2b-256 + SHA256 double-hash\n   */\n  get signablePayloads(): Buffer[] {\n    if (this._txData.inputs.length === 0) {\n      throw new Error('Cannot compute signablePayloads: no inputs');\n    }\n    return this._txData.inputs.map((input, i) =>\n      isEcdsaInput(input)\n        ? computeKaspaEcdsaSigningHash(this._txData, i, SIGHASH_ALL)\n        : computeKaspaSigningHash(this._txData, i, SIGHASH_ALL)\n    );\n  }\n\n  /**\n   * Apply a signature to a single specific input.\n   *\n   * Used in the multi-input MPCv2 flow where each input is signed by an\n   * independent DKLS session that commits to that input's sighash. Call this\n   * once per input with the signature produced for that input's signablePayloads[i].\n   *\n   * @param index      0-based index of the input to sign\n   * @param publicKey  compressed secp256k1 public key (33 bytes hex) — not used in\n   *                   the scriptSig bytes but kept for symmetry with addSignature\n   * @param signature  64-byte signature buffer for input[index]\n   * @param sigHashType SigHash type (default: SIGHASH_ALL)\n   */\n  addSignatureForInput(index: number, publicKey: string, signature: Buffer, sigHashType: number = SIGHASH_ALL): void {\n    if (index < 0 || index >= this._txData.inputs.length) {\n      throw new Error(`Input index ${index} is out of range (tx has ${this._txData.inputs.length} inputs)`);\n    }\n    if (signature.length !== 64) {\n      throw new Error(`Expected 64-byte signature, got ${signature.length}`);\n    }\n    // Kaspa script engine requires push-only signatureScripts.\n    // 0x41 = OP_DATA_65: push the next 65 bytes (64-byte sig + 1-byte sighash type) onto the stack.\n    const sigWithType = Buffer.concat([Buffer.from([0x41]), signature, Buffer.from([sigHashType])]);\n    this._txData.inputs[index].signatureScript = sigWithType.toString('hex');\n  }\n\n  /**\n   * Sign all inputs with the given private key.\n   *\n   * Automatically selects the signature algorithm per input by inspecting each\n   * input's scriptPublicKey:\n   *   - Schnorr (last opcode 0xAC, v0 address): BIP-340 Schnorr + Blake2b sighash\n   *   - ECDSA   (last opcode 0xAB, v1 address): secp256k1 ECDSA + Blake2b+SHA256 sighash\n   *\n   * A single transaction may mix both address types and each input will be\n   * signed correctly without any extra parameters.\n   *\n   * @param privateKey  32-byte private key buffer\n   * @param sigHashType SigHash type (default: SIGHASH_ALL = 0x01)\n   */\n  sign(privateKey: Buffer, sigHashType: number = SIGHASH_ALL): void {\n    if (privateKey.length !== 32) {\n      throw new Error(`Expected 32-byte private key, got ${privateKey.length}`);\n    }\n    for (let i = 0; i < this._txData.inputs.length; i++) {\n      const input = this._txData.inputs[i];\n      let sig: Uint8Array;\n      let sigHash: Buffer;\n\n      if (isEcdsaInput(input)) {\n        // v1 ECDSA address: double-hash + compact secp256k1 ECDSA signature\n        sigHash = computeKaspaEcdsaSigningHash(this._txData, i, sigHashType);\n        sig = ecc.sign(sigHash, privateKey);\n      } else {\n        // v0 Schnorr address (default): Blake2b sighash + BIP-340 Schnorr signature\n        sigHash = computeKaspaSigningHash(this._txData, i, sigHashType);\n        sig = ecc.signSchnorr(sigHash, privateKey);\n      }\n      // Kaspa requires push-only signatureScripts: 0x41 (OP_DATA_65) + 64-byte sig + 1-byte sighash type\n      const sigWithType = Buffer.concat([Buffer.from([0x41]), Buffer.from(sig), Buffer.from([sigHashType])]);\n      this._txData.inputs[i].signatureScript = sigWithType.toString('hex');\n    }\n  }\n\n  /**\n   * Verify that the signature on a specific input is valid.\n   *\n   * Automatically selects the verification algorithm based on the input's\n   * scriptPublicKey (ECDSA for 0xAB, Schnorr for 0xAC), matching `sign()`.\n   *\n   * @param publicKey  33-byte compressed public key (or 32-byte x-only for Schnorr)\n   * @param inputIndex Index of the input to verify\n   * @param sigHashType SigHash type used when signing\n   */\n  verifySignature(publicKey: Buffer, inputIndex: number, sigHashType: number = SIGHASH_ALL): boolean {\n    const input = this._txData.inputs[inputIndex];\n    if (!input?.signatureScript) {\n      return false;\n    }\n    const sigBytes = Buffer.from(input.signatureScript, 'hex');\n    // signatureScript layout: 0x41 (OP_DATA_65) + 64-byte sig + 1-byte sighash type = 66 bytes\n    if (sigBytes.length < 66) {\n      return false;\n    }\n    const sig = sigBytes.slice(1, 65); // skip the 0x41 push opcode\n\n    if (isEcdsaInput(input)) {\n      const sigHash = computeKaspaEcdsaSigningHash(this._txData, inputIndex, sigHashType);\n      // ECDSA verification requires 33-byte compressed public key\n      const compressedPub = publicKey.length === 33 ? publicKey : Buffer.concat([Buffer.from([0x02]), publicKey]);\n      return ecc.verify(sigHash, compressedPub, sig);\n    } else {\n      const sigHash = computeKaspaSigningHash(this._txData, inputIndex, sigHashType);\n      // Schnorr verification uses x-only (32-byte) public key\n      const xOnlyPub = publicKey.length === 33 ? publicKey.slice(1) : publicKey;\n      return ecc.verifySchnorr(sigHash, xOnlyPub, sig);\n    }\n  }\n\n  /**\n   * Explain the transaction in a human-readable format.\n   */\n  explainTransaction(): TransactionExplanation {\n    let totalIn = BigInt(0);\n    let totalOut = BigInt(0);\n\n    for (const input of this._txData.inputs) {\n      totalIn += BigInt(input.amount);\n    }\n    for (const output of this._txData.outputs) {\n      totalOut += BigInt(output.amount);\n    }\n\n    const fee = (totalIn - totalOut).toString();\n\n    const outputs = this._txData.outputs.map((o) => ({\n      address: o.address,\n      amount: o.amount,\n    }));\n\n    return {\n      id: this._txData.id || '',\n      type: TransactionType.Send,\n      outputs,\n      outputAmount: totalOut.toString(),\n      changeOutputs: [],\n      changeAmount: '0',\n      fee: { fee: this._txData.fee || fee },\n      inputs: this._txData.inputs,\n    };\n  }\n\n  /**\n   * Serialize the transaction to the Kaspa REST API JSON string.\n   *\n   * This is the wire format accepted by the Kaspa node REST API for broadcasting.\n   * Unsigned transactions (signatureScript = \"\") use this same structure; once\n   * all inputs are signed the same format is submitted to the node.\n   *\n   * Note: inputs in this format carry only `previousOutpoint`, `signatureScript`,\n   * `sequence`, and `sigOpCount`. The `amount` and `scriptPublicKey` fields needed\n   * for sighash computation are NOT present here — they live in `toJson()`.\n   */\n  toBroadcastFormat(): string {\n    return JSON.stringify({\n      version: this._txData.version,\n      inputs: this._txData.inputs.map((input) => ({\n        previousOutpoint: {\n          transactionId: input.transactionId,\n          index: input.transactionIndex,\n        },\n        signatureScript: input.signatureScript || '',\n        sequence: Number(input.sequence ?? 0),\n        sigOpCount: input.sigOpCount ?? 1,\n      })),\n      outputs: this._txData.outputs.map((output) => ({\n        amount: Number(output.amount),\n        scriptPublicKey: {\n          version: 0,\n          scriptPublicKey: output.scriptPublicKey || '',\n        },\n      })),\n      lockTime: Number(this._txData.lockTime ?? 0),\n      subnetworkId: this._txData.subnetworkId ?? '0000000000000000000000000000000000000000',\n      gas: 0,\n      payload: this._txData.payload ?? '',\n    });\n  }\n\n  /**\n   * Serialize transaction to hex using the internal `KaspaTransactionData` format.\n   *\n   * This hex is used for SDK-internal round-trips (builder serialisation / deserialisation)\n   * because the internal format preserves `amount` and `scriptPublicKey` on inputs,\n   * which are required for sighash computation but are not present in the REST API format.\n   *\n   * Use `Buffer.from(tx.toBroadcastFormat()).toString('hex')` when you need the hex\n   * representation of the broadcast / HSM wire format.\n   */\n  toHex(): string {\n    return Buffer.from(JSON.stringify(this._txData)).toString('hex');\n  }\n\n  /**\n   * Return transaction data as a plain object.\n   */\n  toJson(): KaspaTransactionData {\n    return { ...this._txData };\n  }\n\n  /**\n   * Deserialize from hex.\n   */\n  static fromHex(coin: string, hex: string): Transaction {\n    const json = JSON.parse(Buffer.from(hex, 'hex').toString());\n    return new Transaction(coin, json);\n  }\n\n  /**\n   * Deserialize from JSON string or object.\n   */\n  static fromJson(coin: string, data: string | KaspaTransactionData): Transaction {\n    const txData: KaspaTransactionData = typeof data === 'string' ? JSON.parse(data) : data;\n    return new Transaction(coin, txData);\n  }\n\n  /** @inheritDoc */\n  get signature(): string[] {\n    return this._txData.inputs.map((i) => i.signatureScript || '');\n  }\n\n  /** @inheritDoc */\n  canSign(_key: BaseKey): boolean {\n    return true;\n  }\n\n  /**\n   * Convert this transaction to a PSKT in SIGNER role.\n   *\n   * The PSKT is populated with UTXO data from each input so that sighash\n   * computation is possible immediately. Any existing `signatureScript` on an\n   * input is carried into the PSKT as `finalScriptSig`.\n   *\n   * Typical use:\n   * ```ts\n   * const pskt = tx.toPskt()\n   *   .sign(privateKey)\n   *   .toFinalizer()\n   *   .finalize()\n   *   .toExtractor();\n   * const broadcastJson = pskt.extract();\n   * ```\n   */\n  toPskt(): Pskt {\n    return Pskt.fromTxData(this._txData);\n  }\n\n  /**\n   * Reconstruct a Transaction from a PSKT (any role).\n   *\n   * `finalScriptSig` from each PSKT input is mapped to `signatureScript` so\n   * that the resulting transaction is signed if the PSKT has been finalised.\n   *\n   * @param coin  Coin name string (e.g. 'kaspa', 'tkaspa')\n   * @param pskt  A Pskt instance (typically at FINALIZER or EXTRACTOR role)\n   */\n  static fromPskt(coin: string, pskt: Pskt): Transaction {\n    return new Transaction(coin, pskt.toTxData());\n  }\n}\n"]}

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

@@ -1,19 +1,15 @@
-import { BaseTransactionBuilder, BaseTransaction, BaseKey, PublicKey as BasePublicKey } from '@bitgo-beta/sdk-core';
+import { BaseTransactionBuilder, BaseTransaction, BaseKey } from '@bitgo-beta/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
 import BigNumber from 'bignumber.js';
 import { Transaction } from './transaction';
 import { KaspaUtxoInput, KaspaTransactionOutput } from './iface';
-interface KaspaSignature {
-    publicKey: BasePublicKey;
-    signature: Buffer;
-}
+import { Pskt } from './pskt';
 export declare class TransactionBuilder extends BaseTransactionBuilder {
     protected _transaction: Transaction;
     protected _inputs: KaspaUtxoInput[];
     protected _outputs: KaspaTransactionOutput[];
     protected _fee: string;
     protected _fromAddress: string;
-    protected _signatures: KaspaSignature[];
     constructor(coinConfig: Readonly<CoinConfig>);
     /** @inheritDoc */
     protected get transaction(): BaseTransaction;
@@ -39,16 +35,6 @@ export declare class TransactionBuilder extends BaseTransactionBuilder {
      * Add multiple UTXO inputs.
      */
     addInputs(utxos: KaspaUtxoInput[]): this;
-    /**
-     * Add an externally-produced signature (from TSS/MPC signing) to the transaction.
-     * The signature will be applied to all inputs during build().
-     *
-     * This follows the same pattern as ADA's TransactionBuilder.addSignature().
-     *
-     * @param publicKey The compressed secp256k1 public key that produced the signature
-     * @param signature The 64-byte Schnorr signature buffer
-     */
-    addSignature(publicKey: BasePublicKey, signature: Buffer): void;
     /** @inheritDoc */
     protected fromImplementation(rawTransaction: string): Transaction;
     /** @inheritDoc */
@@ -69,6 +55,26 @@ export declare class TransactionBuilder extends BaseTransactionBuilder {
     validateRawTransaction(rawTransaction: string): void;
     /** @inheritDoc */
     validateValue(value: BigNumber): void;
+    /**
+     * Build the transaction and return it as an unsigned PSKT in UPDATER role.
+     *
+     * The PSKT has all inputs and outputs populated with UTXO data but no
+     * signatures. It is ready to be handed to a signer (HSM, hardware wallet,
+     * or MPCv2 session) via `pskt.toSigner().sign(key)` or
+     * `pskt.toSigner().addSignature(...)`.
+     *
+     * Example:
+     * ```ts
+     * const pskt = await builder.toPskt();
+     * const broadcastJson = pskt
+     *   .toSigner()
+     *   .sign(privateKey)
+     *   .toFinalizer()
+     *   .finalize()
+     *   .toExtractor()
+     *   .extract();
+     * ```
+     */
+    toPskt(): Promise<Pskt>;
 }
-export {};
 //# sourceMappingURL=transactionBuilder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,OAAO,EACP,SAAS,IAAI,aAAa,EAE3B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAwB,cAAc,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAKvF,UAAU,cAAc;IACtB,SAAS,EAAE,aAAa,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,kBAAmB,SAAQ,sBAAsB;IAC5D,SAAS,CAAC,YAAY,EAAE,WAAW,CAAC;IACpC,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,CAAM;IACzC,SAAS,CAAC,QAAQ,EAAE,sBAAsB,EAAE,CAAM;IAClD,SAAS,CAAC,IAAI,EAAE,MAAM,CAAe;IACrC,SAAS,CAAC,YAAY,SAAM;IAC5B,SAAS,CAAC,WAAW,EAAE,cAAc,EAAE,CAAM;gBAEjC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK5C,kBAAkB;IAClB,SAAS,KAAK,WAAW,IAAI,eAAe,CAE3C;IAED,kBAAkB;IAClB,SAAS,KAAK,WAAW,CAAC,EAAE,EAAE,eAAe,EAE5C;IAED;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQ7B;;OAEG;IACH,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAQzC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKtB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;IAQpC;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,IAAI;IAKxC;;;;;;;;OAQG;IACH,YAAY,CAAC,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAI/D,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IASjE,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,eAAe,CAAC;IAqB/D,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,EAAE,GAAG,EAAE,EAAE,OAAO,GAAG,eAAe;IAU/D,kBAAkB;IAClB,mBAAmB,CAAC,YAAY,CAAC,EAAE,eAAe,GAAG,IAAI;IASzD,kBAAkB;IAClB,WAAW,CAAC,GAAG,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAIvC,kBAAkB;IAClB,eAAe,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAMnD,kBAAkB;IAClB,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAQpD,kBAAkB;IAClB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;CAKtC"}
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,OAAO,EAAgB,MAAM,sBAAsB,CAAC;AACtG,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAwB,cAAc,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAIvF,OAAO,EAAE,IAAI,EAAyB,MAAM,QAAQ,CAAC;AAErD,qBAAa,kBAAmB,SAAQ,sBAAsB;IAC5D,SAAS,CAAC,YAAY,EAAE,WAAW,CAAC;IACpC,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,CAAM;IACzC,SAAS,CAAC,QAAQ,EAAE,sBAAsB,EAAE,CAAM;IAClD,SAAS,CAAC,IAAI,EAAE,MAAM,CAAe;IACrC,SAAS,CAAC,YAAY,SAAM;gBAEhB,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK5C,kBAAkB;IAClB,SAAS,KAAK,WAAW,IAAI,eAAe,CAE3C;IAED,kBAAkB;IAClB,SAAS,KAAK,WAAW,CAAC,EAAE,EAAE,eAAe,EAE5C;IAED;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQ7B;;OAEG;IACH,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAQzC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKtB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;IAQpC;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,IAAI;IAKxC,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IASjE,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,eAAe,CAAC;IAgB/D,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,EAAE,GAAG,EAAE,EAAE,OAAO,GAAG,eAAe;IAU/D,kBAAkB;IAClB,mBAAmB,CAAC,YAAY,CAAC,EAAE,eAAe,GAAG,IAAI;IASzD,kBAAkB;IAClB,WAAW,CAAC,GAAG,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAIvC,kBAAkB;IAClB,eAAe,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAMnD,kBAAkB;IAClB,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAQpD,kBAAkB;IAClB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAMrC;;;;;;;;;;;;;;;;;;;OAmBG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CA8B9B"}