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

package/dist/src/lib/transactionBuilder.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transaction_1 = require("./transaction");
+const utils_1 = require("./utils");
+const keyPair_1 = require("./keyPair");
+const constants_1 = require("./constants");
+class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._inputs = [];
+        this._outputs = [];
+        this._fee = constants_1.DEFAULT_FEE;
+        this._fromAddress = '';
+        this._transaction = new transaction_1.Transaction(coinConfig.name);
+    }
+    /** @inheritDoc */
+    get transaction() {
+        return this._transaction;
+    }
+    /** @inheritDoc */
+    set transaction(tx) {
+        this._transaction = tx;
+    }
+    /**
+     * Set the sender address.
+     */
+    sender(address) {
+        if (!(0, utils_1.isValidKaspaAddress)(address)) {
+            throw new Error(`Invalid Kaspa address: ${address}`);
+        }
+        this._fromAddress = address;
+        return this;
+    }
+    /**
+     * Add a recipient output.
+     */
+    to(address, amount) {
+        if (!(0, utils_1.isValidKaspaAddress)(address)) {
+            throw new Error(`Invalid Kaspa recipient address: ${address}`);
+        }
+        this._outputs.push({ address, amount });
+        return this;
+    }
+    /**
+     * Set transaction fee in sompi.
+     */
+    fee(fee) {
+        this._fee = fee;
+        return this;
+    }
+    /**
+     * Add a UTXO input.
+     */
+    addInput(utxo) {
+        if (!utxo.transactionId || utxo.transactionIndex === undefined) {
+            throw new Error('Invalid UTXO: missing transactionId or transactionIndex');
+        }
+        this._inputs.push(utxo);
+        return this;
+    }
+    /**
+     * Add multiple UTXO inputs.
+     */
+    addInputs(utxos) {
+        utxos.forEach((u) => this.addInput(u));
+        return this;
+    }
+    /** @inheritDoc */
+    fromImplementation(rawTransaction) {
+        const tx = transaction_1.Transaction.fromHex(this._coinConfig?.name || 'kaspa', rawTransaction);
+        this._transaction = tx;
+        this._inputs = tx.txData.inputs || [];
+        this._outputs = tx.txData.outputs || [];
+        this._fee = tx.txData.fee || constants_1.DEFAULT_FEE;
+        return tx;
+    }
+    /** @inheritDoc */
+    async buildImplementation() {
+        const txData = {
+            version: constants_1.TX_VERSION,
+            inputs: this._inputs,
+            outputs: this._outputs,
+            fee: this._fee,
+            lockTime: '0',
+            subnetworkId: '0000000000000000000000000000000000000000',
+            payload: '',
+        };
+        this._transaction = new transaction_1.Transaction(this._coinConfig?.name || 'kaspa', txData);
+        return this._transaction;
+    }
+    /** @inheritDoc */
+    signImplementation({ key }) {
+        const keyPair = new keyPair_1.KeyPair({ prv: key });
+        const privateKey = keyPair.getKeys().prv;
+        if (!privateKey) {
+            throw new sdk_core_1.SigningError('Missing private key');
+        }
+        this._transaction.sign(Buffer.from(privateKey, 'hex'));
+        return this._transaction;
+    }
+    /** @inheritDoc */
+    validateTransaction(_transaction) {
+        if (this._inputs.length === 0) {
+            throw new Error('At least one UTXO input is required');
+        }
+        if (this._outputs.length === 0) {
+            throw new Error('At least one output is required');
+        }
+    }
+    /** @inheritDoc */
+    validateKey(key) {
+        // Key validation handled in KeyPair
+    }
+    /** @inheritDoc */
+    validateAddress(address) {
+        if (!(0, utils_1.isValidKaspaAddress)(address.address)) {
+            throw new Error(`Invalid Kaspa address: ${address.address}`);
+        }
+    }
+    /** @inheritDoc */
+    validateRawTransaction(rawTransaction) {
+        try {
+            transaction_1.Transaction.fromHex(this._coinConfig?.name || 'kaspa', rawTransaction);
+        }
+        catch {
+            throw new Error('Invalid raw Kaspa transaction');
+        }
+    }
+    /** @inheritDoc */
+    validateValue(value) {
+        if (value.isLessThan(0)) {
+            throw new Error('Transaction value cannot be negative');
+        }
+    }
+}
+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"]}

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

