@bitshard.io/bitshard-sdk 0.0.1

package/src/crypto/encoding.ts

@@ -0,0 +1,227 @@
+/**
+ * Encoding utilities for cryptocurrency operations
+ */
+
+/**
+ * Convert hex string to Uint8Array
+ * @param hex - Hex string (with or without 0x prefix)
+ * @returns Uint8Array
+ */
+export function hexToBytes(hex: string): Uint8Array {
+    const cleanHex = hex.replace(/^0x/, '');
+    if (cleanHex.length % 2 !== 0) {
+        throw new Error('Hex string must have even length');
+    }
+    
+    const bytes = new Uint8Array(cleanHex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(cleanHex.substr(i * 2, 2), 16);
+    }
+    
+    return bytes;
+}
+
+/**
+ * Convert Uint8Array to hex string
+ * @param bytes - Uint8Array
+ * @param prefix - Whether to add 0x prefix (default: false)
+ * @returns Hex string
+ */
+export function bytesToHex(bytes: Uint8Array, prefix: boolean = false): string {
+    const hex = Array.from(bytes)
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+    
+    return prefix ? '0x' + hex : hex;
+}
+
+/**
+ * Convert Buffer to hex string
+ * @param buffer - Buffer
+ * @param prefix - Whether to add 0x prefix (default: false)
+ * @returns Hex string
+ */
+export function bufferToHex(buffer: Buffer, prefix: boolean = false): string {
+    const hex = buffer.toString('hex');
+    return prefix ? '0x' + hex : hex;
+}
+
+/**
+ * Convert hex string to Buffer
+ * @param hex - Hex string (with or without 0x prefix)
+ * @returns Buffer
+ */
+export function hexToBuffer(hex: string): Buffer {
+    const cleanHex = hex.replace(/^0x/, '');
+    return Buffer.from(cleanHex, 'hex');
+}
+
+/**
+ * Convert base64 string to Uint8Array
+ * @param base64 - Base64 encoded string
+ * @returns Uint8Array
+ */
+export function base64ToBytes(base64: string): Uint8Array {
+    return new Uint8Array(Buffer.from(base64, 'base64'));
+}
+
+/**
+ * Convert Uint8Array to base64 string
+ * @param bytes - Uint8Array
+ * @returns Base64 encoded string
+ */
+export function bytesToBase64(bytes: Uint8Array): string {
+    return Buffer.from(bytes).toString('base64');
+}
+
+/**
+ * Convert UTF-8 string to Uint8Array
+ * @param str - UTF-8 string
+ * @returns Uint8Array
+ */
+export function utf8ToBytes(str: string): Uint8Array {
+    return new TextEncoder().encode(str);
+}
+
+/**
+ * Convert Uint8Array to UTF-8 string
+ * @param bytes - Uint8Array
+ * @returns UTF-8 string
+ */
+export function bytesToUtf8(bytes: Uint8Array): string {
+    return new TextDecoder().decode(bytes);
+}
+
+/**
+ * Concatenate multiple Uint8Arrays
+ * @param arrays - Arrays to concatenate
+ * @returns Combined Uint8Array
+ */
+export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
+    const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    
+    return result;
+}
+
+/**
+ * Compare two Uint8Arrays for equality
+ * @param a - First array
+ * @param b - Second array
+ * @returns True if arrays are equal
+ */
+export function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+    if (a.length !== b.length) return false;
+    
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) return false;
+    }
+    
+    return true;
+}
+
+/**
+ * Convert number to big-endian Uint8Array
+ * @param num - Number to convert
+ * @param bytes - Number of bytes (default: 4)
+ * @returns Uint8Array in big-endian format
+ */
+export function numberToBytes(num: number, bytes: number = 4): Uint8Array {
+    const arr = new Uint8Array(bytes);
+    for (let i = bytes - 1; i >= 0; i--) {
+        arr[i] = num & 0xff;
+        num = num >> 8;
+    }
+    return arr;
+}
+
+/**
+ * Convert big-endian Uint8Array to number
+ * @param bytes - Uint8Array in big-endian format
+ * @returns Number
+ */
+export function bytesToNumber(bytes: Uint8Array): number {
+    let num = 0;
+    for (const byte of bytes) {
+        num = (num << 8) | byte;
+    }
+    return num;
+}
+
+/**
+ * Convert BigInt to Uint8Array
+ * @param bigint - BigInt value
+ * @param length - Optional fixed length (pads with zeros)
+ * @returns Uint8Array
+ */
+export function bigintToBytes(bigint: bigint, length?: number): Uint8Array {
+    let hex = bigint.toString(16);
+    if (hex.length % 2 !== 0) {
+        hex = '0' + hex;
+    }
+    
+    const bytes = hexToBytes(hex);
+    
+    if (length && bytes.length < length) {
+        const padded = new Uint8Array(length);
+        padded.set(bytes, length - bytes.length);
+        return padded;
+    }
+    
+    return bytes;
+}
+
+/**
+ * Convert Uint8Array to BigInt
+ * @param bytes - Uint8Array
+ * @returns BigInt
+ */
+export function bytesToBigint(bytes: Uint8Array): bigint {
+    if (bytes.length === 0) return 0n;
+    return BigInt('0x' + bytesToHex(bytes));
+}
+
+/**
+ * Generate random bytes
+ * @param length - Number of bytes to generate
+ * @returns Random Uint8Array
+ */
+export function randomBytes(length: number): Uint8Array {
+    const bytes = new Uint8Array(length);
+    if (typeof globalThis.crypto !== 'undefined' && globalThis.crypto.getRandomValues) {
+        globalThis.crypto.getRandomValues(bytes);
+    } else {
+        // Fallback for Node.js
+        const crypto = require('crypto');
+        const buffer = crypto.randomBytes(length);
+        bytes.set(buffer);
+    }
+    return bytes;
+}
+
+/**
+ * Hash data using SHA256
+ * @param data - Data to hash
+ * @returns SHA256 hash as Uint8Array
+ */
+export function sha256(data: Uint8Array): Uint8Array {
+    const crypto = require('crypto');
+    const hash = crypto.createHash('sha256');
+    hash.update(data);
+    return new Uint8Array(hash.digest());
+}
+
+/**
+ * Double SHA256 hash (used in Bitcoin)
+ * @param data - Data to hash
+ * @returns Double SHA256 hash as Uint8Array
+ */
+export function doubleSha256(data: Uint8Array): Uint8Array {
+    return sha256(sha256(data));
+}

