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

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,
@@ -21,44 +35,139 @@ class Transaction extends sdk_core_1.BaseTransaction {
         return this._txData;
     }
     /**
-     * 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() {
+        if (this._txData.fee) {
+            return this._txData.fee;
+        }
+        let totalIn = BigInt(0);
+        let totalOut = BigInt(0);
+        for (const input of this._txData.inputs) {
+            totalIn += BigInt(input.amount);
+        }
+        for (const output of this._txData.outputs) {
+            totalOut += BigInt(output.amount);
+        }
+        return (totalIn - totalOut).toString();
+    }
+    /**
+     * 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().
      *
-     * @param privateKey 32-byte private key buffer
+     * 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() {
+        if (this._txData.inputs.length === 0) {
+            throw new Error('Cannot compute signablePayloads: no inputs');
+        }
+        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 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 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, 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)`);
+        }
+        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.
+     *
+     * 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, 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.
@@ -89,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.
@@ -128,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   * 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

@@ -3,6 +3,7 @@ import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
 import BigNumber from 'bignumber.js';
 import { Transaction } from './transaction';
 import { KaspaUtxoInput, KaspaTransactionOutput } from './iface';
+import { Pskt } from './pskt';
 export declare class TransactionBuilder extends BaseTransactionBuilder {
     protected _transaction: Transaction;
     protected _inputs: KaspaUtxoInput[];
@@ -54,5 +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>;
 }
 //# 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,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;AAKvF,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;IAe/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"}

package/dist/src/lib/transactionBuilder.js

@@ -6,6 +6,7 @@ const transaction_1 = require("./transaction");
 const utils_1 = require("./utils");
 const keyPair_1 = require("./keyPair");
 const constants_1 = require("./constants");
+const pskt_1 = require("./pskt");
 class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
     constructor(coinConfig) {
         super(coinConfig);
@@ -40,7 +41,7 @@ class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
         if (!(0, utils_1.isValidKaspaAddress)(address)) {
             throw new Error(`Invalid Kaspa recipient address: ${address}`);
         }
-        this._outputs.push({ address, amount });
+        this._outputs.push({ address, amount, scriptPublicKey: (0, utils_1.addressToScriptPublicKey)(address) });
         return this;
     }
     /**
@@ -69,7 +70,7 @@ class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
     }
     /** @inheritDoc */
     fromImplementation(rawTransaction) {
-        const tx = transaction_1.Transaction.fromHex(this._coinConfig?.name || 'kaspa', rawTransaction);
+        const tx = transaction_1.Transaction.fromHex(this._coinConfig.name, rawTransaction);
         this._transaction = tx;
         this._inputs = tx.txData.inputs || [];
         this._outputs = tx.txData.outputs || [];
@@ -87,7 +88,7 @@ class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
             subnetworkId: '0000000000000000000000000000000000000000',
             payload: '',
         };
-        this._transaction = new transaction_1.Transaction(this._coinConfig?.name || 'kaspa', txData);
+        this._transaction = new transaction_1.Transaction(this._coinConfig.name, txData);
         return this._transaction;
     }
     /** @inheritDoc */
@@ -122,7 +123,7 @@ class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
     /** @inheritDoc */
     validateRawTransaction(rawTransaction) {
         try {
-            transaction_1.Transaction.fromHex(this._coinConfig?.name || 'kaspa', rawTransaction);
+            transaction_1.Transaction.fromHex(this._coinConfig.name, rawTransaction);
         }
         catch {
             throw new Error('Invalid raw Kaspa transaction');
@@ -134,6 +135,53 @@ class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
             throw new Error('Transaction value cannot be negative');
         }
     }
