@bitgo-beta/sdk-coin-kaspa 0.0.1-alpha.10 → 0.0.1-alpha.11

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, per-input DKLS sessions)
+- TSS/MPC support (ECDSA algorithm)
 - Full serialization round-trip (hex/JSON)
 
 ## Installation
@@ -28,273 +28,82 @@ yarn add @bitgo/sdk-coin-kaspa
 
 ## Usage
 
-### 1. Register with BitGo SDK
+### 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();
 ```
 
----
-
-### 3. Address Generation
+### Key Pair
 
 ```typescript
 import { KeyPair } from '@bitgo/sdk-coin-kaspa';
 
-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):
+// Generate a random key pair
+const kp = new KeyPair();
+const { pub, prv } = kp.getKeys();
 
-```typescript
-import { compressedToXOnly, buildP2PKScriptPublicKey } from '@bitgo/sdk-coin-kaspa';
-
-const xOnlyPub = compressedToXOnly(Buffer.from(pub, 'hex'));
-const scriptPublicKey = buildP2PKScriptPublicKey(xOnlyPub).toString('hex');
+// Derive address
+const mainnetAddress = kp.getAddress('mainnet');
+const testnetAddress = kp.getAddress('testnet');
 ```
 
----
-
-### 4. Building a Transaction
+### Build and Sign a Transaction
 
 ```typescript
-import { TransactionBuilderFactory, Transaction } from '@bitgo/sdk-coin-kaspa';
+import { TransactionBuilderFactory } 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(utxo)
-  .to('kaspa:qq...recipient...', '99998000') // amount in sompi
+  .addInput({
+    transactionId: '<prev-tx-id>',
+    transactionIndex: 0,
+    amount: '100000000', // 1 KASPA in sompi
+    scriptPublicKey: '<spk>',
+    sequence: '0',
+    sigOpCount: 1,
+  })
+  .to('<recipient-kaspa-address>', '99998000')
   .fee('2000');
 
-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)
+const tx = await builder.build();
 tx.sign(Buffer.from(privateKeyHex, 'hex'));
 
-// 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 };
+const broadcastPayload = tx.toBroadcastFormat(); // JSON string for RPC
 ```
 
----
-
-### 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                    # AbstractKaspaLikeCoin, Kaspa, Tkaspa classes
-├── register.ts                 # SDK registration helper
+├── kaspa.ts                    # Kaspa mainnet coin class
+├── tkaspa.ts                   # Kaspa testnet coin class
+├── register.ts                 # SDK registration
 ├── index.ts
 └── lib/
-    ├── constants.ts            # Chain constants (prefixes, decimals, default fee)
+    ├── constants.ts            # Chain constants (prefixes, decimals, fees)
     ├── iface.ts                # TypeScript interfaces
-    ├── keyPair.ts              # secp256k1 key pair + address derivation
-    ├── sighash.ts              # Blake2b-256 Schnorr sighash + script utilities
-    ├── transaction.ts          # Transaction class (sign / verify / explain / serialize)
+    ├── keyPair.ts              # secp256k1 key pair
+    ├── sighash.ts              # Blake2b-256 Schnorr sighash
+    ├── transaction.ts          # Transaction class (sign/verify/explain)
     ├── transactionBuilder.ts   # UTXO transaction builder
     ├── transactionBuilderFactory.ts
     ├── utils.ts                # Address validation and encoding
     └── index.ts
 test/
 ├── fixtures/
-│   └── kaspa.fixtures.ts       # Deterministic test vectors
+│   ├── kaspa.fixtures.ts       # Deterministic test vectors
+│   └── kaspaFixtures.ts        # Synthetic test fixtures
 └── unit/
     ├── coin.test.ts
     ├── keyPair.test.ts
     ├── transaction.test.ts
     ├── transactionBuilder.test.ts
+    ├── transactionFlow.test.ts
     └── utils.test.ts
 ```
 
@@ -308,7 +117,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 (`0x01` = SIGHASH_ALL).
+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.
 
 ## References
 

package/dist/src/kaspa.d.ts

@@ -1,35 +1,18 @@
-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;
+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;
     /**
      * Return the base factor (sompi per KASPA).
      * 1 KASPA = 100,000,000 sompi (8 decimal places)
      */
-    getBaseFactor(): number;
+    getBaseFactor(): string | number;
     /** @inheritDoc */
     getDefaultMultisigType(): MultisigType;
     /**
@@ -47,10 +30,7 @@ export declare abstract class AbstractKaspaLikeCoin extends AbstractUtxoCoin {
     /**
      * Generate a Kaspa key pair.
      */
-    generateKeyPair(seed?: Buffer): {
-        pub: string;
-        prv: string;
-    };
+    generateKeyPair(seed?: Buffer): IKeyPair;
     /**
      * Check if address belongs to wallet by deriving from keychains.
      */
@@ -58,75 +38,27 @@ export declare abstract class AbstractKaspaLikeCoin extends AbstractUtxoCoin {
     private getBuilder;
     /**
      * Parse a Kaspa transaction from prebuild.
-     * Overrides AbstractUtxoCoin's PSBT-based implementation with Kaspa's JSON-hex format.
      */
-    parseTransaction<TNumber extends number | bigint = number>(params: ParseTransactionOptions<TNumber>): Promise<transaction.ParsedTransaction<TNumber>>;
+    parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction>;
     /**
      * 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<TNumber extends number | bigint = number>(params: ExplainTransactionOptions<TNumber>, _wallet?: IWallet): Promise<Awaited<ReturnType<AbstractUtxoCoin['explainTransaction']>>>;
+    explainTransaction(params: KaspaExplainTransactionOptions): Promise<TransactionExplanation>;
     /**
      * 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.
      */
-    postProcessPrebuild<TNumber extends number | bigint>(prebuild: TransactionPrebuild<TNumber>): Promise<TransactionPrebuild<TNumber>>;
-    signMessage(_key: IKeyPair, _message: string | Buffer): Promise<Buffer>;
+    signTransaction(params: KaspaSignTransactionOptions): Promise<SignedTransaction>;
+    signMessage(key: IKeyPair, message: string | Buffer): Promise<Buffer>;
     /** @inheritDoc */
-    auditDecryptedKey(_params: AuditDecryptedKeyParams): void;
+    auditDecryptedKey(params: AuditDecryptedKeyParams): void;
     /**
-     * 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)`.
+     * MPC support: Kaspa uses secp256k1 (Schnorr variant).
      */
     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":"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"}
+{"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"}