@bitshard.io/bitshard-sdk 0.0.1

package/src/core/types.ts

@@ -0,0 +1,253 @@
+import type { Keyshare } from '@silencelaboratories/dkls-wasm-ll-node';
+
+/**
+ * Result of distributed key generation
+ */
+export interface DKGResult {
+    /** SHA256 hash of the public key */
+    dkgCommitment: string;
+    /** SHA256 hash of the server share */
+    serverShareCommitment: string;
+    /** Master public key in hex format with 0x prefix */
+    masterPublicKey: string;
+    /** Base64 encoded server keyshare */
+    serverShare: string;
+    /** Base64 encoded backup keyshare */
+    backupShare: string;
+    /** Base64 encoded mobile keyshare */
+    mobileShare: string;
+    /** Public key in hex format with 0x prefix */
+    publicKey: string;
+    /** Ethereum address */
+    ethAddress: string;
+    /** Bitcoin address (P2PKH) */
+    btcAddress: string;
+    /** Cosmos address */
+    cosmosAddress: string;
+    /** BNB Smart Chain address (same as ETH) */
+    bnbAddress: string;
+    /** Polygon address (same as ETH) */
+    polygonAddress: string;
+    /** Avalanche C-Chain address (same as ETH) */
+    avaxAddress: string;
+    /** Arbitrum address (same as ETH) */
+    arbAddress: string;
+}
+
+/**
+ * Extended DKG result for flexible threshold configurations
+ */
+export interface FlexibleDKGResult {
+    /** Total number of parties */
+    totalParties: number;
+    /** Threshold required for signing */
+    threshold: number;
+    /** Public key in hex format with 0x prefix */
+    publicKey: string;
+    /** SHA256 hash of the public key */
+    dkgCommitment: string;
+    /** Array of keyshares for each party */
+    keyshares: PartyKeyshare[];
+    /** Derived blockchain addresses */
+    addresses: BlockchainAddresses;
+}
+
+/**
+ * Keyshare data for a specific party
+ */
+export interface PartyKeyshare {
+    /** Party identifier (0-based index) */
+    partyId: number;
+    /** Base64 encoded keyshare data */
+    share: string;
+    /** SHA256 hash of the keyshare */
+    commitment: string;
+}
+
+/**
+ * Blockchain addresses derived from public key
+ */
+export interface BlockchainAddresses {
+    /** Ethereum address */
+    ethereum: string;
+    /** Bitcoin address (P2PKH) */
+    bitcoin: string;
+    /** Cosmos address */
+    cosmos: string;
+    /** Arbitrum address (same as ETH) */
+    arbitrum: string;
+    /** Polygon address (same as ETH) */
+    polygon: string;
+    /** BNB Smart Chain address (same as ETH) */
+    bnb: string;
+    /** Avalanche C-Chain address (same as ETH) */
+    avalanche: string;
+}
+
+/**
+ * MPC session for tracking protocol execution
+ */
+export interface MPCSession {
+    /** Unique session identifier */
+    id: string;
+    /** Associated wallet ID */
+    walletId: string;
+    /** Type of MPC operation */
+    sessionType: 'keygen' | 'signing' | 'refresh';
+    /** Current session status */
+    status: 'active' | 'completed' | 'failed';
+    /** List of participant IDs */
+    participants: string[];
+    /** Current protocol round */
+    currentRound?: number;
+    /** Total number of rounds */
+    totalRounds?: number;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Last update timestamp */
+    updatedAt: Date;
+}
+
+/**
+ * Signature result from threshold signing
+ */
+export interface SignatureResult {
+    /** Full signature in hex format with 0x prefix */
+    signature: string;
+    /** R component of signature */
+    r: string;
+    /** S component of signature */
+    s: string;
+    /** V value for Ethereum signatures */
+    v?: number;
+}
+
+/**
+ * Wire format for DKLS messages over network
+ */
+export interface WireMessage {
+    /** Sender party ID */
+    from_id: number;
+    /** Recipient party ID (optional for broadcast) */
+    to_id?: number;
+    /** Base64 encoded message payload */
+    payload: string;
+}
+
+/**
+ * Party configuration for distributed setup
+ */
+export interface PartyConfig {
+    /** Unique party identifier (0-based) */
+    partyId: number;
+    /** Total number of parties */
+    totalParties: number;
+    /** Threshold required for operations */
+    threshold: number;
+    /** Role of this party */
+    role?: 'coordinator' | 'signer';
+}
+
+/**
+ * Local wallet for testing (all parties in one process)
+ */
+export interface LocalWallet {
+    /** Public key in hex format */
+    publicKey: string;
+    /** All keyshares for local testing */
+    keyshares: Keyshare[];
+    /** Threshold configuration */
+    config: {
+        totalParties: number;
+        threshold: number;
+        partyIds: number[];
+    };
+}
+
+/**
+ * Pre-signature data structure
+ */
+export interface PreSignature {
+    /** Unique identifier for tracking */
+    id: string;
+    /** Sign sessions ready for final round */
+    parties: any[]; // Will be SignSession[] but avoiding import
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Whether this pre-signature has been consumed */
+    consumed: boolean;
+}
+
+/**
+ * Chain configuration for multi-chain support
+ */
+export interface ChainConfig {
+    /** Chain ID */
+    chainId: number;
+    /** Human-readable chain name */
+    name: string;
+    /** RPC endpoint URL */
+    rpcUrl: string;
+    /** Block explorer URL */
+    explorer?: string;
+    /** Native currency info */
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    /** Gas configuration */
+    gasConfig?: {
+        maxFeePerGas?: string;
+        maxPriorityFeePerGas?: string;
+    };
+}
+
+/**
+ * Bitcoin network configuration
+ */
+export interface BitcoinConfig {
+    /** Network type */
+    network: 'mainnet' | 'testnet' | 'regtest';
+    /** RPC endpoint URL */
+    rpcUrl?: string;
+    /** API URL for UTXO queries */
+    apiUrl?: string;
+    /** Default fee rate in sats/vbyte */
+    feeRate?: number;
+}
+
+/**
+ * WebSocket session for protocol coordination
+ */
+export interface WebSocketSession {
+    /** Session identifier */
+    sessionId: string;
+    /** Session type */
+    type: 'keygen' | 'signing' | 'refresh';
+    /** Connected parties */
+    parties: Set<number>;
+    /** Message queue */
+    messages: WireMessage[];
+    /** Session metadata */
+    metadata?: Record<string, any>;
+}
+
+/**
+ * SDK configuration options
+ */
+export interface SDKConfig {
+    /** WebSocket server URL for coordination */
+    websocketUrl?: string;
+    /** Default chain configuration */
+    defaultChain?: string;
+    /** Custom chain configurations */
+    chains?: Record<string, ChainConfig>;
+    /** Bitcoin network configuration */
+    bitcoin?: BitcoinConfig;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+
+// Re-export types from DKLS library for convenience
+export type { Message, Keyshare } from '@silencelaboratories/dkls-wasm-ll-node';

package/src/crypto/addresses.ts

@@ -0,0 +1,282 @@
+import crypto from 'crypto';
+import { keccak256 } from 'viem';
+import type { BlockchainAddresses } from '../core/types';
+import { getUncompressedPublicKey } from './elliptic';
+
+/**
+ * Derive Ethereum address from ECDSA public key
+ * @param publicKeyHex - Hex string of public key (compressed or uncompressed)
+ * @returns Ethereum address with 0x prefix
+ */
+export function deriveEthereumAddress(publicKeyHex: string): string {
+    // Remove 0x prefix if present
+    const cleanHex = publicKeyHex.replace(/^0x/, '');
+
+    // Get uncompressed public key (64 bytes, no 04 prefix)
+    const uncompressedKey = getUncompressedPublicKey(cleanHex);
+
+    // Keccak256 hash of the uncompressed public key
+    const hash = keccak256(`0x${uncompressedKey}`);
+
+    // Take the last 20 bytes (40 hex chars) as the address
+    const address = '0x' + hash.slice(-40);
+
+    return address.toLowerCase();
+}
+
+/**
+ * Derive Ethereum address from public key bytes
+ * @param publicKey - Uint8Array of the public key
+ * @returns Ethereum address with 0x prefix
+ */
+export function deriveEthereumAddressFromBytes(publicKey: Uint8Array): string {
+    // Remove the first byte (0x04 for uncompressed key) if present
+    const pubKeyBytes = publicKey[0] === 0x04 ? publicKey.slice(1) : publicKey;
+
+    // Convert to hex and derive address
+    const pubKeyHex = Buffer.from(pubKeyBytes).toString('hex');
+    return deriveEthereumAddress(pubKeyHex);
+}
+
+/**
+ * Derive Bitcoin P2PKH address from ECDSA public key
+ * @param publicKeyHex - Hex string of the public key
+ * @param network - Network type: 'mainnet', 'testnet', or 'regtest'
+ * @returns Bitcoin address in base58check format
+ */
+export function deriveBitcoinAddress(
+    publicKeyHex: string,
+    network: 'mainnet' | 'testnet' | 'regtest' = 'mainnet'
+): string {
+    // Remove 0x prefix if present
+    const cleanHex = publicKeyHex.replace(/^0x/, '');
+
+    // Convert to compressed public key format if uncompressed
+    const compressedPubKey = compressPublicKey(cleanHex);
+
+    // Step 1: SHA256 hash of the public key
+    const sha256Hash = crypto.createHash('sha256')
+        .update(Buffer.from(compressedPubKey, 'hex'))
+        .digest();
+
+    // Step 2: RIPEMD160 hash of the SHA256 hash
+    const ripemd160Hash = crypto.createHash('ripemd160')
+        .update(sha256Hash)
+        .digest();
+
+    // Step 3: Add version byte
+    // 0x00 for mainnet P2PKH
+    // 0x6f for testnet/regtest P2PKH
+    const versionByte = network === 'mainnet' ? 0x00 : 0x6f;
+    const versionedPayload = Buffer.concat([
+        Buffer.from([versionByte]),
+        ripemd160Hash
+    ]);
+
+    // Step 4: Calculate checksum (first 4 bytes of double SHA256)
+    const checksum = crypto.createHash('sha256')
+        .update(crypto.createHash('sha256').update(versionedPayload).digest())
+        .digest()
+        .slice(0, 4);
+
+    // Step 5: Append checksum
+    const finalPayload = Buffer.concat([versionedPayload, checksum]);
+
+    // Step 6: Base58 encode
+    return base58Encode(finalPayload);
+}
+
+/**
+ * Derive Bitcoin address from public key bytes
+ * @param publicKey - Uint8Array of the public key
+ * @param network - Network type
+ * @returns Bitcoin address in base58check format
+ */
+export function deriveBitcoinAddressFromBytes(
+    publicKey: Uint8Array,
+    network: 'mainnet' | 'testnet' | 'regtest' = 'mainnet'
+): string {
+    const pubKeyHex = Buffer.from(publicKey).toString('hex');
+    return deriveBitcoinAddress(pubKeyHex, network);
+}
+
+/**
+ * Derive Cosmos address from ECDSA public key
+ * @param publicKeyHex - Hex string of the public key
+ * @param prefix - Bech32 prefix (default: 'cosmos')
+ * @returns Cosmos address with bech32 encoding
+ */
+export function deriveCosmosAddress(publicKeyHex: string, prefix: string = 'cosmos'): string {
+    // Remove 0x prefix if present
+    const cleanHex = publicKeyHex.replace(/^0x/, '');
+
+    // Convert to compressed format
+    const compressedPubKey = compressPublicKey(cleanHex);
+
+    // SHA256 hash
+    const sha256Hash = crypto.createHash('sha256')
+        .update(Buffer.from(compressedPubKey, 'hex'))
+        .digest();
+
+    // RIPEMD160 hash
+    const ripemd160Hash = crypto.createHash('ripemd160')
+        .update(sha256Hash)
+        .digest();
+
+    // TODO: Implement proper bech32 encoding
+    // For now, return a simplified version
+    return prefix + '1' + ripemd160Hash.toString('hex').substring(0, 38);
+}
+
+/**
+ * Compress an uncompressed ECDSA public key
+ * @param publicKeyHex - Hex string of uncompressed public key (with or without 04 prefix)
+ * @returns Compressed public key hex string (33 bytes)
+ */
+export function compressPublicKey(publicKeyHex: string): string {
+    // Remove 04 prefix if present (uncompressed marker)
+    const cleanHex = publicKeyHex.startsWith('04') ? publicKeyHex.slice(2) : publicKeyHex;
+
+    // Split into x and y coordinates (32 bytes each)
+    const x = cleanHex.slice(0, 64);
+    const y = cleanHex.slice(64, 128);
+
+    // Determine prefix based on y coordinate parity
+    const yBigInt = BigInt('0x' + y);
+    const prefix = (yBigInt % 2n === 0n) ? '02' : '03';
+
+    return prefix + x;
+}
+
+/**
+ * Base58 encoding (for Bitcoin addresses)
+ */
+export function base58Encode(buffer: Buffer): string {
+    const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+    const base = BigInt(58);
+
+    let num = BigInt('0x' + buffer.toString('hex'));
+    let encoded = '';
+
+    while (num > 0n) {
+        const remainder = num % base;
+        num = num / base;
+        encoded = ALPHABET[Number(remainder)] + encoded;
+    }
+
+    // Handle leading zeros
+    for (let i = 0; i < buffer.length && buffer[i] === 0; i++) {
+        encoded = '1' + encoded;
+    }
+
+    return encoded;
+}
+
+/**
+ * Base58 decoding (for Bitcoin addresses)
+ */
+export function base58Decode(encoded: string): Buffer {
+    const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+    const ALPHABET_MAP: { [key: string]: bigint } = {};
+    for (let i = 0; i < ALPHABET.length; i++) {
+        ALPHABET_MAP[ALPHABET[i]!] = BigInt(i);
+    }
+
+    let num = 0n;
+    const base = 58n;
+
+    for (const char of encoded) {
+        num = num * base + ALPHABET_MAP[char]!;
+    }
+
+    // Convert to hex and then to buffer
+    let hex = num.toString(16);
+    // Ensure even length
+    if (hex.length % 2 !== 0) {
+        hex = '0' + hex;
+    }
+
+    const buffer = Buffer.from(hex, 'hex');
+
+    // Add leading zeros for each leading '1' in the input
+    let leadingZeros = 0;
+    for (const char of encoded) {
+        if (char === '1') {
+            leadingZeros++;
+        } else {
+            break;
+        }
+    }
+
+    return Buffer.concat([Buffer.alloc(leadingZeros), buffer]);
+}
+
+/**
+ * Derive addresses for all supported blockchains from public key
+ * @param publicKeyHex - Hex string of the public key
+ * @returns Object with addresses for all supported chains
+ */
+export function deriveAddresses(publicKeyHex: string): {
+    ethereum: string;
+    bitcoin: string;
+    bitcoinTestnet: string;
+    cosmos: string;
+    arbitrum: string;
+    polygon: string;
+    bnb: string;
+    avalanche: string;
+} {
+    const ethAddress = deriveEthereumAddress(publicKeyHex);
+
+    return {
+        ethereum: ethAddress,
+        bitcoin: deriveBitcoinAddress(publicKeyHex, 'mainnet'),
+        bitcoinTestnet: deriveBitcoinAddress(publicKeyHex, 'testnet'),
+        cosmos: deriveCosmosAddress(publicKeyHex),
+        // EVM-compatible chains use the same address as Ethereum
+        arbitrum: ethAddress,
+        polygon: ethAddress,
+        bnb: ethAddress,
+        avalanche: ethAddress
+    };
+}
+
+/**
+ * Derive addresses from public key bytes
+ * @param publicKey - Uint8Array of the public key
+ * @returns BlockchainAddresses object
+ */
+export function deriveAddressesFromBytes(publicKey: Uint8Array): BlockchainAddresses {
+    const pubKeyHex = Buffer.from(publicKey).toString('hex');
+    const addresses = deriveAddresses(pubKeyHex);
+
+    return {
+        ethereum: addresses.ethereum,
+        bitcoin: addresses.bitcoin,
+        cosmos: addresses.cosmos,
+        arbitrum: addresses.arbitrum,
+        polygon: addresses.polygon,
+        bnb: addresses.bnb,
+        avalanche: addresses.avalanche
+    };
+}
+
+/**
+ * Validate Ethereum address format
+ * @param address - Address to validate
+ * @returns True if valid Ethereum address
+ */
+export function isValidEthereumAddress(address: string): boolean {
+    return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+
+/**
+ * Validate Bitcoin address format (basic validation)
+ * @param address - Address to validate
+ * @returns True if valid Bitcoin address format
+ */
+export function isValidBitcoinAddress(address: string): boolean {
+    // Basic format check - proper validation would verify checksum
+    return /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/.test(address) || // P2PKH/P2SH
+        /^bc1[a-z0-9]{39,59}$/.test(address); // Bech32
+}

package/src/crypto/elliptic.ts

@@ -0,0 +1,133 @@
+/**
+ * Decompress a compressed ECDSA public key
+ * @param compressedHex - Hex string of compressed public key (33 bytes)
+ * @returns Uncompressed public key hex string (64 bytes, without 04 prefix)
+ */
+export function decompressPublicKey(compressedHex: string): string {
+    // Remove 0x prefix if present
+    const cleanHex = compressedHex.replace(/^0x/, '');
+
+    if (cleanHex.length !== 66) {
+        throw new Error('Invalid compressed public key length');
+    }
+
+    const prefix = cleanHex.slice(0, 2);
+    if (prefix !== '02' && prefix !== '03') {
+        throw new Error('Invalid compressed public key prefix');
+    }
+
+    // Get x coordinate
+    const x = BigInt('0x' + cleanHex.slice(2));
+
+    // secp256k1 curve parameters
+    const p = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F');
+    const a = BigInt(0);
+    const b = BigInt(7);
+
+    // Calculate y^2 = x^3 + ax + b (mod p)
+    const x3 = modPow(x, 3n, p);
+    const ax = (a * x) % p;
+    const y2 = (x3 + ax + b) % p;
+
+    // Calculate y = sqrt(y^2) mod p
+    let y = modSqrt(y2, p);
+
+    if (y === null) {
+        throw new Error('Invalid public key - no valid y coordinate');
+    }
+
+    // Choose the correct y based on prefix
+    const isEven = y % 2n === 0n;
+    const shouldBeEven = prefix === '02';
+
+    if (isEven !== shouldBeEven) {
+        y = p - y;
+    }
+
+    // Convert to hex strings (32 bytes each)
+    const xHex = x.toString(16).padStart(64, '0');
+    const yHex = y.toString(16).padStart(64, '0');
+
+    return xHex + yHex;
+}
+
+/**
+ * Modular exponentiation: (base^exp) % mod
+ */
+function modPow(base: bigint, exp: bigint, mod: bigint): bigint {
+    let result = 1n;
+    base = base % mod;
+
+    while (exp > 0n) {
+        if (exp % 2n === 1n) {
+            result = (result * base) % mod;
+        }
+        exp = exp >> 1n;
+        base = (base * base) % mod;
+    }
+
+    return result;
+}
+
+/**
+ * Modular square root using Tonelli-Shanks algorithm
+ * For secp256k1, p ≡ 3 (mod 4), so we can use the simpler formula
+ */
+function modSqrt(a: bigint, p: bigint): bigint | null {
+    // Check if a is a quadratic residue
+    const legendreSymbol = modPow(a, (p - 1n) / 2n, p);
+    if (legendreSymbol !== 1n) {
+        return null; // No square root exists
+    }
+
+    // For p ≡ 3 (mod 4), sqrt(a) = a^((p+1)/4) mod p
+    if (p % 4n === 3n) {
+        return modPow(a, (p + 1n) / 4n, p);
+    }
+
+    // For other cases, would need full Tonelli-Shanks
+    throw new Error('Unsupported prime for square root');
+}
+
+/**
+ * Check if a public key is compressed
+ * @param publicKeyHex - Hex string of public key
+ * @returns True if compressed (33 bytes), false if uncompressed (64 or 65 bytes)
+ */
+export function isCompressedPublicKey(publicKeyHex: string): boolean {
+    const cleanHex = publicKeyHex.replace(/^0x/, '');
+
+    // Compressed keys are 33 bytes (66 hex chars)
+    if (cleanHex.length === 66) {
+        const prefix = cleanHex.slice(0, 2);
+        return prefix === '02' || prefix === '03';
+    }
+
+    return false;
+}
+
+/**
+ * Get uncompressed public key, handling both compressed and uncompressed inputs
+ * @param publicKeyHex - Hex string of public key (compressed or uncompressed)
+ * @returns Uncompressed public key hex string (64 bytes, without 04 prefix)
+ */
+export function getUncompressedPublicKey(publicKeyHex: string): string {
+    const cleanHex = publicKeyHex.replace(/^0x/, '');
+
+    // Check if compressed
+    if (isCompressedPublicKey(cleanHex)) {
+        return decompressPublicKey(cleanHex);
+    }
+
+    // If uncompressed with 04 prefix, remove it
+    if (cleanHex.startsWith('04')) {
+        return cleanHex.slice(2);
+    }
+
+    // If already uncompressed without prefix (128 chars = 64 bytes)
+    if (cleanHex.length === 128) {
+        return cleanHex;
+    }
+
+    throw new Error(`Invalid public key format: ${cleanHex.length} hex chars`);
+}