@bitgo-beta/sdk-coin-kaspa 0.0.1-beta.8 → 0.0.1-beta.80

package/README.md

@@ -17,7 +17,7 @@ Supported coin identifiers:
 - Address derivation (kaspa bech32 P2PK Schnorr)
 - UTXO transaction building
 - Schnorr signing and verification (Blake2b-256 sighash)
-- TSS/MPC support (ECDSA algorithm)
+- TSS/MPC support (ECDSA algorithm, per-input DKLS sessions)
 - Full serialization round-trip (hex/JSON)
 
 ## Installation
@@ -28,82 +28,273 @@ yarn add @bitgo/sdk-coin-kaspa
 
 ## Usage
 
-### Register with BitGo SDK
+### 1. Register with BitGo SDK
 
 ```typescript
+import { BitGo } from 'bitgo';
 import { register } from '@bitgo/sdk-coin-kaspa';
+
+const bitgo = new BitGo({ env: 'prod' });
 register(bitgo);
+
+const kaspa = bitgo.coin('kaspa');
+const tkaspa = bitgo.coin('tkaspa'); // testnet
+```
+
+Alternatively, instantiate directly (useful in tests or scripts):
+
+```typescript
+import { Kaspa, Tkaspa } from '@bitgo/sdk-coin-kaspa';
+
+const kaspa = Kaspa.createInstance(bitgo);
+const tkaspa = Tkaspa.createInstance(bitgo);
+```
+
+---
+
+### 2. Key Generation
+
+```typescript
+// Random key pair
+const kp = kaspa.generateKeyPair();
+console.log(kp.pub); // 66-char hex compressed secp256k1 public key
+console.log(kp.prv); // 64-char hex private key
+
+// Deterministic from a 32-byte seed
+const seed = Buffer.from('...32 bytes...', 'hex');
+const kpFromSeed = kaspa.generateKeyPair(seed);
+
+// Validation
+kaspa.isValidPub(kp.pub); // true
+kaspa.isValidPrv(kp.prv); // true
+```
+
+Using `KeyPair` directly:
+
+```typescript
+import { KeyPair } from '@bitgo/sdk-coin-kaspa';
+
+const keyPair = new KeyPair(); // random
+const { pub, prv } = keyPair.getKeys();
 ```
 
-### Key Pair
+---
+
+### 3. Address Generation
 
 ```typescript
 import { KeyPair } from '@bitgo/sdk-coin-kaspa';
 
-// Generate a random key pair
-const kp = new KeyPair();
-const { pub, prv } = kp.getKeys();
+const keyPair = new KeyPair({ prv: '<64-char-hex-private-key>' });
+
+const mainnetAddress = keyPair.getAddress('mainnet'); // kaspa:qq...
+const testnetAddress = keyPair.getAddress('testnet'); // kaspatest:qq...
+
+kaspa.isValidAddress(mainnetAddress); // true
+```
+
+Computing the P2PK `scriptPublicKey` for a key (required when constructing UTXO inputs):
 
-// Derive address
-const mainnetAddress = kp.getAddress('mainnet');
-const testnetAddress = kp.getAddress('testnet');
+```typescript
+import { compressedToXOnly, buildP2PKScriptPublicKey } from '@bitgo/sdk-coin-kaspa';
+
+const xOnlyPub = compressedToXOnly(Buffer.from(pub, 'hex'));
+const scriptPublicKey = buildP2PKScriptPublicKey(xOnlyPub).toString('hex');
 ```
 