+    /**
+     * 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();
+     * ```
+     */
+    async toPskt() {
+        this.validateTransaction();
+        const psktInputs = this._inputs.map((inp) => ({
+            previousOutpoint: { transactionId: inp.transactionId, index: inp.transactionIndex },
+            utxoEntry: { amount: inp.amount, scriptPublicKey: inp.scriptPublicKey },
+            sequence: inp.sequence,
+            sigOpCount: inp.sigOpCount ?? 1,
+            partialSigs: {},
+            sighashType: constants_1.SIGHASH_ALL,
+            bip32Derivations: {},
+            proprietaries: {},
+        }));
+        const psktOutputs = this._outputs.map((out) => ({
+            amount: out.amount,
+            scriptPublicKey: { version: 0, scriptPublicKey: out.scriptPublicKey || (0, utils_1.addressToScriptPublicKey)(out.address) },
+            bip32Derivations: {},
+            proprietaries: {},
+        }));
+        const pskt = pskt_1.Pskt.creator(constants_1.TX_VERSION);
+        for (const inp of psktInputs) {
+            pskt.input(inp);
+        }
+        for (const out of psktOutputs) {
+            pskt.output(out);
+        }
+        return pskt.toUpdater();
+    }
 }
 exports.TransactionBuilder = TransactionBuilder;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTransactionBuilder, BaseTransaction, BaseKey, SigningError } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport BigNumber from 'bignumber.js';\nimport { Transaction } from './transaction';\nimport { KaspaTransactionData, KaspaUtxoInput, KaspaTransactionOutput } from './iface';\nimport { isValidKaspaAddress } from './utils';\nimport { KeyPair } from './keyPair';\nimport { DEFAULT_FEE, TX_VERSION } from './constants';\n\nexport class TransactionBuilder extends BaseTransactionBuilder {\n  protected _transaction: Transaction;\n  protected _inputs: KaspaUtxoInput[] = [];\n  protected _outputs: KaspaTransactionOutput[] = [];\n  protected _fee: string = DEFAULT_FEE;\n  protected _fromAddress = '';\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._transaction = new Transaction(coinConfig.name);\n  }\n\n  /** @inheritDoc */\n  protected get transaction(): BaseTransaction {\n    return this._transaction;\n  }\n\n  /** @inheritDoc */\n  protected set transaction(tx: BaseTransaction) {\n    this._transaction = tx as Transaction;\n  }\n\n  /**\n   * Set the sender address.\n   */\n  sender(address: string): this {\n    if (!isValidKaspaAddress(address)) {\n      throw new Error(`Invalid Kaspa address: ${address}`);\n    }\n    this._fromAddress = address;\n    return this;\n  }\n\n  /**\n   * Add a recipient output.\n   */\n  to(address: string, amount: string): this {\n    if (!isValidKaspaAddress(address)) {\n      throw new Error(`Invalid Kaspa recipient address: ${address}`);\n    }\n    this._outputs.push({ address, amount });\n    return this;\n  }\n\n  /**\n   * Set transaction fee in sompi.\n   */\n  fee(fee: string): this {\n    this._fee = fee;\n    return this;\n  }\n\n  /**\n   * Add a UTXO input.\n   */\n  addInput(utxo: KaspaUtxoInput): this {\n    if (!utxo.transactionId || utxo.transactionIndex === undefined) {\n      throw new Error('Invalid UTXO: missing transactionId or transactionIndex');\n    }\n    this._inputs.push(utxo);\n    return this;\n  }\n\n  /**\n   * Add multiple UTXO inputs.\n   */\n  addInputs(utxos: KaspaUtxoInput[]): this {\n    utxos.forEach((u) => this.addInput(u));\n    return this;\n  }\n\n  /** @inheritDoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = Transaction.fromHex((this as any)._coinConfig?.name || 'kaspa', rawTransaction);\n    this._transaction = tx;\n    this._inputs = tx.txData.inputs || [];\n    this._outputs = tx.txData.outputs || [];\n    this._fee = tx.txData.fee || DEFAULT_FEE;\n    return tx;\n  }\n\n  /** @inheritDoc */\n  protected async buildImplementation(): Promise<BaseTransaction> {\n    const txData: KaspaTransactionData = {\n      version: TX_VERSION,\n      inputs: this._inputs,\n      outputs: this._outputs,\n      fee: this._fee,\n      lockTime: '0',\n      subnetworkId: '0000000000000000000000000000000000000000',\n      payload: '',\n    };\n\n    this._transaction = new Transaction((this as any)._coinConfig?.name || 'kaspa', txData);\n    return this._transaction;\n  }\n\n  /** @inheritDoc */\n  protected signImplementation({ key }: BaseKey): BaseTransaction {\n    const keyPair = new KeyPair({ prv: key });\n    const privateKey = keyPair.getKeys().prv;\n    if (!privateKey) {\n      throw new SigningError('Missing private key');\n    }\n    this._transaction.sign(Buffer.from(privateKey, 'hex'));\n    return this._transaction;\n  }\n\n  /** @inheritDoc */\n  validateTransaction(_transaction?: BaseTransaction): void {\n    if (this._inputs.length === 0) {\n      throw new Error('At least one UTXO input is required');\n    }\n    if (this._outputs.length === 0) {\n      throw new Error('At least one output is required');\n    }\n  }\n\n  /** @inheritDoc */\n  validateKey(key: { key: string }): void {\n    // Key validation handled in KeyPair\n  }\n\n  /** @inheritDoc */\n  validateAddress(address: { address: string }): void {\n    if (!isValidKaspaAddress(address.address)) {\n      throw new Error(`Invalid Kaspa address: ${address.address}`);\n    }\n  }\n\n  /** @inheritDoc */\n  validateRawTransaction(rawTransaction: string): void {\n    try {\n      Transaction.fromHex((this as any)._coinConfig?.name || 'kaspa', rawTransaction);\n    } catch {\n      throw new Error('Invalid raw Kaspa transaction');\n    }\n  }\n\n  /** @inheritDoc */\n  validateValue(value: BigNumber): void {\n    if (value.isLessThan(0)) {\n      throw new Error('Transaction value cannot be negative');\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTransactionBuilder, BaseTransaction, BaseKey, SigningError } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport BigNumber from 'bignumber.js';\nimport { Transaction } from './transaction';\nimport { KaspaTransactionData, KaspaUtxoInput, KaspaTransactionOutput } from './iface';\nimport { isValidKaspaAddress, addressToScriptPublicKey } from './utils';\nimport { KeyPair } from './keyPair';\nimport { DEFAULT_FEE, TX_VERSION, SIGHASH_ALL } from './constants';\nimport { Pskt, PsktInput, PsktOutput } from './pskt';\n\nexport class TransactionBuilder extends BaseTransactionBuilder {\n  protected _transaction: Transaction;\n  protected _inputs: KaspaUtxoInput[] = [];\n  protected _outputs: KaspaTransactionOutput[] = [];\n  protected _fee: string = DEFAULT_FEE;\n  protected _fromAddress = '';\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._transaction = new Transaction(coinConfig.name);\n  }\n\n  /** @inheritDoc */\n  protected get transaction(): BaseTransaction {\n    return this._transaction;\n  }\n\n  /** @inheritDoc */\n  protected set transaction(tx: BaseTransaction) {\n    this._transaction = tx as Transaction;\n  }\n\n  /**\n   * Set the sender address.\n   */\n  sender(address: string): this {\n    if (!isValidKaspaAddress(address)) {\n      throw new Error(`Invalid Kaspa address: ${address}`);\n    }\n    this._fromAddress = address;\n    return this;\n  }\n\n  /**\n   * Add a recipient output.\n   */\n  to(address: string, amount: string): this {\n    if (!isValidKaspaAddress(address)) {\n      throw new Error(`Invalid Kaspa recipient address: ${address}`);\n    }\n    this._outputs.push({ address, amount, scriptPublicKey: addressToScriptPublicKey(address) });\n    return this;\n  }\n\n  /**\n   * Set transaction fee in sompi.\n   */\n  fee(fee: string): this {\n    this._fee = fee;\n    return this;\n  }\n\n  /**\n   * Add a UTXO input.\n   */\n  addInput(utxo: KaspaUtxoInput): this {\n    if (!utxo.transactionId || utxo.transactionIndex === undefined) {\n      throw new Error('Invalid UTXO: missing transactionId or transactionIndex');\n    }\n    this._inputs.push(utxo);\n    return this;\n  }\n\n  /**\n   * Add multiple UTXO inputs.\n   */\n  addInputs(utxos: KaspaUtxoInput[]): this {\n    utxos.forEach((u) => this.addInput(u));\n    return this;\n  }\n\n  /** @inheritDoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = Transaction.fromHex(this._coinConfig.name, rawTransaction);\n    this._transaction = tx;\n    this._inputs = tx.txData.inputs || [];\n    this._outputs = tx.txData.outputs || [];\n    this._fee = tx.txData.fee || DEFAULT_FEE;\n    return tx;\n  }\n\n  /** @inheritDoc */\n  protected async buildImplementation(): Promise<BaseTransaction> {\n    const txData: KaspaTransactionData = {\n      version: TX_VERSION,\n      inputs: this._inputs,\n      outputs: this._outputs,\n      fee: this._fee,\n      lockTime: '0',\n      subnetworkId: '0000000000000000000000000000000000000000',\n      payload: '',\n    };\n\n    this._transaction = new Transaction(this._coinConfig.name, txData);\n\n    return this._transaction;\n  }\n\n  /** @inheritDoc */\n  protected signImplementation({ key }: BaseKey): BaseTransaction {\n    const keyPair = new KeyPair({ prv: key });\n    const privateKey = keyPair.getKeys().prv;\n    if (!privateKey) {\n      throw new SigningError('Missing private key');\n    }\n    this._transaction.sign(Buffer.from(privateKey, 'hex'));\n    return this._transaction;\n  }\n\n  /** @inheritDoc */\n  validateTransaction(_transaction?: BaseTransaction): void {\n    if (this._inputs.length === 0) {\n      throw new Error('At least one UTXO input is required');\n    }\n    if (this._outputs.length === 0) {\n      throw new Error('At least one output is required');\n    }\n  }\n\n  /** @inheritDoc */\n  validateKey(key: { key: string }): void {\n    // Key validation handled in KeyPair\n  }\n\n  /** @inheritDoc */\n  validateAddress(address: { address: string }): void {\n    if (!isValidKaspaAddress(address.address)) {\n      throw new Error(`Invalid Kaspa address: ${address.address}`);\n    }\n  }\n\n  /** @inheritDoc */\n  validateRawTransaction(rawTransaction: string): void {\n    try {\n      Transaction.fromHex(this._coinConfig.name, rawTransaction);\n    } catch {\n      throw new Error('Invalid raw Kaspa transaction');\n    }\n  }\n\n  /** @inheritDoc */\n  validateValue(value: BigNumber): void {\n    if (value.isLessThan(0)) {\n      throw new Error('Transaction value cannot be negative');\n    }\n  }\n\n  /**\n   * Build the transaction and return it as an unsigned PSKT in UPDATER role.\n   *\n   * The PSKT has all inputs and outputs populated with UTXO data but no\n   * signatures. It is ready to be handed to a signer (HSM, hardware wallet,\n   * or MPCv2 session) via `pskt.toSigner().sign(key)` or\n   * `pskt.toSigner().addSignature(...)`.\n   *\n   * Example:\n   * ```ts\n   * const pskt = await builder.toPskt();\n   * const broadcastJson = pskt\n   *   .toSigner()\n   *   .sign(privateKey)\n   *   .toFinalizer()\n   *   .finalize()\n   *   .toExtractor()\n   *   .extract();\n   * ```\n   */\n  async toPskt(): Promise<Pskt> {\n    this.validateTransaction();\n\n    const psktInputs: PsktInput[] = this._inputs.map((inp) => ({\n      previousOutpoint: { transactionId: inp.transactionId, index: inp.transactionIndex },\n      utxoEntry: { amount: inp.amount, scriptPublicKey: inp.scriptPublicKey },\n      sequence: inp.sequence,\n      sigOpCount: inp.sigOpCount ?? 1,\n      partialSigs: {},\n      sighashType: SIGHASH_ALL,\n      bip32Derivations: {},\n      proprietaries: {},\n    }));\n\n    const psktOutputs: PsktOutput[] = this._outputs.map((out) => ({\n      amount: out.amount,\n      scriptPublicKey: { version: 0, scriptPublicKey: out.scriptPublicKey || addressToScriptPublicKey(out.address) },\n      bip32Derivations: {},\n      proprietaries: {},\n    }));\n\n    const pskt = Pskt.creator(TX_VERSION);\n    for (const inp of psktInputs) {\n      pskt.input(inp);\n    }\n    for (const out of psktOutputs) {\n      pskt.output(out);\n    }\n    return pskt.toUpdater();\n  }\n}\n"]}

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

@@ -1,15 +1,20 @@
+import { BaseTransactionBuilderFactory } from '@bitgo-beta/sdk-core';
 import { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
 import { TransactionBuilder } from './transactionBuilder';
-export declare class TransactionBuilderFactory {
-    protected _coinConfig: Readonly<StaticsBaseCoin>;
+export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     constructor(coinConfig: Readonly<StaticsBaseCoin>);
     /**
      * Get a base transaction builder for Kaspa transfers.
      */
     getBuilder(): TransactionBuilder;
+    /** @inheritdoc */
+    getTransferBuilder(): TransactionBuilder;
     /**
-     * Reconstruct a transaction builder from a raw transaction hex.
+     * Kaspa does not have a wallet initialization transaction.
+     * @throws NotImplementedError
      */
+    getWalletInitializationBuilder(): never;
+    /** @inheritdoc */
     from(rawTransaction: string): TransactionBuilder;
 }
 //# sourceMappingURL=transactionBuilderFactory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,qBAAa,yBAAyB;IACpC,SAAS,CAAC,WAAW,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;gBAErC,UAAU,EAAE,QAAQ,CAAC,eAAe,CAAC;IAIjD;;OAEG;IACH,UAAU,IAAI,kBAAkB;IAIhC;;OAEG;IACH,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,kBAAkB;CAKjD"}
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAuB,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,UAAU,EAAE,QAAQ,CAAC,eAAe,CAAC;IAIjD;;OAEG;IACH,UAAU,IAAI,kBAAkB;IAIhC,kBAAkB;IAClB,kBAAkB,IAAI,kBAAkB;IAIxC;;;OAGG;IACH,8BAA8B,IAAI,KAAK;IAIvC,kBAAkB;IAClB,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,kBAAkB;CAKjD"}

package/dist/src/lib/transactionBuilderFactory.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionBuilderFactory = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
 const transactionBuilder_1 = require("./transactionBuilder");
-class TransactionBuilderFactory {
+class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
     constructor(coinConfig) {
-        this._coinConfig = coinConfig;
+        super(coinConfig);
     }
     /**
      * Get a base transaction builder for Kaspa transfers.
@@ -12,9 +13,18 @@ class TransactionBuilderFactory {
     getBuilder() {
         return new transactionBuilder_1.TransactionBuilder(this._coinConfig);
     }
+    /** @inheritdoc */
+    getTransferBuilder() {
+        return this.getBuilder();
+    }
     /**
-     * Reconstruct a transaction builder from a raw transaction hex.
+     * Kaspa does not have a wallet initialization transaction.
+     * @throws NotImplementedError
      */
+    getWalletInitializationBuilder() {
+        throw new sdk_core_1.NotImplementedError('getWalletInitializationBuilder is not supported for Kaspa');
+    }
+    /** @inheritdoc */
     from(rawTransaction) {
         const builder = this.getBuilder();
         builder.from(rawTransaction);
@@ -22,4 +32,4 @@ class TransactionBuilderFactory {
     }
 }
 exports.TransactionBuilderFactory = TransactionBuilderFactory;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvdHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSw2REFBMEQ7QUFFMUQsTUFBYSx5QkFBeUI7SUFHcEMsWUFBWSxVQUFxQztRQUMvQyxJQUFJLENBQUMsV0FBVyxHQUFHLFVBQVUsQ0FBQztJQUNoQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxVQUFVO1FBQ1IsT0FBTyxJQUFJLHVDQUFrQixDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLENBQUMsY0FBc0I7UUFDekIsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBQ2xDLE9BQU8sQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDN0IsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztDQUNGO0FBdEJELDhEQXNCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VDb2luIGFzIFN0YXRpY3NCYXNlQ29pbiB9IGZyb20gJ0BiaXRnby1iZXRhL3N0YXRpY3MnO1xuaW1wb3J0IHsgVHJhbnNhY3Rpb25CdWlsZGVyIH0gZnJvbSAnLi90cmFuc2FjdGlvbkJ1aWxkZXInO1xuXG5leHBvcnQgY2xhc3MgVHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeSB7XG4gIHByb3RlY3RlZCBfY29pbkNvbmZpZzogUmVhZG9ubHk8U3RhdGljc0Jhc2VDb2luPjtcblxuICBjb25zdHJ1Y3Rvcihjb2luQ29uZmlnOiBSZWFkb25seTxTdGF0aWNzQmFzZUNvaW4+KSB7XG4gICAgdGhpcy5fY29pbkNvbmZpZyA9IGNvaW5Db25maWc7XG4gIH1cblxuICAvKipcbiAgICogR2V0IGEgYmFzZSB0cmFuc2FjdGlvbiBidWlsZGVyIGZvciBLYXNwYSB0cmFuc2ZlcnMuXG4gICAqL1xuICBnZXRCdWlsZGVyKCk6IFRyYW5zYWN0aW9uQnVpbGRlciB7XG4gICAgcmV0dXJuIG5ldyBUcmFuc2FjdGlvbkJ1aWxkZXIodGhpcy5fY29pbkNvbmZpZyk7XG4gIH1cblxuICAvKipcbiAgICogUmVjb25zdHJ1Y3QgYSB0cmFuc2FjdGlvbiBidWlsZGVyIGZyb20gYSByYXcgdHJhbnNhY3Rpb24gaGV4LlxuICAgKi9cbiAgZnJvbShyYXdUcmFuc2FjdGlvbjogc3RyaW5nKTogVHJhbnNhY3Rpb25CdWlsZGVyIHtcbiAgICBjb25zdCBidWlsZGVyID0gdGhpcy5nZXRCdWlsZGVyKCk7XG4gICAgYnVpbGRlci5mcm9tKHJhd1RyYW5zYWN0aW9uKTtcbiAgICByZXR1cm4gYnVpbGRlcjtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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