@bitgo-beta/sdk-coin-kaspa 0.0.1-beta.0

package/dist/src/lib/sighash.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCRIPT_PUBLIC_KEY_VERSION = exports.OP_CHECKSIG_SCHNORR = exports.SIGHASH_ANYONECANPAY = exports.SIGHASH_SINGLE = exports.SIGHASH_NONE = exports.SIGHASH_ALL = void 0;
+exports.buildP2PKScriptPublicKey = buildP2PKScriptPublicKey;
+exports.compressedToXOnly = compressedToXOnly;
+exports.computeKaspaSigningHash = computeKaspaSigningHash;
+/**
+ * Kaspa transaction sighash computation.
+ *
+ * BIP-143-like scheme using Blake2b-256. All integer fields are little-endian.
+ *
+ * Reference (authoritative implementation):
+ * https://github.com/kaspanet/rusty-kaspa/blob/master/consensus/core/src/hashing/sighash.rs
+ */
+const blakejs_1 = require("blakejs");
+// SigHash type flags
+exports.SIGHASH_ALL = 0x01;
+exports.SIGHASH_NONE = 0x02;
+exports.SIGHASH_SINGLE = 0x04;
+exports.SIGHASH_ANYONECANPAY = 0x80;
+// Script constants
+exports.OP_CHECKSIG_SCHNORR = 0xab; // Kaspa Schnorr checksig opcode
+exports.SCRIPT_PUBLIC_KEY_VERSION = 0; // Standard P2PK version
+function blake2b256(data) {
+    return Buffer.from((0, blakejs_1.blake2b)(data, undefined, 32));
+}
+/**
+ * Build P2PK Schnorr scriptPublicKey from a 32-byte x-only public key.
+ * Format: DATA_32(0x20) + xOnlyPubKey(32 bytes) + OP_CHECKSIG_SCHNORR(0xAB)
+ */
+function buildP2PKScriptPublicKey(xOnlyPubKey) {
+    if (xOnlyPubKey.length !== 32) {
+        throw new Error(`Expected 32-byte x-only pubkey, got ${xOnlyPubKey.length}`);
+    }
+    return Buffer.concat([Buffer.from([0x20]), xOnlyPubKey, Buffer.from([exports.OP_CHECKSIG_SCHNORR])]);
+}
+/**
+ * Derive x-only public key from 33-byte compressed public key.
+ */
+function compressedToXOnly(compressedPubKey) {
+    if (compressedPubKey.length !== 33) {
+        throw new Error(`Expected 33-byte compressed pubkey, got ${compressedPubKey.length}`);
+    }
+    return compressedPubKey.slice(1); // drop the 02/03 prefix byte
+}
+// --- Intermediate hash helpers ---
+function hashPreviousOutputs(inputs) {
+    const parts = inputs.map((inp) => {
+        const buf = Buffer.alloc(36);
+        Buffer.from(inp.transactionId, 'hex').copy(buf, 0);
+        buf.writeUInt32LE(inp.transactionIndex, 32);
+        return buf;
+    });
+    return blake2b256(Buffer.concat(parts));
+}
+function hashSequences(inputs) {
+    const buf = Buffer.alloc(inputs.length * 8);
+    inputs.forEach((inp, i) => {
+        buf.writeBigUInt64LE(BigInt(inp.sequence || '0'), i * 8);
+    });
+    return blake2b256(buf);
+}
+function hashSigOpCounts(inputs) {
+    const bytes = inputs.map((inp) => inp.sigOpCount ?? 1);
+    return blake2b256(Buffer.from(bytes));
+}
+function serializeOutput(output) {
+    const scriptBytes = Buffer.from(output.scriptPublicKey || '', 'hex');
+    const spkVersion = 0; // standard P2PK
+    // value (u64 LE, 8) + spk_version (u16 LE, 2) + script_length (u64 LE, 8) + script
+    const buf = Buffer.alloc(8 + 2 + 8 + scriptBytes.length);
+    let offset = 0;
+    buf.writeBigUInt64LE(BigInt(output.amount), offset);
+    offset += 8;
+    buf.writeUInt16LE(spkVersion, offset);
+    offset += 2;
+    buf.writeBigUInt64LE(BigInt(scriptBytes.length), offset);
+    offset += 8;
+    scriptBytes.copy(buf, offset);
+    return buf;
+}
+function hashOutputs(tx, inputIndex, sigHashType) {
+    const baseType = sigHashType & 0x1f;
+    if (baseType === exports.SIGHASH_NONE) {
+        return Buffer.alloc(32); // zero hash
+    }
+    if (baseType === exports.SIGHASH_SINGLE) {
+        if (inputIndex >= tx.outputs.length) {
+            return Buffer.alloc(32);
+        }
+        return blake2b256(serializeOutput(tx.outputs[inputIndex]));
+    }
+    // SIGHASH_ALL
+    const parts = tx.outputs.map(serializeOutput);
+    return blake2b256(Buffer.concat(parts));
+}
+function hashPayload(tx) {
+    const subnetId = Buffer.from(tx.subnetworkId || '0000000000000000000000000000000000000000', 'hex');
+    // If subnetwork is native (all zeros), payloadHash is zero
+    if (subnetId.every((b) => b === 0)) {
+        return Buffer.alloc(32);
+    }
+    return blake2b256(Buffer.from(tx.payload || '', 'hex'));
+}
+/**
+ * Compute the Kaspa sighash for a specific input.
+ *
+ * @param tx        Full transaction data
+ * @param inputIndex Index of the input being signed
+ * @param sigHashType SigHash type flags (use SIGHASH_ALL = 0x01 for standard)
+ */
+function computeKaspaSigningHash(tx, inputIndex, sigHashType = exports.SIGHASH_ALL) {
+    const anyoneCanPay = !!(sigHashType & exports.SIGHASH_ANYONECANPAY);
+    const baseType = sigHashType & 0x1f;
+    const input = tx.inputs[inputIndex];
+    if (!input) {
+        throw new Error(`Input index ${inputIndex} out of range`);
+    }
+    // Conditional intermediate hashes
+    const prevOutputsHash = anyoneCanPay ? Buffer.alloc(32) : hashPreviousOutputs(tx.inputs);
+    const seqHash = anyoneCanPay || baseType === exports.SIGHASH_SINGLE || baseType === exports.SIGHASH_NONE
+        ? Buffer.alloc(32)
+        : hashSequences(tx.inputs);
+    const sigOpHash = anyoneCanPay ? Buffer.alloc(32) : hashSigOpCounts(tx.inputs);
+    const outsHash = hashOutputs(tx, inputIndex, sigHashType);
+    const payloadHash = hashPayload(tx);
+    // Parse the current input's script public key
+    const scriptBytes = Buffer.from(input.scriptPublicKey || '', 'hex');
+    const spkVersion = 0; // standard P2PK
+    const subnetId = Buffer.from(tx.subnetworkId || '0000000000000000000000000000000000000000', 'hex');
+    // Build the preimage
+    const fixedSize = 2 + 32 + 32 + 32 + 32 + 4 + 2 + 8 + 8 + 8 + 1 + 32 + 8 + 20 + 8 + 32 + 1;
+    const preimage = Buffer.alloc(fixedSize + scriptBytes.length);
+    let offset = 0;
+    // 1. version
+    preimage.writeUInt16LE(tx.version ?? 0, offset);
+    offset += 2;
+    // 2. previousOutputsHash
+    prevOutputsHash.copy(preimage, offset);
+    offset += 32;
+    // 3. sequencesHash
+    seqHash.copy(preimage, offset);
+    offset += 32;
+    // 4. sigOpCountsHash
+    sigOpHash.copy(preimage, offset);
+    offset += 32;
+    // 5. current input's previous outpoint txId
+    Buffer.from(input.transactionId, 'hex').copy(preimage, offset);
+    offset += 32;
+    // 6. current input's previous outpoint index
+    preimage.writeUInt32LE(input.transactionIndex, offset);
+    offset += 4;
+    // 7. scriptPublicKey version
+    preimage.writeUInt16LE(spkVersion, offset);
+    offset += 2;
+    // 8. scriptPublicKey length (u64 LE)
+    preimage.writeBigUInt64LE(BigInt(scriptBytes.length), offset);
+    offset += 8;
+    // 9. scriptPublicKey bytes
+    scriptBytes.copy(preimage, offset);
+    offset += scriptBytes.length;
+    // 10. value (amount in sompi, u64 LE)
+    preimage.writeBigUInt64LE(BigInt(input.amount), offset);
+    offset += 8;
+    // 11. sequence (u64 LE)
+    preimage.writeBigUInt64LE(BigInt(input.sequence || '0'), offset);
+    offset += 8;
+    // 12. sigOpCount (u8)
+    preimage.writeUInt8(input.sigOpCount ?? 1, offset);
+    offset += 1;
+    // 13. outputsHash
+    outsHash.copy(preimage, offset);
+    offset += 32;
+    // 14. locktime (u64 LE)
+    preimage.writeBigUInt64LE(BigInt(tx.lockTime || '0'), offset);
+    offset += 8;
+    // 15. subnetworkId (20 bytes)
+    subnetId.copy(preimage, offset);
+    offset += 20;
+    // 16. gas (u64 LE) — always 0 for native KASPA
+    preimage.writeBigUInt64LE(0n, offset);
+    offset += 8;
+    // 17. payloadHash
+    payloadHash.copy(preimage, offset);
+    offset += 32;
+    // 18. sigHashType (u8)
+    preimage.writeUInt8(sigHashType, offset);
+    offset += 1;
+    return blake2b256(preimage.slice(0, offset));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sighash.js","sourceRoot":"","sources":["../../../src/lib/sighash.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Kaspa transaction sighash computation.\n *\n * BIP-143-like scheme using Blake2b-256. All integer fields are little-endian.\n *\n * Reference (authoritative implementation):\n * https://github.com/kaspanet/rusty-kaspa/blob/master/consensus/core/src/hashing/sighash.rs\n */\nimport { blake2b } from 'blakejs';\nimport { KaspaTransactionData, KaspaUtxoInput, KaspaTransactionOutput } from './iface';\n\n// SigHash type flags\nexport const SIGHASH_ALL = 0x01;\nexport const SIGHASH_NONE = 0x02;\nexport const SIGHASH_SINGLE = 0x04;\nexport const SIGHASH_ANYONECANPAY = 0x80;\n\n// Script constants\nexport const OP_CHECKSIG_SCHNORR = 0xab; // Kaspa Schnorr checksig opcode\nexport const SCRIPT_PUBLIC_KEY_VERSION = 0; // Standard P2PK version\n\nfunction blake2b256(data: Buffer): Buffer {\n  return Buffer.from(blake2b(data, undefined, 32));\n}\n\n/**\n * Build P2PK Schnorr scriptPublicKey from a 32-byte x-only public key.\n * Format: DATA_32(0x20) + xOnlyPubKey(32 bytes) + OP_CHECKSIG_SCHNORR(0xAB)\n */\nexport function buildP2PKScriptPublicKey(xOnlyPubKey: Buffer): Buffer {\n  if (xOnlyPubKey.length !== 32) {\n    throw new Error(`Expected 32-byte x-only pubkey, got ${xOnlyPubKey.length}`);\n  }\n  return Buffer.concat([Buffer.from([0x20]), xOnlyPubKey, Buffer.from([OP_CHECKSIG_SCHNORR])]);\n}\n\n/**\n * Derive x-only public key from 33-byte compressed public key.\n */\nexport function compressedToXOnly(compressedPubKey: Buffer): Buffer {\n  if (compressedPubKey.length !== 33) {\n    throw new Error(`Expected 33-byte compressed pubkey, got ${compressedPubKey.length}`);\n  }\n  return compressedPubKey.slice(1); // drop the 02/03 prefix byte\n}\n\n// --- Intermediate hash helpers ---\n\nfunction hashPreviousOutputs(inputs: KaspaUtxoInput[]): Buffer {\n  const parts = inputs.map((inp) => {\n    const buf = Buffer.alloc(36);\n    Buffer.from(inp.transactionId, 'hex').copy(buf, 0);\n    buf.writeUInt32LE(inp.transactionIndex, 32);\n    return buf;\n  });\n  return blake2b256(Buffer.concat(parts));\n}\n\nfunction hashSequences(inputs: KaspaUtxoInput[]): Buffer {\n  const buf = Buffer.alloc(inputs.length * 8);\n  inputs.forEach((inp, i) => {\n    buf.writeBigUInt64LE(BigInt(inp.sequence || '0'), i * 8);\n  });\n  return blake2b256(buf);\n}\n\nfunction hashSigOpCounts(inputs: KaspaUtxoInput[]): Buffer {\n  const bytes = inputs.map((inp) => inp.sigOpCount ?? 1);\n  return blake2b256(Buffer.from(bytes));\n}\n\nfunction serializeOutput(output: KaspaTransactionOutput): Buffer {\n  const scriptBytes = Buffer.from(output.scriptPublicKey || '', 'hex');\n  const spkVersion = 0; // standard P2PK\n  // value (u64 LE, 8) + spk_version (u16 LE, 2) + script_length (u64 LE, 8) + script\n  const buf = Buffer.alloc(8 + 2 + 8 + scriptBytes.length);\n  let offset = 0;\n  buf.writeBigUInt64LE(BigInt(output.amount), offset);\n  offset += 8;\n  buf.writeUInt16LE(spkVersion, offset);\n  offset += 2;\n  buf.writeBigUInt64LE(BigInt(scriptBytes.length), offset);\n  offset += 8;\n  scriptBytes.copy(buf, offset);\n  return buf;\n}\n\nfunction hashOutputs(tx: KaspaTransactionData, inputIndex: number, sigHashType: number): Buffer {\n  const baseType = sigHashType & 0x1f;\n  if (baseType === SIGHASH_NONE) {\n    return Buffer.alloc(32); // zero hash\n  }\n  if (baseType === SIGHASH_SINGLE) {\n    if (inputIndex >= tx.outputs.length) {\n      return Buffer.alloc(32);\n    }\n    return blake2b256(serializeOutput(tx.outputs[inputIndex]));\n  }\n  // SIGHASH_ALL\n  const parts = tx.outputs.map(serializeOutput);\n  return blake2b256(Buffer.concat(parts));\n}\n\nfunction hashPayload(tx: KaspaTransactionData): Buffer {\n  const subnetId = Buffer.from(tx.subnetworkId || '0000000000000000000000000000000000000000', 'hex');\n  // If subnetwork is native (all zeros), payloadHash is zero\n  if (subnetId.every((b) => b === 0)) {\n    return Buffer.alloc(32);\n  }\n  return blake2b256(Buffer.from(tx.payload || '', 'hex'));\n}\n\n/**\n * Compute the Kaspa sighash for a specific input.\n *\n * @param tx        Full transaction data\n * @param inputIndex Index of the input being signed\n * @param sigHashType SigHash type flags (use SIGHASH_ALL = 0x01 for standard)\n */\nexport function computeKaspaSigningHash(\n  tx: KaspaTransactionData,\n  inputIndex: number,\n  sigHashType: number = SIGHASH_ALL\n): Buffer {\n  const anyoneCanPay = !!(sigHashType & SIGHASH_ANYONECANPAY);\n  const baseType = sigHashType & 0x1f;\n\n  const input = tx.inputs[inputIndex];\n  if (!input) {\n    throw new Error(`Input index ${inputIndex} out of range`);\n  }\n\n  // Conditional intermediate hashes\n  const prevOutputsHash = anyoneCanPay ? Buffer.alloc(32) : hashPreviousOutputs(tx.inputs);\n  const seqHash =\n    anyoneCanPay || baseType === SIGHASH_SINGLE || baseType === SIGHASH_NONE\n      ? Buffer.alloc(32)\n      : hashSequences(tx.inputs);\n  const sigOpHash = anyoneCanPay ? Buffer.alloc(32) : hashSigOpCounts(tx.inputs);\n  const outsHash = hashOutputs(tx, inputIndex, sigHashType);\n  const payloadHash = hashPayload(tx);\n\n  // Parse the current input's script public key\n  const scriptBytes = Buffer.from(input.scriptPublicKey || '', 'hex');\n  const spkVersion = 0; // standard P2PK\n  const subnetId = Buffer.from(tx.subnetworkId || '0000000000000000000000000000000000000000', 'hex');\n\n  // Build the preimage\n  const fixedSize = 2 + 32 + 32 + 32 + 32 + 4 + 2 + 8 + 8 + 8 + 1 + 32 + 8 + 20 + 8 + 32 + 1;\n  const preimage = Buffer.alloc(fixedSize + scriptBytes.length);\n  let offset = 0;\n\n  // 1. version\n  preimage.writeUInt16LE(tx.version ?? 0, offset);\n  offset += 2;\n\n  // 2. previousOutputsHash\n  prevOutputsHash.copy(preimage, offset);\n  offset += 32;\n\n  // 3. sequencesHash\n  seqHash.copy(preimage, offset);\n  offset += 32;\n\n  // 4. sigOpCountsHash\n  sigOpHash.copy(preimage, offset);\n  offset += 32;\n\n  // 5. current input's previous outpoint txId\n  Buffer.from(input.transactionId, 'hex').copy(preimage, offset);\n  offset += 32;\n\n  // 6. current input's previous outpoint index\n  preimage.writeUInt32LE(input.transactionIndex, offset);\n  offset += 4;\n\n  // 7. scriptPublicKey version\n  preimage.writeUInt16LE(spkVersion, offset);\n  offset += 2;\n\n  // 8. scriptPublicKey length (u64 LE)\n  preimage.writeBigUInt64LE(BigInt(scriptBytes.length), offset);\n  offset += 8;\n\n  // 9. scriptPublicKey bytes\n  scriptBytes.copy(preimage, offset);\n  offset += scriptBytes.length;\n\n  // 10. value (amount in sompi, u64 LE)\n  preimage.writeBigUInt64LE(BigInt(input.amount), offset);\n  offset += 8;\n\n  // 11. sequence (u64 LE)\n  preimage.writeBigUInt64LE(BigInt(input.sequence || '0'), offset);\n  offset += 8;\n\n  // 12. sigOpCount (u8)\n  preimage.writeUInt8(input.sigOpCount ?? 1, offset);\n  offset += 1;\n\n  // 13. outputsHash\n  outsHash.copy(preimage, offset);\n  offset += 32;\n\n  // 14. locktime (u64 LE)\n  preimage.writeBigUInt64LE(BigInt(tx.lockTime || '0'), offset);\n  offset += 8;\n\n  // 15. subnetworkId (20 bytes)\n  subnetId.copy(preimage, offset);\n  offset += 20;\n\n  // 16. gas (u64 LE) — always 0 for native KASPA\n  preimage.writeBigUInt64LE(0n, offset);\n  offset += 8;\n\n  // 17. payloadHash\n  payloadHash.copy(preimage, offset);\n  offset += 32;\n\n  // 18. sigHashType (u8)\n  preimage.writeUInt8(sigHashType, offset);\n  offset += 1;\n\n  return blake2b256(preimage.slice(0, offset));\n}\n"]}

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

@@ -0,0 +1,53 @@
+import { BaseKey, BaseTransaction } from '@bitgo-beta/sdk-core';
+import { KaspaTransactionData, TransactionExplanation } from './iface';
+export declare class Transaction extends BaseTransaction {
+    protected _txData: KaspaTransactionData;
+    constructor(coin: string, txData?: KaspaTransactionData);
+    /** @inheritDoc */
+    get id(): string;
+    get txData(): KaspaTransactionData;
+    /**
+     * Sign all inputs with the given private key using Schnorr signatures.
+     *
+     * @param privateKey 32-byte private key buffer
+     * @param sigHashType SigHash type (default: SIGHASH_ALL = 0x01)
+     */
+    sign(privateKey: Buffer, sigHashType?: number): void;
+    /**
+     * Verify that a Schnorr signature on a specific input is valid.
+     *
+     * @param publicKey 33-byte compressed public key (or 32-byte x-only)
+     * @param inputIndex Index of the input to verify
+     * @param sigHashType SigHash type used when signing
+     */
+    verifySignature(publicKey: Buffer, inputIndex: number, sigHashType?: number): boolean;
+    /**
+     * Explain the transaction in a human-readable format.
+     */
+    explainTransaction(): TransactionExplanation;
+    /**
+     * Serialize the transaction to a JSON string (broadcast format).
+     */
+    toBroadcastFormat(): string;
+    /**
+     * Serialize transaction to hex (JSON-encoded then hex-encoded).
+     */
+    toHex(): string;
+    /**
+     * Return transaction data as a plain object.
+     */
+    toJson(): KaspaTransactionData;
+    /**
+     * Deserialize from hex.
+     */
+    static fromHex(coin: string, hex: string): Transaction;
+    /**
+     * Deserialize from JSON string or object.
+     */
+    static fromJson(coin: string, data: string | KaspaTransactionData): Transaction;
+    /** @inheritDoc */
+    get signature(): string[];
+    /** @inheritDoc */
+    canSign(_key: BaseKey): boolean;
+}
+//# sourceMappingURL=transaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,eAAe,EAAmB,MAAM,sBAAsB,CAAC;AAEjF,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAGvE,qBAAa,WAAY,SAAQ,eAAe;IAC9C,SAAS,CAAC,OAAO,EAAE,oBAAoB,CAAC;gBAE5B,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,oBAAoB;IASvD,kBAAkB;IAClB,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,IAAI,MAAM,IAAI,oBAAoB,CAEjC;IAED;;;;;OAKG;IACH,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,GAAE,MAAoB,GAAG,IAAI;IAajE;;;;;;OAMG;IACH,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAE,MAAoB,GAAG,OAAO;IAgBlG;;OAEG;IACH,kBAAkB,IAAI,sBAAsB;IA8B5C;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAI3B;;OAEG;IACH,KAAK,IAAI,MAAM;IAIf;;OAEG;IACH,MAAM,IAAI,oBAAoB;IAI9B;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW;IAKtD;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,WAAW;IAK/E,kBAAkB;IAClB,IAAI,SAAS,IAAI,MAAM,EAAE,CAExB;IAED,kBAAkB;IAClB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;CAGhC"}

package/dist/src/lib/transaction.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+class Transaction extends sdk_core_1.BaseTransaction {
+    constructor(coin, txData) {
+        super({ coin });
+        this._txData = txData || {
+            version: 0,
+            inputs: [],
+            outputs: [],
+        };
+    }
+    /** @inheritDoc */
+    get id() {
+        return this._txData.id || '';
+    }
+    get txData() {
+        return this._txData;
+    }
+    /**
+     * Sign all inputs with the given private key using Schnorr signatures.
+     *
+     * @param privateKey 32-byte private key buffer
+     * @param sigHashType SigHash type (default: SIGHASH_ALL = 0x01)
+     */
+    sign(privateKey, sigHashType = sighash_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])]);
+            this._txData.inputs[i].signatureScript = sigWithType.toString('hex');
+        }
+    }
+    /**
+     * Verify that a Schnorr signature on a specific input is valid.
+     *
+     * @param publicKey 33-byte compressed public key (or 32-byte x-only)
+     * @param inputIndex Index of the input to verify
+     * @param sigHashType SigHash type used when signing
+     */
+    verifySignature(publicKey, inputIndex, sigHashType = sighash_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) {
+            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);
+    }
+    /**
+     * Explain the transaction in a human-readable format.
+     */
+    explainTransaction() {
+        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);
+        }
+        const fee = (totalIn - totalOut).toString();
+        const outputs = this._txData.outputs.map((o) => ({
+            address: o.address,
+            amount: o.amount,
+        }));
+        return {
+            id: this._txData.id || '',
+            type: sdk_core_1.TransactionType.Send,
+            outputs,
+            outputAmount: totalOut.toString(),
+            changeOutputs: [],
+            changeAmount: '0',
+            fee: { fee: this._txData.fee || fee },
+            inputs: this._txData.inputs,
+        };
+    }
+    /**
+     * Serialize the transaction to a JSON string (broadcast format).
+     */
+    toBroadcastFormat() {
+        return JSON.stringify(this._txData);
+    }
+    /**
+     * Serialize transaction to hex (JSON-encoded then hex-encoded).
+     */
+    toHex() {
+        return Buffer.from(this.toBroadcastFormat()).toString('hex');
+    }
+    /**
+     * Return transaction data as a plain object.
+     */
+    toJson() {
+        return { ...this._txData };
+    }
+    /**
+     * Deserialize from hex.
+     */
+    static fromHex(coin, hex) {
+        const json = JSON.parse(Buffer.from(hex, 'hex').toString());
+        return new Transaction(coin, json);
+    }
+    /**
+     * Deserialize from JSON string or object.
+     */
+    static fromJson(coin, data) {
+        const txData = typeof data === 'string' ? JSON.parse(data) : data;
+        return new Transaction(coin, txData);
+    }
+    /** @inheritDoc */
+    get signature() {
+        return this._txData.inputs.map((i) => i.signatureScript || '');
+    }
+    /** @inheritDoc */
+    canSign(_key) {
+        return true;
+    }
+}
+exports.Transaction = Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":";;;AAAA,mDAAiF;AACjF,qDAA4C;AAE5C,uCAAiE;AAEjE,MAAa,WAAY,SAAQ,0BAAe;IAG9C,YAAY,IAAY,EAAE,MAA6B;QACrD,KAAK,CAAC,EAAE,IAAI,EAAS,CAAC,CAAC;QACvB,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI;YACvB,OAAO,EAAE,CAAC;YACV,MAAM,EAAE,EAAE;YACV,OAAO,EAAE,EAAE;SACZ,CAAC;IACJ,CAAC;IAED,kBAAkB;IAClB,IAAI,EAAE;QACJ,OAAO,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC;IAC/B,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACH,IAAI,CAAC,UAAkB,EAAE,cAAsB,qBAAW;QACxD,IAAI,UAAU,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,qCAAqC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;QAC5E,CAAC;QACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACpD,MAAM,OAAO,GAAG,IAAA,iCAAuB,EAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC;YACtE,MAAM,GAAG,GAAG,eAAG,CAAC,WAAW,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;YACjD,+DAA+D;YAC/D,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;YAClF,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,eAAe,GAAG,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACvE,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,eAAe,CAAC,SAAiB,EAAE,UAAkB,EAAE,cAAsB,qBAAW;QACtF,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAC9C,IAAI,CAAC,KAAK,EAAE,eAAe,EAAE,CAAC;YAC5B,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;QAC3D,IAAI,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;YACzB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAClC,MAAM,OAAO,GAAG,IAAA,iCAAuB,EAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC;QAC/E,8CAA8C;QAC9C,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC1E,OAAO,eAAG,CAAC,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,kBAAkB;QAChB,IAAI,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAEzB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACxC,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAClC,CAAC;QACD,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAC1C,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACpC,CAAC;QAED,MAAM,GAAG,GAAG,CAAC,OAAO,GAAG,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC;QAE5C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC/C,OAAO,EAAE,CAAC,CAAC,OAAO;YAClB,MAAM,EAAE,CAAC,CAAC,MAAM;SACjB,CAAC,CAAC,CAAC;QAEJ,OAAO;YACL,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE;YACzB,IAAI,EAAE,0BAAe,CAAC,IAAI;YAC1B,OAAO;YACP,YAAY,EAAE,QAAQ,CAAC,QAAQ,EAAE;YACjC,aAAa,EAAE,EAAE;YACjB,YAAY,EAAE,GAAG;YACjB,GAAG,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,EAAE;YACrC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM;SAC5B,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,iBAAiB;QACf,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,KAAK;QACH,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,IAAY,EAAE,GAAW;QACtC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC5D,OAAO,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAY,EAAE,IAAmC;QAC/D,MAAM,MAAM,GAAyB,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACxF,OAAO,IAAI,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACvC,CAAC;IAED,kBAAkB;IAClB,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC;IACjE,CAAC;IAED,kBAAkB;IAClB,OAAO,CAAC,IAAa;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AA9ID,kCA8IC","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"]}

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