-### Build and Sign a Transaction
+---
+
+### 4. Building a Transaction
 
 ```typescript
-import { TransactionBuilderFactory } from '@bitgo/sdk-coin-kaspa';
+import { TransactionBuilderFactory, Transaction } from '@bitgo/sdk-coin-kaspa';
 import { coins } from '@bitgo/statics';
+import type { KaspaUtxoInput } from '@bitgo/sdk-coin-kaspa';
+
+const utxo: KaspaUtxoInput = {
+  transactionId: '<64-char-hex-prev-tx-id>',
+  transactionIndex: 0,
+  amount: '100000000',      // 1 KASPA in sompi (1e8)
+  scriptPublicKey: '<hex>', // P2PK script of the sender's key
+  sequence: '0',
+  sigOpCount: 1,
+};
 
 const factory = new TransactionBuilderFactory(coins.get('kaspa'));
 const builder = factory.getBuilder();
 
 builder
-  .addInput({
-    transactionId: '<prev-tx-id>',
-    transactionIndex: 0,
-    amount: '100000000', // 1 KASPA in sompi
-    scriptPublicKey: '<spk>',
-    sequence: '0',
-    sigOpCount: 1,
-  })
-  .to('<recipient-kaspa-address>', '99998000')
+  .addInput(utxo)
+  .to('kaspa:qq...recipient...', '99998000') // amount in sompi
   .fee('2000');
 
-const tx = await builder.build();
+const tx = (await builder.build()) as Transaction;
+```
+
+Multiple inputs:
+
+```typescript
+builder
+  .addInput(utxo1)
+  .addInput(utxo2)
+  .to(recipientAddress, '299996000')
+  .fee('4000');
+```
+
+---
+
+### 5. Signing — Path A: Direct Private Key (non-TSS)
+
+```typescript
+// `tx.sign` takes a 32-byte Buffer (raw private key)
 tx.sign(Buffer.from(privateKeyHex, 'hex'));
 
-const broadcastPayload = tx.toBroadcastFormat(); // JSON string for RPC
+// Signs every input at once. Fully signed → txHex; partial → halfSigned
+const signedTxHex = tx.toHex(); // SDK-internal format for round-trips
+
+// Or via the coin interface:
+const result = await kaspa.signTransaction({
+  txPrebuild: { txHex: unsignedTxHex },
+  prv: privateKeyHex,
+} as any) as { txHex: string };
 ```
 
+---
+
+### 6. Signing — Path B: TSS / MPC (per-input DKLS sessions)
+
+Kaspa is UTXO-based: every input has its own sighash (Blake2b-256, BIP-143-like).
+Each input **requires an independent DKLS session** — there is no way to produce N valid
+Schnorr signatures from a single signing operation.
+
+```typescript
+const unsignedTx = (await builder.build()) as Transaction;
+const txHex = unsignedTx.toHex();
+
+// Step 1: one sighash Buffer per input — the messages for each DKLS session
+const sighashes: Buffer[] = unsignedTx.signablePayloads; // Buffer[N]
+
+// Step 2: run N DKLS sessions in parallel (one per sighash)
+// Each session produces a 64-byte raw Schnorr signature
+
+// Step 3: collect results and call signTransaction
+const signatures = sighashes.map((hash, inputIndex) => ({
+  inputIndex,
+  pubKey: compressedPubKeyHex,          // 33-byte hex
+  signature: dklsSession(hash),         // 64-byte hex Schnorr sig
+}));
+
+const result = await kaspa.signTransaction({
+  txPrebuild: { txHex },
+  signatures,
+} as any) as { txHex: string } | { halfSigned: { txHex: string } };
+
+// result.txHex      → all inputs signed
+// result.halfSigned → some inputs still unsigned (partial TSS round)
+```
+
+---
+
+### 7. Broadcasting
+
+```typescript
+// toBroadcastFormat() returns the Kaspa RPC-compatible JSON string
+const broadcastPayload = tx.toBroadcastFormat();
+
+// toHex() is the SDK-internal round-trip format (preserves amount + scriptPublicKey
+// on inputs for sighash recomputation). Do NOT send this to the Kaspa node directly.
+const internalHex = tx.toHex();
+```
+
+---
+
+### 8. Explaining / Parsing a Transaction
+
+```typescript
+// Human-readable breakdown
+const explained = await kaspa.explainTransaction({ txHex });
+console.log(explained.outputs);      // [{ address, amount }]
+console.log(explained.outputAmount); // total sent (sompi)
+console.log(explained.fee);          // fee (sompi)
+
+// Structured parse — inputs and outputs tagged with coin name
+const parsed = await kaspa.parseTransaction({ txHex } as any);
+// { inputs: [{ amount, coin: 'kaspa' }], outputs: [{ address, amount, coin: 'kaspa' }] }
+```
+
+---
+
+### 9. Verifying a Transaction
+
+```typescript
+const valid = await kaspa.verifyTransaction({
+  txPrebuild: { txHex },
+  txParams: {
+    recipients: [{ address: 'kaspa:qq...', amount: '99998000' }],
+  },
+} as any);
+
+console.log(valid); // true
+```
+
+---
+
+### 10. Coin Properties
+
+```typescript
+kaspa.getChain();        // 'kaspa'
+kaspa.getFamily();       // 'kaspa'
+kaspa.getFullName();     // 'Kaspa'
+kaspa.getBaseFactor();   // 100_000_000  (sompi per KASPA)
+kaspa.supportsTss();     // true
+kaspa.getMPCAlgorithm(); // 'ecdsa'
+
+tkaspa.getChain();       // 'tkaspa'
+tkaspa.getFullName();    // 'Testnet Kaspa'
+```
+
+---
+
+## Key Constants
+
+| Property | Value |
+|---|---|
+| 1 KASPA | `100_000_000` sompi |
+| `getBaseFactor()` | `1e8` |
+| Mainnet address prefix | `kaspa:` |
+| Testnet address prefix | `kaspatest:` |
+| Address type | P2PK Schnorr (x-only secp256k1) |
+| Signature algorithm | Schnorr (Blake2b-256 sighash) |
+| TSS algorithm | `ecdsa` (DKLS) |
+| Multisig type | `onchain` |
+
+---
+
 ## Module Structure
 
 ```
 src/
-├── kaspa.ts                    # Kaspa mainnet coin class
-├── tkaspa.ts                   # Kaspa testnet coin class
-├── register.ts                 # SDK registration
+├── kaspa.ts                    # AbstractKaspaLikeCoin, Kaspa, Tkaspa classes
+├── register.ts                 # SDK registration helper
 ├── index.ts
 └── lib/
-    ├── constants.ts            # Chain constants (prefixes, decimals, fees)
+    ├── constants.ts            # Chain constants (prefixes, decimals, default fee)
     ├── iface.ts                # TypeScript interfaces
-    ├── keyPair.ts              # secp256k1 key pair
-    ├── sighash.ts              # Blake2b-256 Schnorr sighash
-    ├── transaction.ts          # Transaction class (sign/verify/explain)
+    ├── keyPair.ts              # secp256k1 key pair + address derivation
+    ├── sighash.ts              # Blake2b-256 Schnorr sighash + script utilities
+    ├── transaction.ts          # Transaction class (sign / verify / explain / serialize)
     ├── transactionBuilder.ts   # UTXO transaction builder
     ├── transactionBuilderFactory.ts
     ├── utils.ts                # Address validation and encoding
     └── index.ts
 test/
 ├── fixtures/
-│   ├── kaspa.fixtures.ts       # Deterministic test vectors
-│   └── kaspaFixtures.ts        # Synthetic test fixtures
+│   └── kaspa.fixtures.ts       # Deterministic test vectors
 └── unit/
     ├── coin.test.ts
     ├── keyPair.test.ts
     ├── transaction.test.ts
     ├── transactionBuilder.test.ts
-    ├── transactionFlow.test.ts
     └── utils.test.ts
 ```
 