package/src/index.ts

@@ -0,0 +1,40 @@
+// Core exports
+export { DKLSService } from './core/DKLSService';
+export { DKLSParty } from './core/DKLSParty';
+export { ThresholdConfig } from './core/ThresholdConfig';
+export * from './core/types';
+
+// Crypto exports
+export * from './crypto/addresses';
+export * from './crypto/encoding';
+
+// Protocol exports
+export * from './protocols/keygen';
+export * from './protocols/signing';
+export * from './protocols/presignature';
+export * from './protocols/refresh';
+
+// Chain exports
+export * from './chains/config';
+export * from './chains/evm/EVMChain';
+export * from './chains/bitcoin/BitcoinChain';
+
+// RPC exports
+export * from './rpc/RPCProvider';
+export * from './rpc/methods';
+
+// Wire format exports
+export * from './wire/format';
+export * from './wire/validation';
+
+// WebSocket exports
+export * from './websocket/coordinator';
+export * from './websocket/session';
+export * from './websocket/messages';
+
+// Main SDK class
+export { BitShardSDK } from './BitShardSDK';
+
+// Re-export classes and types from WASM library
+// This ensures all consumers use the same WASM instance
+export { Message, Keyshare, KeygenSession, SignSession } from '@silencelaboratories/dkls-wasm-ll-node';

package/src/protocols/keygen.ts

@@ -0,0 +1,8 @@
+/**
+ * Key generation protocol implementation
+ */
+
+export { DKLSService } from '../core/DKLSService';
+export { DKLSParty } from '../core/DKLSParty';
+
+// TODO: Implement protocol-specific helpers and utilities

package/src/protocols/presignature.ts