@@ -0,0 +1,15 @@
+import { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
+import { TransactionBuilder } from './transactionBuilder';
+export declare class TransactionBuilderFactory {
+    protected _coinConfig: Readonly<StaticsBaseCoin>;
+    constructor(coinConfig: Readonly<StaticsBaseCoin>);
+    /**
+     * Get a base transaction builder for Kaspa transfers.
+     */
+    getBuilder(): TransactionBuilder;
+    /**
+     * Reconstruct a transaction builder from a raw transaction hex.
+     */
+    from(rawTransaction: string): TransactionBuilder;
+}
+//# sourceMappingURL=transactionBuilderFactory.d.ts.map

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

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

package/dist/src/lib/transactionBuilderFactory.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilderFactory = void 0;
+const transactionBuilder_1 = require("./transactionBuilder");
+class TransactionBuilderFactory {
+    constructor(coinConfig) {
+        this._coinConfig = coinConfig;
+    }
+    /**
+     * Get a base transaction builder for Kaspa transfers.
+     */
+    getBuilder() {
+        return new transactionBuilder_1.TransactionBuilder(this._coinConfig);
+    }
+    /**
+     * Reconstruct a transaction builder from a raw transaction hex.
+     */
+    from(rawTransaction) {
+        const builder = this.getBuilder();
+        builder.from(rawTransaction);
+        return builder;
+    }
+}
+exports.TransactionBuilderFactory = TransactionBuilderFactory;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvdHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSw2REFBMEQ7QUFFMUQsTUFBYSx5QkFBeUI7SUFHcEMsWUFBWSxVQUFxQztRQUMvQyxJQUFJLENBQUMsV0FBVyxHQUFHLFVBQVUsQ0FBQztJQUNoQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxVQUFVO1FBQ1IsT0FBTyxJQUFJLHVDQUFrQixDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLENBQUMsY0FBc0I7UUFDekIsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBQ2xDLE9BQU8sQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDN0IsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztDQUNGO0FBdEJELDhEQXNCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VDb2luIGFzIFN0YXRpY3NCYXNlQ29pbiB9IGZyb20gJ0BiaXRnby1iZXRhL3N0YXRpY3MnO1xuaW1wb3J0IHsgVHJhbnNhY3Rpb25CdWlsZGVyIH0gZnJvbSAnLi90cmFuc2FjdGlvbkJ1aWxkZXInO1xuXG5leHBvcnQgY2xhc3MgVHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeSB7XG4gIHByb3RlY3RlZCBfY29pbkNvbmZpZzogUmVhZG9ubHk8U3RhdGljc0Jhc2VDb2luPjtcblxuICBjb25zdHJ1Y3Rvcihjb2luQ29uZmlnOiBSZWFkb25seTxTdGF0aWNzQmFzZUNvaW4+KSB7XG4gICAgdGhpcy5fY29pbkNvbmZpZyA9IGNvaW5Db25maWc7XG4gIH1cblxuICAvKipcbiAgICogR2V0IGEgYmFzZSB0cmFuc2FjdGlvbiBidWlsZGVyIGZvciBLYXNwYSB0cmFuc2ZlcnMuXG4gICAqL1xuICBnZXRCdWlsZGVyKCk6IFRyYW5zYWN0aW9uQnVpbGRlciB7XG4gICAgcmV0dXJuIG5ldyBUcmFuc2FjdGlvbkJ1aWxkZXIodGhpcy5fY29pbkNvbmZpZyk7XG4gIH1cblxuICAvKipcbiAgICogUmVjb25zdHJ1Y3QgYSB0cmFuc2FjdGlvbiBidWlsZGVyIGZyb20gYSByYXcgdHJhbnNhY3Rpb24gaGV4LlxuICAgKi9cbiAgZnJvbShyYXdUcmFuc2FjdGlvbjogc3RyaW5nKTogVHJhbnNhY3Rpb25CdWlsZGVyIHtcbiAgICBjb25zdCBidWlsZGVyID0gdGhpcy5nZXRCdWlsZGVyKCk7XG4gICAgYnVpbGRlci5mcm9tKHJhd1RyYW5zYWN0aW9uKTtcbiAgICByZXR1cm4gYnVpbGRlcjtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,43 @@
+import { BaseUtils } from '@bitgo-beta/sdk-core';
+/**
+ * Validates a Kaspa address (mainnet or testnet)
+ */
+export declare function isValidKaspaAddress(address: string): boolean;
+/**
+ * Validates a Kaspa mainnet address
+ */
+export declare function isValidMainnetAddress(address: string): boolean;
+/**
+ * Validates a Kaspa testnet address
+ */
+export declare function isValidTestnetAddress(address: string): boolean;
+/**
+ * Derive a Kaspa P2PK (Schnorr) address from a compressed secp256k1 public key.
+ *
+ * @param compressedPubKey - 33-byte compressed secp256k1 public key (hex string or Buffer)
+ * @param hrp - human-readable part ('kaspa' or 'kaspatest')
+ */
+export declare function pubKeyToKaspaAddress(compressedPubKey: string | Buffer, hrp: string): string;
+/**
+ * Validates a secp256k1 public key (compressed or uncompressed)
+ */
+export declare function isValidPublicKey(pub: string): boolean;
+/**
+ * Validates a secp256k1 private key (32-byte hex)
+ */
+export declare function isValidPrivateKey(prv: string): boolean;
+/**
+ * Validates a transaction ID (64-char hex)
+ */
+export declare function isValidTransactionId(txId: string): boolean;
+export declare class Utils implements BaseUtils {
+    isValidAddress(address: string): boolean;
+    isValidBlockId(hash: string): boolean;
+    isValidPrivateKey(key: string): boolean;
+    isValidPublicKey(key: string): boolean;
+    isValidSignature(signature: string): boolean;
+    isValidTransactionId(txId: string): boolean;
+}
+declare const utils: Utils;
+export default utils;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAA4B,MAAM,sBAAsB,CAAC;AAmH3E;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAqB5D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAoB3F;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAgBrD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAatD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,qBAAa,KAAM,YAAW,SAAS;IACrC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAItC,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI5C,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAG5C;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAC1B,eAAe,KAAK,CAAC"}

package/dist/src/lib/utils.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+exports.isValidKaspaAddress = isValidKaspaAddress;
+exports.isValidMainnetAddress = isValidMainnetAddress;
+exports.isValidTestnetAddress = isValidTestnetAddress;
+exports.pubKeyToKaspaAddress = pubKeyToKaspaAddress;
+exports.isValidPublicKey = isValidPublicKey;
+exports.isValidPrivateKey = isValidPrivateKey;
+exports.isValidTransactionId = isValidTransactionId;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const constants_1 = require("./constants");
+// Kaspa address encoding uses a bech32-like scheme with ':' as separator
+// and a custom checksum polynomial (same as Bitcoin Cash cashaddr).
+const CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+const CHARSET_REVERSE = {};
+for (let i = 0; i < CHARSET.length; i++) {
+    CHARSET_REVERSE[CHARSET[i]] = i;
+}
+const GENERATOR = [
+    BigInt('0x98f2bc8e61'),
+    BigInt('0x79b76d99e2'),
+    BigInt('0xf33e5fb3c4'),
+    BigInt('0xae2eabe2a8'),
+    BigInt('0x1e4f43e470'),
+];
+function polymod(values) {
+    let c = 1n;
+    for (const d of values) {
+        const c0 = c >> 35n;
+        c = ((c & BigInt('0x07ffffffff')) << 5n) ^ BigInt(d);
+        for (let i = 0; i < 5; i++) {
+            if ((c0 >> BigInt(i)) & 1n) {
+                c ^= GENERATOR[i];
+            }
+        }
+    }
+    return c ^ 1n;
+}
+function prefixExpand(prefix) {
+    return [...prefix].map((c) => c.charCodeAt(0) & 0x1f).concat([0]);
+}
+function createChecksum(prefix, data) {
+    const values = prefixExpand(prefix).concat(data).concat([0, 0, 0, 0, 0, 0, 0, 0]);
+    const mod = polymod(values);
+    const ret = [];
+    for (let i = 7; i >= 0; i--) {
+        ret.push(Number((mod >> BigInt(5 * i)) & 31n));
+    }
+    return ret;
+}
+function verifyChecksum(prefix, data) {
+    const values = prefixExpand(prefix).concat(data);
+    return polymod(values) === 0n;
+}
+function convertBits(data, from, to, pad) {
+    let acc = 0;
+    let bits = 0;
+    const ret = [];
+    const maxv = (1 << to) - 1;
+    for (const value of data) {
+        acc = (acc << from) | value;
+        bits += from;
+        while (bits >= to) {
+            bits -= to;
+            ret.push((acc >> bits) & maxv);
+        }
+    }
+    if (pad && bits > 0) {
+        ret.push((acc << (to - bits)) & maxv);
+    }
+    return ret;
+}
+/**
+ * Encode data into a Kaspa bech32-like address.
+ */
+function kaspaEncode(prefix, data) {
+    const checksum = createChecksum(prefix, data);
+    return (prefix +
+        ':' +
+        data
+            .concat(checksum)
+            .map((d) => CHARSET[d])
+            .join(''));
+}
+/**
+ * Decode a Kaspa bech32-like address.
+ * Returns { prefix, data } or throws on error.
+ */
+function kaspacDecode(address) {
+    const colonIdx = address.lastIndexOf(':');
+    if (colonIdx < 1) {
+        throw new Error('Missing prefix separator');
+    }
+    const prefix = address.slice(0, colonIdx).toLowerCase();
+    const encoded = address.slice(colonIdx + 1).toLowerCase();
+    const data = [];
+    for (const c of encoded) {
+        const val = CHARSET_REVERSE[c];
+        if (val === undefined) {
+            throw new Error(`Invalid character: ${c}`);
+        }
+        data.push(val);
+    }
+    if (!verifyChecksum(prefix, data)) {
+        throw new Error('Invalid checksum');
+    }
+    return { prefix, data: data.slice(0, -8) };
+}
+/**
+ * Validates a Kaspa address (mainnet or testnet)
+ */
+function isValidKaspaAddress(address) {
+    if (!address || typeof address !== 'string') {
+        return false;
+    }
+    const colonIdx = address.lastIndexOf(':');
+    if (colonIdx < 1) {
+        return false;
+    }
+    const prefix = address.slice(0, colonIdx).toLowerCase();
+    if (prefix !== constants_1.MAINNET_PREFIX && prefix !== constants_1.TESTNET_PREFIX) {
+        return false;
+    }
+    try {
+        const decoded = kaspacDecode(address);
+        return decoded.data.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validates a Kaspa mainnet address
+ */
+function isValidMainnetAddress(address) {
+    return isValidKaspaAddress(address) && address.toLowerCase().startsWith(constants_1.MAINNET_PREFIX + ':');
+}
+/**
+ * Validates a Kaspa testnet address
+ */
+function isValidTestnetAddress(address) {
+    return isValidKaspaAddress(address) && address.toLowerCase().startsWith(constants_1.TESTNET_PREFIX + ':');
+}
+/**
+ * Derive a Kaspa P2PK (Schnorr) address from a compressed secp256k1 public key.
+ *
+ * @param compressedPubKey - 33-byte compressed secp256k1 public key (hex string or Buffer)
+ * @param hrp - human-readable part ('kaspa' or 'kaspatest')
+ */
+function pubKeyToKaspaAddress(compressedPubKey, hrp) {
+    const pubKeyBytes = Buffer.isBuffer(compressedPubKey)
+        ? compressedPubKey
+        : Buffer.from(compressedPubKey, 'hex');
+    if (pubKeyBytes.length !== 33) {
+        throw new Error(`Expected 33-byte compressed public key, got ${pubKeyBytes.length}`);
+    }
+    // X-only public key: drop the prefix byte (02 or 03), keep 32-byte x-coordinate
+    const xOnlyPubKey = pubKeyBytes.slice(1);
+    // Kaspa P2PK address:
+    // - version nibble: 0 (Schnorr secp256k1 P2PK)
+    // - payload: x-only public key (32 bytes)
+    const versionByte = 0;
+    const payload = Buffer.concat([Buffer.from([versionByte]), xOnlyPubKey]);
+    const words = convertBits(payload, 8, 5, true);
+    return kaspaEncode(hrp, words);
+}
+/**
+ * Validates a secp256k1 public key (compressed or uncompressed)
+ */
+function isValidPublicKey(pub) {
+    if (!pub || typeof pub !== 'string') {
+        return false;
+    }
+    try {
+        const buf = Buffer.from(pub, 'hex');
+        if (buf.length === 33) {
+            return buf[0] === 0x02 || buf[0] === 0x03;
+        }
+        if (buf.length === 65) {
+            return buf[0] === 0x04;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validates a secp256k1 private key (32-byte hex)
+ */
+function isValidPrivateKey(prv) {
+    if (!prv || typeof prv !== 'string') {
+        return false;
+    }
+    if ((0, sdk_core_1.isValidXprv)(prv) || (0, sdk_core_1.isValidXpub)(prv)) {
+        return true;
+    }
+    try {
+        const buf = Buffer.from(prv.slice(0, 64), 'hex');
+        return buf.length === 32;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validates a transaction ID (64-char hex)
+ */
+function isValidTransactionId(txId) {
+    return /^[0-9a-fA-F]{64}$/.test(txId);
+}
+class Utils {
+    isValidAddress(address) {
+        return isValidKaspaAddress(address);
+    }
+    isValidBlockId(hash) {
+        return /^[0-9a-fA-F]{64}$/.test(hash);
+    }
+    isValidPrivateKey(key) {
+        return isValidPrivateKey(key);
+    }
+    isValidPublicKey(key) {
+        return isValidPublicKey(key);
+    }
+    isValidSignature(signature) {
+        return /^[0-9a-fA-F]{128,130}$/.test(signature);
+    }
+    isValidTransactionId(txId) {
+        return isValidTransactionId(txId);
+    }
+}
+exports.Utils = Utils;
+const utils = new Utils();
+exports.default = utils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseUtils, isValidXprv, isValidXpub } from '@bitgo-beta/sdk-core';\nimport { MAINNET_PREFIX, TESTNET_PREFIX } from './constants';\n\n// Kaspa address encoding uses a bech32-like scheme with ':' as separator\n// and a custom checksum polynomial (same as Bitcoin Cash cashaddr).\n\nconst CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';\nconst CHARSET_REVERSE: Record<string, number> = {};\nfor (let i = 0; i < CHARSET.length; i++) {\n  CHARSET_REVERSE[CHARSET[i]] = i;\n}\n\nconst GENERATOR = [\n  BigInt('0x98f2bc8e61'),\n  BigInt('0x79b76d99e2'),\n  BigInt('0xf33e5fb3c4'),\n  BigInt('0xae2eabe2a8'),\n  BigInt('0x1e4f43e470'),\n];\n\nfunction polymod(values: number[]): bigint {\n  let c = 1n;\n  for (const d of values) {\n    const c0 = c >> 35n;\n    c = ((c & BigInt('0x07ffffffff')) << 5n) ^ BigInt(d);\n    for (let i = 0; i < 5; i++) {\n      if ((c0 >> BigInt(i)) & 1n) {\n        c ^= GENERATOR[i];\n      }\n    }\n  }\n  return c ^ 1n;\n}\n\nfunction prefixExpand(prefix: string): number[] {\n  return [...prefix].map((c) => c.charCodeAt(0) & 0x1f).concat([0]);\n}\n\nfunction createChecksum(prefix: string, data: number[]): number[] {\n  const values = prefixExpand(prefix).concat(data).concat([0, 0, 0, 0, 0, 0, 0, 0]);\n  const mod = polymod(values);\n  const ret: number[] = [];\n  for (let i = 7; i >= 0; i--) {\n    ret.push(Number((mod >> BigInt(5 * i)) & 31n));\n  }\n  return ret;\n}\n\nfunction verifyChecksum(prefix: string, data: number[]): boolean {\n  const values = prefixExpand(prefix).concat(data);\n  return polymod(values) === 0n;\n}\n\nfunction convertBits(data: Buffer | Uint8Array, from: number, to: number, pad: boolean): number[] {\n  let acc = 0;\n  let bits = 0;\n  const ret: number[] = [];\n  const maxv = (1 << to) - 1;\n  for (const value of data) {\n    acc = (acc << from) | value;\n    bits += from;\n    while (bits >= to) {\n      bits -= to;\n      ret.push((acc >> bits) & maxv);\n    }\n  }\n  if (pad && bits > 0) {\n    ret.push((acc << (to - bits)) & maxv);\n  }\n  return ret;\n}\n\n/**\n * Encode data into a Kaspa bech32-like address.\n */\nfunction kaspaEncode(prefix: string, data: number[]): string {\n  const checksum = createChecksum(prefix, data);\n  return (\n    prefix +\n    ':' +\n    data\n      .concat(checksum)\n      .map((d) => CHARSET[d])\n      .join('')\n  );\n}\n\n/**\n * Decode a Kaspa bech32-like address.\n * Returns { prefix, data } or throws on error.\n */\nfunction kaspacDecode(address: string): { prefix: string; data: number[] } {\n  const colonIdx = address.lastIndexOf(':');\n  if (colonIdx < 1) {\n    throw new Error('Missing prefix separator');\n  }\n  const prefix = address.slice(0, colonIdx).toLowerCase();\n  const encoded = address.slice(colonIdx + 1).toLowerCase();\n\n  const data: number[] = [];\n  for (const c of encoded) {\n    const val = CHARSET_REVERSE[c];\n    if (val === undefined) {\n      throw new Error(`Invalid character: ${c}`);\n    }\n    data.push(val);\n  }\n\n  if (!verifyChecksum(prefix, data)) {\n    throw new Error('Invalid checksum');\n  }\n\n  return { prefix, data: data.slice(0, -8) };\n}\n\n/**\n * Validates a Kaspa address (mainnet or testnet)\n */\nexport function isValidKaspaAddress(address: string): boolean {\n  if (!address || typeof address !== 'string') {\n    return false;\n  }\n\n  const colonIdx = address.lastIndexOf(':');\n  if (colonIdx < 1) {\n    return false;\n  }\n\n  const prefix = address.slice(0, colonIdx).toLowerCase();\n  if (prefix !== MAINNET_PREFIX && prefix !== TESTNET_PREFIX) {\n    return false;\n  }\n\n  try {\n    const decoded = kaspacDecode(address);\n    return decoded.data.length > 0;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validates a Kaspa mainnet address\n */\nexport function isValidMainnetAddress(address: string): boolean {\n  return isValidKaspaAddress(address) && address.toLowerCase().startsWith(MAINNET_PREFIX + ':');\n}\n\n/**\n * Validates a Kaspa testnet address\n */\nexport function isValidTestnetAddress(address: string): boolean {\n  return isValidKaspaAddress(address) && address.toLowerCase().startsWith(TESTNET_PREFIX + ':');\n}\n\n/**\n * Derive a Kaspa P2PK (Schnorr) address from a compressed secp256k1 public key.\n *\n * @param compressedPubKey - 33-byte compressed secp256k1 public key (hex string or Buffer)\n * @param hrp - human-readable part ('kaspa' or 'kaspatest')\n */\nexport function pubKeyToKaspaAddress(compressedPubKey: string | Buffer, hrp: string): string {\n  const pubKeyBytes = Buffer.isBuffer(compressedPubKey)\n    ? compressedPubKey\n    : Buffer.from(compressedPubKey as string, 'hex');\n\n  if (pubKeyBytes.length !== 33) {\n    throw new Error(`Expected 33-byte compressed public key, got ${pubKeyBytes.length}`);\n  }\n\n  // X-only public key: drop the prefix byte (02 or 03), keep 32-byte x-coordinate\n  const xOnlyPubKey = pubKeyBytes.slice(1);\n\n  // Kaspa P2PK address:\n  // - version nibble: 0 (Schnorr secp256k1 P2PK)\n  // - payload: x-only public key (32 bytes)\n  const versionByte = 0;\n  const payload = Buffer.concat([Buffer.from([versionByte]), xOnlyPubKey]);\n  const words = convertBits(payload, 8, 5, true);\n\n  return kaspaEncode(hrp, words);\n}\n\n/**\n * Validates a secp256k1 public key (compressed or uncompressed)\n */\nexport function isValidPublicKey(pub: string): boolean {\n  if (!pub || typeof pub !== 'string') {\n    return false;\n  }\n  try {\n    const buf = Buffer.from(pub, 'hex');\n    if (buf.length === 33) {\n      return buf[0] === 0x02 || buf[0] === 0x03;\n    }\n    if (buf.length === 65) {\n      return buf[0] === 0x04;\n    }\n    return false;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validates a secp256k1 private key (32-byte hex)\n */\nexport function isValidPrivateKey(prv: string): boolean {\n  if (!prv || typeof prv !== 'string') {\n    return false;\n  }\n  if (isValidXprv(prv) || isValidXpub(prv)) {\n    return true;\n  }\n  try {\n    const buf = Buffer.from(prv.slice(0, 64), 'hex');\n    return buf.length === 32;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validates a transaction ID (64-char hex)\n */\nexport function isValidTransactionId(txId: string): boolean {\n  return /^[0-9a-fA-F]{64}$/.test(txId);\n}\n\nexport class Utils implements BaseUtils {\n  isValidAddress(address: string): boolean {\n    return isValidKaspaAddress(address);\n  }\n\n  isValidBlockId(hash: string): boolean {\n    return /^[0-9a-fA-F]{64}$/.test(hash);\n  }\n\n  isValidPrivateKey(key: string): boolean {\n    return isValidPrivateKey(key);\n  }\n\n  isValidPublicKey(key: string): boolean {\n    return isValidPublicKey(key);\n  }\n\n  isValidSignature(signature: string): boolean {\n    return /^[0-9a-fA-F]{128,130}$/.test(signature);\n  }\n\n  isValidTransactionId(txId: string): boolean {\n    return isValidTransactionId(txId);\n  }\n}\n\nconst utils = new Utils();\nexport default utils;\n"]}

package/dist/src/register.d.ts

@@ -0,0 +1,3 @@
+import { BitGoBase } from '@bitgo-beta/sdk-core';
+export declare const register: (sdk: BitGoBase) => void;
+//# sourceMappingURL=register.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGjD,eAAO,MAAM,QAAQ,QAAS,SAAS,KAAG,IAGzC,CAAC"}

package/dist/src/register.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const kaspa_1 = require("./kaspa");
+const register = (sdk) => {
+    sdk.register('kaspa', kaspa_1.Kaspa.createInstance);
+    sdk.register('tkaspa', kaspa_1.Kaspa.createInstance);
+};
+exports.register = register;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsbUNBQWdDO0FBRXpCLE1BQU0sUUFBUSxHQUFHLENBQUMsR0FBYyxFQUFRLEVBQUU7SUFDL0MsR0FBRyxDQUFDLFFBQVEsQ0FBQyxPQUFPLEVBQUUsYUFBSyxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQzVDLEdBQUcsQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLGFBQUssQ0FBQyxjQUFjLENBQUMsQ0FBQztBQUMvQyxDQUFDLENBQUM7QUFIVyxRQUFBLFFBQVEsWUFHbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCaXRHb0Jhc2UgfSBmcm9tICdAYml0Z28tYmV0YS9zZGstY29yZSc7XG5pbXBvcnQgeyBLYXNwYSB9IGZyb20gJy4va2FzcGEnO1xuXG5leHBvcnQgY29uc3QgcmVnaXN0ZXIgPSAoc2RrOiBCaXRHb0Jhc2UpOiB2b2lkID0+IHtcbiAgc2RrLnJlZ2lzdGVyKCdrYXNwYScsIEthc3BhLmNyZWF0ZUluc3RhbmNlKTtcbiAgc2RrLnJlZ2lzdGVyKCd0a2FzcGEnLCBLYXNwYS5jcmVhdGVJbnN0YW5jZSk7XG59O1xuIl19

package/dist/test/fixtures/kaspa.fixtures.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Kaspa (KASPA) Test Fixtures
+ *
+ * Deterministic test data derived from a fixed private key.
+ * Do NOT use these keys in production.
+ */
+import { KaspaTransactionData, KaspaUtxoInput } from '../../src/lib/iface';
+export declare const TEST_PRV_KEY = "b94f5374fce5edbc8e2a8697c15331677e6ebf0b000000000000000000000001";
+export declare const KEYS: {
+    prv: string;
+    pub: string;
+};
+export declare const ADDRESSES: {
+    valid: string;
+    testnet: string;
+    invalid: string;
+    sender: string;
+    recipient: string;
+};
+export declare const SCRIPT_PUBLIC_KEY: string;
+export declare const UTXOS: {
+    readonly simple: KaspaUtxoInput;
+    readonly second: KaspaUtxoInput;
+};
+export declare const TRANSACTIONS: {
+    readonly simple: KaspaTransactionData;
+    readonly multiInput: KaspaTransactionData;
+};
+//# sourceMappingURL=kaspa.fixtures.d.ts.map

package/dist/test/fixtures/kaspa.fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kaspa.fixtures.d.ts","sourceRoot":"","sources":["../../../test/fixtures/kaspa.fixtures.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG3E,eAAO,MAAM,YAAY,qEAAqE,CAAC;AAO/F,eAAO,MAAM,IAAI;;;CAGhB,CAAC;AAEF,eAAO,MAAM,SAAS;;;;;;CAMrB,CAAC;AAEF,eAAO,MAAM,iBAAiB,QAAmB,CAAC;AAGlD,eAAO,MAAM,KAAK;qBACF,cAAc;qBAUd,cAAc;CAU7B,CAAC;AAGF,eAAO,MAAM,YAAY;qBACT,oBAAoB;yBAmBhB,oBAAoB;CAmBvC,CAAC"}