@@ -0,0 +1,58 @@
+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';
+export declare class TransactionBuilder extends BaseTransactionBuilder {
+    protected _transaction: Transaction;
+    protected _inputs: KaspaUtxoInput[];
+    protected _outputs: KaspaTransactionOutput[];
+    protected _fee: string;
+    protected _fromAddress: string;
+    constructor(coinConfig: Readonly<CoinConfig>);
+    /** @inheritDoc */
+    protected get transaction(): BaseTransaction;
+    /** @inheritDoc */
+    protected set transaction(tx: BaseTransaction);
+    /**
+     * Set the sender address.
+     */
+    sender(address: string): this;
+    /**
+     * Add a recipient output.
+     */
+    to(address: string, amount: string): this;
+    /**
+     * Set transaction fee in sompi.
+     */
+    fee(fee: string): this;
+    /**
+     * Add a UTXO input.
+     */
+    addInput(utxo: KaspaUtxoInput): this;
+    /**
+     * Add multiple UTXO inputs.
+     */
+    addInputs(utxos: KaspaUtxoInput[]): this;
+    /** @inheritDoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /** @inheritDoc */
+    protected buildImplementation(): Promise<BaseTransaction>;
+    /** @inheritDoc */
+    protected signImplementation({ key }: BaseKey): BaseTransaction;
+    /** @inheritDoc */
+    validateTransaction(_transaction?: BaseTransaction): void;
+    /** @inheritDoc */
+    validateKey(key: {
+        key: string;
+    }): void;
+    /** @inheritDoc */
+    validateAddress(address: {
+        address: string;
+    }): void;
+    /** @inheritDoc */
+    validateRawTransaction(rawTransaction: string): void;
+    /** @inheritDoc */
+    validateValue(value: BigNumber): void;
+}
+//# sourceMappingURL=transactionBuilder.d.ts.map

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

@@ -0,0 +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"}