@@ -0,0 +1,196 @@
+/**
+ * Pre-signature generation and management
+ * 
+ * CRITICAL SECURITY WARNING:
+ * Pre-signatures MUST NOT be reused. Reusing a pre-signature will expose the private key.
+ */
+
+import { SignSession, Keyshare, Message } from '@silencelaboratories/dkls-wasm-ll-node';
+import type { PreSignature } from '../core/types';
+
+/**
+ * Pre-signature manager for secure pre-signature generation and tracking
+ */
+export class PreSignatureManager {
+    private consumedPreSignatures: Set<string> = new Set();
+    private preSignaturePool: Map<string, PreSignature> = new Map();
+
+    /**
+     * Generate pre-signatures that can be computed ahead of time
+     * @param keyshares Array of keyshares
+     * @param threshold Threshold value
+     * @param count Number of pre-signatures to generate
+     * @returns Array of pre-signatures
+     */
+    async generatePreSignatures(
+        keyshares: Keyshare[],
+        threshold: number,
+        count: number = 1
+    ): Promise<PreSignature[]> {
+        if (keyshares.length < threshold) {
+            throw new Error(`Insufficient keyshares: need ${threshold}, got ${keyshares.length}`);
+        }
+
+        const preSignatures: PreSignature[] = [];
+
+        for (let i = 0; i < count; i++) {
+            const id = this.generateId();
+            
+            // Use first threshold keyshares
+            const signingShares = keyshares.slice(0, threshold);
+            
+            // Create sign sessions
+            const parties: SignSession[] = signingShares.map(ks => 
+                new SignSession(ks, "m")
+            );
+
+            // Execute pre-signature rounds
+            const preSignature = await this.executePreSignatureRounds(
+                parties,
+                id
+            );
+
+            preSignatures.push(preSignature);
+            this.preSignaturePool.set(id, preSignature);
+        }
+
+        return preSignatures;
+    }
+
+    /**
+     * Execute pre-signature generation rounds
+     */
+    private async executePreSignatureRounds(
+        parties: SignSession[],
+        id: string
+    ): Promise<PreSignature> {
+        // Round 1: Create first messages
+        const msg1: Message[] = parties.map(p => p.createFirstMessage());
+        const selfIds: number[] = msg1.map(m => m.from_id);
+
+        // Round 2: Broadcast first messages
+        const msg2: Message[] = parties.flatMap((p, idx) =>
+            p.handleMessages(this.filterMessages(msg1, selfIds[idx]!))
+        );
+
+        // Round 3: Handle P2P messages
+        const msg3: Message[] = parties.flatMap((p, idx) =>
+            p.handleMessages(this.selectMessages(msg2, selfIds[idx]!))
+        );
+
+        // Round 4: Complete pre-signature
+        parties.forEach((p, idx) =>
+            p.handleMessages(this.selectMessages(msg3, selfIds[idx]!))
+        );
+
+        return {
+            id,
+            parties,
+            createdAt: new Date(),
+            consumed: false
+        };
+    }
+
+    /**
+     * Use a pre-signature to sign a message
+     * @param messageHash Message hash to sign
+     * @param preSignature Pre-signature to consume
+     * @returns Signature components
+     */
+    async signWithPreSignature(
+        messageHash: Uint8Array,
+        preSignature: PreSignature
+    ): Promise<[Uint8Array, Uint8Array]> {
+        // Check if pre-signature has already been used
+        if (this.consumedPreSignatures.has(preSignature.id)) {
+            throw new Error(
+                'CRITICAL: Pre-signature has already been used! ' +
+                'Reusing pre-signatures exposes the private key!'
+            );
+        }
+
+        if (preSignature.consumed) {
+            throw new Error('Pre-signature has already been consumed');
+        }
+
+        // Mark as consumed IMMEDIATELY
+        this.consumedPreSignatures.add(preSignature.id);
+        preSignature.consumed = true;
+
+        const { parties } = preSignature;
+        const selfIds = parties.map((_, idx) => idx);
+
+        // Generate last message with actual message hash
+        const msg4: Message[] = parties.map(p => p.lastMessage(messageHash));
+
+        // Combine to produce signature (consumes session)
+        const signatures = parties.map((p, idx) => 
+            p.combine(this.filterMessages(msg4, selfIds[idx]!))
+        );
+
+        // All parties should produce the same signature
+        return signatures[0]!;
+    }
+
+    /**
+     * Check if a pre-signature has been consumed
+     * @param id Pre-signature ID
+     * @returns True if consumed
+     */
+    isConsumed(id: string): boolean {
+        return this.consumedPreSignatures.has(id);
+    }
+
+    /**
+     * Get available pre-signature count
+     * @returns Number of unused pre-signatures
+     */
+    getAvailableCount(): number {
+        return Array.from(this.preSignaturePool.values())
+            .filter(ps => !ps.consumed).length;
+    }
+
+    /**
+     * Get next available pre-signature
+     * @returns Pre-signature or undefined
+     */
+    getNextAvailable(): PreSignature | undefined {
+        return Array.from(this.preSignaturePool.values())
+            .find(ps => !ps.consumed);
+    }
+
+    /**
+     * Clear consumed pre-signatures from pool
+     */
+    cleanupConsumed(): void {
+        for (const [id, preSignature] of this.preSignaturePool.entries()) {
+            if (preSignature.consumed) {
+                this.preSignaturePool.delete(id);
+            }
+        }
+    }
+
+    /**
+     * Generate unique ID
+     */
+    private generateId(): string {
+        return `presig-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Filter messages for broadcast
+     */
+    private filterMessages(msgs: Message[], party: number): Message[] {
+        return msgs.filter((m) => m.from_id !== party).map(m => m.clone());
+    }
+
+    /**
+     * Select P2P messages
+     */
+    private selectMessages(msgs: Message[], party: number): Message[] {
+        return msgs.filter((m) => m.to_id === party).map(m => m.clone());
+    }
+}
+
+// Export singleton instance
+export const preSignatureManager = new PreSignatureManager();

package/src/protocols/refresh.ts

@@ -0,0 +1,7 @@
+/**
+ * Key refresh/rotation protocol
+ */
+
+export { DKLSService } from '../core/DKLSService';
+
+// TODO: Implement key refresh protocol helpers

package/src/protocols/signing.ts

@@ -0,0 +1,9 @@
+/**
+ * Signing protocol implementation
+ */
+
+export { DKLSService } from '../core/DKLSService';
+export { DKLSParty } from '../core/DKLSParty';
+export type { SignatureResult } from '../core/types';
+
+// TODO: Implement signing protocol helpers

package/src/rpc/RPCProvider.ts

@@ -0,0 +1,7 @@
+/**
+ * RPC provider interface
+ */
+
+export interface RPCProvider {
+    // TODO: Implement RPC provider interface
+}

package/src/rpc/methods.ts

@@ -0,0 +1,7 @@
+/**
+ * RPC method registry
+ */
+
+export const RPC_METHODS = {
+    // TODO: Implement RPC methods
+};

package/src/websocket/coordinator.ts

@@ -0,0 +1,7 @@
+/**
+ * WebSocket coordinator for multi-party protocols
+ */
+
+export class WebSocketCoordinator {
+    // TODO: Implement WebSocket coordination
+}

package/src/websocket/messages.ts

@@ -0,0 +1,11 @@
+/**
+ * WebSocket protocol messages
+ */
+
+export interface WebSocketMessage {
+    type: string;
+    sessionId: string;
+    payload: any;
+}
+
+// TODO: Implement protocol messages

package/src/websocket/session.ts

@@ -0,0 +1,7 @@
+/**
+ * WebSocket session management
+ */
+
+export type { WebSocketSession } from '../core/types';
+
+// TODO: Implement session management

package/src/wire/format.ts

@@ -0,0 +1,10 @@
+/**
+ * Wire message format utilities
+ */
+
+export type { WireMessage } from '../core/types';
+import { DKLSService } from '../core/DKLSService';
+
+// Re-export wire format methods
+export const toWireMessage = DKLSService.toWireMessage;
+export const fromWireMessage = DKLSService.fromWireMessage;

package/src/wire/validation.ts

@@ -0,0 +1,14 @@
+/**
+ * Wire message validation
+ */
+
+import type { WireMessage } from '../core/types';
+
+export function validateWireMessage(message: any): message is WireMessage {
+    return (
+        typeof message === 'object' &&
+        typeof message.from_id === 'number' &&
+        typeof message.payload === 'string' &&
+        (message.to_id === undefined || typeof message.to_id === 'number')
+    );
+}