@@ -117,7 +308,7 @@ Kaspa uses a custom cashaddr-like bech32 encoding:
 
 ## Signing
 
-Kaspa uses **Schnorr signatures over secp256k1** with a **Blake2b-256** sighash. The sighash preimage follows the Kaspa BIP-143-like specification. Each input is signed independently, producing a 65-byte signature: 64 bytes Schnorr + 1 byte sighash type.
+Kaspa uses **Schnorr signatures over secp256k1** with a **Blake2b-256** sighash. The sighash preimage follows the Kaspa BIP-143-like specification. Each input is signed independently, producing a 65-byte signature: 64 bytes Schnorr + 1 byte sighash type (`0x01` = SIGHASH_ALL).
 
 ## References
 

package/dist/src/kaspa.d.ts

@@ -1,18 +1,35 @@
-import { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo-beta/statics';
-import { AuditDecryptedKeyParams, BaseCoin, BitGoBase, KeyPair as IKeyPair, MPCAlgorithm, MultisigType, ParsedTransaction, ParseTransactionOptions, SignedTransaction, VerifyAddressOptions } from '@bitgo-beta/sdk-core';
-import { KaspaExplainTransactionOptions, KaspaSignTransactionOptions, KaspaVerifyTransactionOptions, TransactionExplanation } from './lib/iface';
-export declare class Kaspa extends BaseCoin {
-    protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
-    constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
-    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
-    getChain(): string;
-    getFamily(): CoinFamily;
-    getFullName(): string;
+import { AuditDecryptedKeyParams, BitGoBase, IWallet, KeyPair as IKeyPair, MPCAlgorithm, MultisigType, SignedTransaction, VerifyAddressOptions } from '@bitgo-beta/sdk-core';
+import { AbstractUtxoCoin, ExplainTransactionOptions, ParseTransactionOptions, SignTransactionOptions, TransactionPrebuild, UtxoCoinName, UtxoCoinNameMainnet, transaction } from '@bitgo-beta/abstract-utxo';
+import { KaspaVerifyTransactionOptions } from './lib/iface';
+export declare abstract class AbstractKaspaLikeCoin extends AbstractUtxoCoin {
+    /**
+     * Kaspa has no utxo-lib network entry. This deprecated getter is overridden
+     * to prevent accidental usage of the Bitcoin PSBT signing stack.
+     */
+    get network(): never;
+    /**
+     * Kaspa family name is 'kaspa' for both mainnet and testnet.
+     * Override avoids going through names.ts which only knows Bitcoin-family coins.
+     * The cast is required because UtxoCoinNameMainnet is a closed union of Bitcoin-family coins;
+     * Kaspa manages its own network stack and is intentionally outside that union.
+     */
+    getFamily(): UtxoCoinNameMainnet;
+    /**
+     * Human-readable name for this coin variant.
+     * Implemented in each concrete class to avoid runtime name comparisons.
+     */
+    abstract getFullName(): string;
+    /**
+     * Whether this is a mainnet or testnet coin.
+     * Implemented in each concrete class to avoid runtime name comparisons.
+     */
+    protected abstract isMainnet(): boolean;
+    supportsBlockTarget(): boolean;
     /**
      * Return the base factor (sompi per KASPA).
      * 1 KASPA = 100,000,000 sompi (8 decimal places)
      */
-    getBaseFactor(): string | number;
+    getBaseFactor(): number;
     /** @inheritDoc */
     getDefaultMultisigType(): MultisigType;
     /**
@@ -30,7 +47,10 @@ export declare class Kaspa extends BaseCoin {
     /**
      * Generate a Kaspa key pair.
      */
-    generateKeyPair(seed?: Buffer): IKeyPair;
+    generateKeyPair(seed?: Buffer): {
+        pub: string;
+        prv: string;
+    };
     /**
      * Check if address belongs to wallet by deriving from keychains.
      */
@@ -38,27 +58,75 @@ export declare class Kaspa extends BaseCoin {
     private getBuilder;
     /**
      * Parse a Kaspa transaction from prebuild.
+     * Overrides AbstractUtxoCoin's PSBT-based implementation with Kaspa's JSON-hex format.
      */
-    parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction>;
+    parseTransaction<TNumber extends number | bigint = number>(params: ParseTransactionOptions<TNumber>): Promise<transaction.ParsedTransaction<TNumber>>;
     /**
      * Verify a Kaspa transaction against expected params.
      */
     verifyTransaction(params: KaspaVerifyTransactionOptions): Promise<boolean>;
     /**
      * Explain a Kaspa transaction.
+     * Overrides AbstractUtxoCoin's PSBT-based implementation with Kaspa's JSON-hex format.
+     * The return type cast is necessary because Kaspa uses a custom TransactionExplanation
+     * that doesn't include Bitcoin-specific fields (chain, index) on outputs.
      */
-    explainTransaction(params: KaspaExplainTransactionOptions): Promise<TransactionExplanation>;
+    explainTransaction<TNumber extends number | bigint = number>(params: ExplainTransactionOptions<TNumber>, _wallet?: IWallet): Promise<Awaited<ReturnType<AbstractUtxoCoin['explainTransaction']>>>;
     /**
      * Sign a Kaspa transaction using secp256k1 Schnorr signatures.
+     *
+     * Kaspa is a UTXO coin: every input has its own sighash.
+     * Two signing paths are supported:
+     *
+     * Path A — `params.prv` (direct key, test / non-TSS):
+     *   Calls `tx.sign(prv)` which loops every input and produces a Schnorr
+     *   signature for each one in a single call.
+     *
+     * Path B — `params.signatures` (TSS multi-input):
+     *   The caller already ran one independent DKLS session per input, using
+     *   `tx.signablePayloads[i]` as the message for session i.  Each resulting
+     *   signature is applied to its input via `addSignatureForInput`.
+     *
+     *   Platform flow:
+     *     1. Build tx, read `(tx as Transaction).signablePayloads` → Buffer[N]
+     *     2. Run N DKLS sessions in parallel, one per sighash
+     *     3. Call signTransaction({ signatures: [{ inputIndex, pubKey, signature }, ...] })
+     */
+    signTransaction<TNumber extends number | bigint = number>(params: SignTransactionOptions<TNumber>): Promise<SignedTransaction>;
+    /**
+     * Kaspa's txHex is already the custom JSON-hex format — skip the PSBT
+     * re-encode that AbstractUtxoCoin.postProcessPrebuild would otherwise apply.
      */
-    signTransaction(params: KaspaSignTransactionOptions): Promise<SignedTransaction>;
-    signMessage(key: IKeyPair, message: string | Buffer): Promise<Buffer>;
+    postProcessPrebuild<TNumber extends number | bigint>(prebuild: TransactionPrebuild<TNumber>): Promise<TransactionPrebuild<TNumber>>;
+    signMessage(_key: IKeyPair, _message: string | Buffer): Promise<Buffer>;
     /** @inheritDoc */
-    auditDecryptedKey(params: AuditDecryptedKeyParams): void;
+    auditDecryptedKey(_params: AuditDecryptedKeyParams): void;
     /**
-     * MPC support: Kaspa uses secp256k1 (Schnorr variant).
+     * TSS/MPC support: Kaspa uses secp256k1 (Schnorr variant for on-chain,
+     * ECDSA for the off-chain TSS ceremony).
+     *
+     * Kaspa is a UTXO coin with a BIP-143-like per-input sighash scheme.
+     * Each input commits to its own index and produces a distinct hash.
+     * One independent DKLS signing session is required per input.
+     *
+     * Correct multi-input TSS flow:
+     *   1. Read `tx.signablePayloads` → Buffer[] (one sighash per input).
+     *   2. Run one DKLS signing session per sighash IN PARALLEL.
+     *   3. Apply each signature: `tx.addSignatureForInput(i, pubKey, sig)`.
      */
     supportsTss(): boolean;
     getMPCAlgorithm(): MPCAlgorithm;
 }
+export declare class Kaspa extends AbstractKaspaLikeCoin {
+    readonly name: UtxoCoinName;
+    getFullName(): string;
+    protected isMainnet(): boolean;
+    static createInstance(bitgo: BitGoBase): Kaspa;
+}
+export declare class Tkaspa extends AbstractKaspaLikeCoin {
+    readonly name: UtxoCoinName;
+    getFullName(): string;
+    protected isMainnet(): boolean;
+    static createInstance(bitgo: BitGoBase): Tkaspa;
+}
 //# sourceMappingURL=kaspa.d.ts.map

package/dist/src/kaspa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kaspa.d.ts","sourceRoot":"","sources":["../../src/kaspa.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,UAAU,EAAS,MAAM,qBAAqB,CAAC;AACrF,OAAO,EACL,uBAAuB,EACvB,QAAQ,EACR,SAAS,EAGT,OAAO,IAAI,QAAQ,EAEnB,YAAY,EACZ,YAAY,EAEZ,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,EAEjB,oBAAoB,EACrB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,EAC3B,6BAA6B,EAC7B,sBAAsB,EACvB,MAAM,aAAa,CAAC;AAGrB,qBAAa,KAAM,SAAQ,QAAQ;IACjC,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;gBAE/C,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAUrE,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,QAAQ,IAAI,MAAM;IAIlB,SAAS,IAAI,UAAU;IAIvB,WAAW,IAAI,MAAM;IAIrB;;;OAGG;IACH,aAAa,IAAI,MAAM,GAAG,MAAM;IAIhC,kBAAkB;IAClB,sBAAsB,IAAI,YAAY;IAItC;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC;;OAEG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAShC;;OAEG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAShC;;OAEG;IACH,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,QAAQ;IAcxC;;OAEG;IACG,eAAe,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBrE,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACG,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA4BnF;;OAEG;IACG,iBAAiB,CAAC,MAAM,EAAE,6BAA6B,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BhF;;OAEG;IACG,kBAAkB,CAAC,MAAM,EAAE,8BAA8B,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAcjG;;OAEG;IACG,eAAe,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAsBhF,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI3E,kBAAkB;IAClB,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI;IAIxD;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB,eAAe,IAAI,YAAY;CAGhC"}
+{"version":3,"file":"kaspa.d.ts","sourceRoot":"","sources":["../../src/kaspa.ts"],"names":[],"mappings":"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"}