smartledger-bsv 3.2.0 → 3.2.2

package/build/webpack.bundle.config.js

@@ -0,0 +1,22 @@
+const path = require('path')
+
+module.exports = {
+  entry: path.join(__dirname, '/bundle-entry.js'),
+  output: {
+    library: 'bsv',
+    libraryTarget: 'umd',
+    globalObject: 'typeof self !== \'undefined\' ? self : this',
+    path: path.join(__dirname, '/'),
+    filename: 'bsv.bundle.js'
+  },
+  node: {
+    crypto: 'empty',
+    stream: 'empty',  
+    Buffer: true
+  },
+  mode: 'production',
+  optimization: {
+    minimize: true
+  },
+
+}

package/build/webpack.config.js

@@ -0,0 +1,18 @@
+var path = require('path')
+
+module.exports = {
+  entry: path.join(__dirname, '/index.js'),
+  output: {
+    library: 'bsv',
+    libraryTarget: 'umd',
+    globalObject: 'typeof self !== \'undefined\' ? self : this',
+    path: path.join(__dirname, '/'),
+    filename: 'bsv.min.js'
+  },
+  node: {
+    crypto: 'empty',
+    stream: 'empty',
+    Buffer: true
+  },
+  mode: 'production'
+}

package/build/webpack.covenant.config.js

@@ -0,0 +1,27 @@
+const path = require('path');
+
+module.exports = {
+  mode: 'production',
+  entry: './covenant-entry.js',
+  output: {
+    path: path.resolve(__dirname, '.'),
+    filename: 'bsv-covenant.min.js',
+    library: 'bsvCovenant',
+    libraryTarget: 'var'
+  },
+  externals: {
+    // Don't bundle BSV - it should be loaded separately
+    '../index.js': 'bsv'
+  },
+  node: {
+    fs: 'empty',
+    path: 'empty',
+    crypto: 'empty',
+    stream: 'empty',
+    assert: 'empty',
+    http: 'empty',
+    https: 'empty',
+    os: 'empty',
+    url: 'empty'
+  }
+};

package/build/webpack.script-helper.config.js

@@ -0,0 +1,27 @@
+const path = require('path');
+
+module.exports = {
+  mode: 'production',
+  entry: './script-helper-entry.js',
+  output: {
+    path: path.resolve(__dirname, '.'),
+    filename: 'bsv-script-helper.min.js',
+    library: 'bsvScriptHelper',
+    libraryTarget: 'var'
+  },
+  externals: {
+    // Don't bundle BSV - it should be loaded separately
+    '../index.js': 'bsv'
+  },
+  node: {
+    fs: 'empty',
+    path: 'empty',
+    crypto: 'empty',
+    stream: 'empty',
+    assert: 'empty',
+    http: 'empty',
+    https: 'empty',
+    os: 'empty',
+    url: 'empty'
+  }
+};

package/build/webpack.security.config.js

@@ -0,0 +1,23 @@
+const path = require('path');
+
+module.exports = {
+  mode: 'production',
+  entry: './security-entry.js',
+  output: {
+    path: path.resolve(__dirname, '.'),
+    filename: 'bsv-security.min.js',
+    library: 'bsvSecurity',
+    libraryTarget: 'var'
+  },
+  node: {
+    fs: 'empty',
+    path: 'empty',
+    crypto: 'empty',
+    stream: 'empty',
+    assert: 'empty',
+    http: 'empty',
+    https: 'empty',
+    os: 'empty',
+    url: 'empty'
+  }
+};

package/build/webpack.smartcontract.config.js

@@ -0,0 +1,25 @@
+const path = require('path')
+
+module.exports = {
+  entry: path.join(__dirname, '/smartcontract-entry.js'),
+  output: {
+    library: 'bsvSmartContract',
+    libraryTarget: 'umd',
+    globalObject: 'typeof self !== \'undefined\' ? self : this',
+    path: path.join(__dirname, '/'),
+    filename: 'bsv-smartcontract.min.js'
+  },
+  externals: {
+    // Don't bundle BSV - expect it to be loaded separately
+    './index.js': 'bsv'
+  },
+  node: {
+    crypto: 'empty',
+    stream: 'empty',  
+    Buffer: true
+  },
+  mode: 'production',
+  optimization: {
+    minimize: true
+  }
+}

package/build/webpack.subproject.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  externals: {
+    '../../': 'bsv'
+  },
+  mode: 'production'
+}

package/bundle-entry.js

@@ -0,0 +1,265 @@
+/**
+ * SmartLedger BSV Complete Bundle
+ * 
+ * This bundle includes:
+ * - Core BSV library with all cryptographic functions
+ * - Message signing and verification
+ * - HD wallets and mnemonic generation  
+ * - ECIES encryption/decryption
+ * - SmartLedger security enhancements
+ * - All dependencies bundled for standalone usage
+ * 
+ * Usage:
+ *   <script src="bsv.bundle.js"></script>
+ *   <script>
+ *     // Everything available under 'bsv' namespace
+ *     const key = new bsv.PrivateKey();
+ *     const message = new bsv.Message('hello');  
+ *     const mnemonic = new bsv.Mnemonic();
+ *     const encrypted = bsv.ECIES.encrypt(data, publicKey);
+ *   </script>
+ */
+
+'use strict'
+
+// Load main BSV library
+var bsv = require('./index.js')
+
+// Attach Message functionality
+try {
+  const Message = require('./lib/message/message.js')
+  bsv.Message = Message
+  
+  // Make it available globally for consistency with separate modules
+  if (typeof window !== 'undefined') {
+    window.bsvMessage = Message
+  }
+} catch (e) {
+  console.warn('Message module not available:', e.message)
+}
+
+// Attach Mnemonic functionality with browser crypto polyfill
+try {
+  // Provide crypto polyfill for browser environment
+  if (typeof window !== 'undefined' && typeof crypto !== 'undefined' && crypto.subtle) {
+    // Browser environment - provide HMAC polyfill
+    const originalCrypto = require('crypto')
+    if (!originalCrypto.createHmac) {
+      originalCrypto.createHmac = function(algorithm, key) {
+        return {
+          update: function(data) { this._data = data; return this; },
+          digest: function(encoding) {
+            // Simple fallback - in production you'd want proper HMAC
+            const hash = bsv.crypto.Hash.sha256(Buffer.concat([
+              Buffer.isBuffer(key) ? key : Buffer.from(key), 
+              Buffer.isBuffer(this._data) ? this._data : Buffer.from(this._data)
+            ]));
+            return encoding === 'hex' ? hash.toString('hex') : hash;
+          }
+        };
+      };
+    }
+  }
+  
+  const Mnemonic = require('./lib/mnemonic/mnemonic.js')
+  bsv.Mnemonic = Mnemonic
+  
+  // Make it available globally for consistency with separate modules
+  if (typeof window !== 'undefined') {
+    window.bsvMnemonic = Mnemonic
+  }
+} catch (e) {
+  console.warn('Mnemonic module not available:', e.message)
+  console.warn('This is expected in browser environments without crypto polyfills')
+  
+  // Provide a minimal mnemonic alternative for browsers
+  if (typeof window !== 'undefined') {
+    bsv.Mnemonic = function() {
+      throw new Error('Full mnemonic functionality requires Node.js crypto. Use separate bsv-mnemonic.min.js for browser support.');
+    };
+    bsv.Mnemonic.fromString = function() {
+      throw new Error('Full mnemonic functionality requires Node.js crypto. Use separate bsv-mnemonic.min.js for browser support.');
+    };
+  }
+}
+
+// Attach ECIES functionality
+try {
+  const ECIES = require('./lib/ecies/index.js')
+  bsv.ECIES = ECIES
+  bsv.crypto.ECIES = ECIES
+  
+  // Make it available globally for consistency with separate modules  
+  if (typeof window !== 'undefined') {
+    window.bsvEcies = ECIES
+  }
+} catch (e) {
+  console.warn('ECIES module not available:', e.message)
+}
+
+// Include SmartContract interface with debug tools (forced for bundle)
+try {
+  const SmartContract = require('./lib/smart_contract')
+  bsv.SmartContract = SmartContract
+  console.log('SmartContract interface loaded in bundle with', Object.keys(SmartContract).length, 'methods')
+} catch (e) {
+  console.warn('SmartContract module not available:', e.message)
+}
+
+// Include CovenantInterface for advanced covenant development
+try {
+  const CovenantInterface = require('./lib/covenant-interface.js')
+  bsv.CovenantInterface = CovenantInterface
+  console.log('CovenantInterface loaded in bundle')
+} catch (e) {
+  console.warn('CovenantInterface module not available:', e.message)
+}
+
+// Include CustomScriptHelper for simplified script development
+try {
+  const CustomScriptHelper = require('./lib/custom-script-helper.js')
+  bsv.CustomScriptHelper = CustomScriptHelper
+  console.log('CustomScriptHelper loaded in bundle')
+} catch (e) {
+  console.warn('CustomScriptHelper module not available:', e.message)
+}
+
+// SmartLedger security modules (matching index.js structure)
+bsv.SmartLedger = {
+  version: bsv.version,
+  hardenedBy: bsv.hardenedBy,
+  baseVersion: bsv.baseVersion,
+  securityFeatures: bsv.securityFeatures,
+  SmartVerify: bsv.crypto.SmartVerify,
+  EllipticFixed: bsv.crypto.EllipticFixed
+}
+bsv.SmartVerify = bsv.crypto.SmartVerify
+bsv.EllipticFixed = bsv.crypto.EllipticFixed
+
+// Internal usage, exposed for testing/advanced tweaking (matching index.js)
+if (bsv.Transaction && bsv.Transaction.sighash === undefined) {
+  try {
+    bsv.Transaction.sighash = require('./lib/transaction/sighash')
+  } catch (e) {
+    console.warn('Transaction.sighash not available:', e.message)
+  }
+}
+
+// Enhanced bundle information
+bsv.bundle = {
+  version: bsv.version,
+  includes: [
+    'core-bsv',
+    'message-signing', 
+    'hd-wallets',
+    'mnemonic-generation',
+    'ecies-encryption',
+    'smartledger-security',
+    'smartcontract-interface',
+    'debug-tools',
+    'covenant-interface',
+    'custom-script-helper',
+    'advanced-sighash'
+  ],
+  size: 'complete',
+  type: 'all-in-one'
+}
+
+// SmartLedger bundle namespace
+bsv.SmartLedgerBundle = {
+  version: bsv.version,
+  hardenedBy: bsv.hardenedBy,
+  bundleIncludes: bsv.bundle.includes,
+  
+  // Quick access methods
+  generateKeys: function() {
+    const privateKey = new bsv.PrivateKey()
+    return {
+      privateKey: privateKey,
+      publicKey: privateKey.toPublicKey(),
+      address: privateKey.toAddress()
+    }
+  },
+  
+  generateMnemonic: function() {
+    if (!bsv.Mnemonic) {
+      throw new Error('Mnemonic functionality not available in bundle')
+    }
+    // Generate 24-word mnemonic by default (256-bit entropy)
+    return new bsv.Mnemonic(256)
+  },
+  
+  createMessage: function(text) {
+    if (!bsv.Message) {
+      throw new Error('Message functionality not available in bundle')
+    }
+    return new bsv.Message(text)
+  },
+  
+  encrypt: function(data, publicKey) {
+    if (!bsv.ECIES) {
+      throw new Error('ECIES functionality not available in bundle')
+    }
+    return bsv.ECIES.encrypt(data, publicKey)
+  },
+  
+  // SmartContract debug tools (NEW v3.2.1)
+  examineScript: function(scriptASM) {
+    if (!bsv.SmartContract || !bsv.SmartContract.examineStack) {
+      throw new Error('SmartContract debug tools not available in bundle')
+    }
+    const script = bsv.Script.fromASM(scriptASM)
+    return bsv.SmartContract.examineStack(script)
+  },
+  
+  interpretScript: function(scriptASM) {
+    if (!bsv.SmartContract || !bsv.SmartContract.interpretScript) {
+      throw new Error('SmartContract debug tools not available in bundle')
+    }
+    const script = bsv.Script.fromASM(scriptASM)
+    return bsv.SmartContract.interpretScript(script)
+  },
+  
+  getScriptMetrics: function(scriptASM) {
+    if (!bsv.SmartContract || !bsv.SmartContract.getScriptMetrics) {
+      throw new Error('SmartContract metrics not available in bundle')
+    }
+    const script = bsv.Script.fromASM(scriptASM)
+    return bsv.SmartContract.getScriptMetrics(script)
+  },
+  
+  optimizeScript: function(scriptASM) {
+    if (!bsv.SmartContract || !bsv.SmartContract.optimizeScript) {
+      throw new Error('SmartContract optimizer not available in bundle')
+    }
+    const script = bsv.Script.fromASM(scriptASM)
+    return bsv.SmartContract.optimizeScript(script)
+  },
+  
+  // Covenant development (NEW v3.2.1)
+  createCovenant: function(config) {
+    if (!bsv.CovenantInterface) {
+      throw new Error('CovenantInterface not available in bundle')
+    }
+    const covenantInterface = new bsv.CovenantInterface()
+    return covenantInterface.createCovenantTransaction(config)
+  },
+  
+  // Custom script development (NEW v3.2.1)
+  createCustomSignature: function(transaction, privateKey, inputIndex, lockingScript, satoshis, sighashType) {
+    if (!bsv.CustomScriptHelper) {
+      throw new Error('CustomScriptHelper not available in bundle')
+    }
+    return bsv.CustomScriptHelper.createSignature(transaction, privateKey, inputIndex, lockingScript, satoshis, sighashType)
+  },
+  
+  // Advanced sighash access (NEW v3.2.1)
+  calculateSighash: function(transaction, sighashType, inputNumber, subscript, satoshisBN) {
+    if (!bsv.Transaction || !bsv.Transaction.sighash) {
+      throw new Error('Advanced sighash functionality not available in bundle')
+    }
+    return bsv.Transaction.sighash.sighash(transaction, sighashType, inputNumber, subscript, satoshisBN)
+  }
+}
+
+module.exports = bsv

package/covenant-entry.js

@@ -0,0 +1,44 @@
+/**
+ * SmartLedger BSV Covenant Interface - Standalone Module
+ * 
+ * Advanced covenant development framework for Bitcoin SV
+ * Requires main BSV library to be loaded first.
+ * 
+ * Usage:
+ *   <script src="bsv.min.js"></script>
+ *   <script src="bsv-covenant.min.js"></script>
+ *   <script>
+ *     const covenant = new bsvCovenant.CovenantInterface();
+ *     const tx = covenant.createCovenantTransaction(config);
+ *   </script>
+ */
+
+'use strict'
+
+// Verify BSV library is available
+if (typeof bsv === 'undefined') {
+  throw new Error('CovenantInterface requires BSV library. Load bsv.min.js first.');
+}
+
+// Load CovenantInterface
+const CovenantInterface = require('./lib/covenant-interface.js');
+
+// Browser compatibility
+if (typeof window !== 'undefined') {
+  window.bsvCovenant = {
+    CovenantInterface: CovenantInterface,
+    version: bsv.version || 'unknown'
+  };
+  
+  // Also attach to main bsv object if available
+  if (typeof bsv !== 'undefined') {
+    bsv.CovenantInterface = CovenantInterface;
+  }
+  
+  console.log('CovenantInterface standalone module loaded');
+}
+
+module.exports = {
+  CovenantInterface: CovenantInterface,
+  version: bsv.version || 'unknown'
+};

package/docs/pushtx-key-insights.md

@@ -0,0 +1,106 @@
+# PUSHTX Key Insights and Application to SmartLedger-BSV
+
+This document extracts the critical insights from nChain's PUSHTX whitepaper that informed our implementation and security considerations for SmartLedger-BSV's smart contract capabilities.
+
+## Core PUSHTX Concept
+
+**Original Innovation**: Developed by Y. Chan and D. Kramer at nChain (2017)
+
+**Fundamental Principle**: Generate a signature in-script on a data element and use OP_CHECKSIG to verify it. When verification passes, it proves the message constructed by OP_CHECKSIG is identical to the data element on the stack, effectively "pushing" the current spending transaction to the stack.
+
+## Key Technical Components
+
+### 1. Signature Generation Building Block
+
+**ECDSA Formula**: `s = k^(-1)(z + ra) mod n`
+- `z`: Double SHA256 of message to be signed
+- `k`: Ephemeral key (must be fixed)
+- `r`: x-coordinate of ephemeral key point
+- `a`: Private key (must be fixed)
+- `n`: Curve order
+
+**Critical Security Requirements**:
+- Both private key `a` and ephemeral key `k` must be fixed in locking script
+- Public key must be fixed to prevent malleability
+- SIGHASH flag should be fixed for restrictiveness
+
+### 2. Message Construction Building Block
+
+**Signed Message Components** (11 items total):
+1. Version (4 bytes) - Optional
+2. Hash of input outpoints (32 bytes) - Infeasible due to circular reference
+3. Hash of input sequences (32 bytes) - Optional, recommend flexible
+4. Input outpoint (36 bytes) - Infeasible due to circular reference  
+5. Previous locking script length - Optional
+6. Previous locking script - Infeasible due to circular reference
+7. Previous output value (8 bytes) - Optional
+8. Sequence number (4 bytes) - Optional
+9. Hash of outputs (32 bytes) - Optional if known, otherwise infeasible
+10. Locktime (4 bytes) - Optional
+11. SIGHASH flag (4 bytes) - Recommend fixed
+
+## Security Analysis Insights
+
+### Formal Security Claims
+
+**Claim 1**: Computational infeasibility to construct alternative message `m'` that validates with same signature `(r,s)`, assuming hash function is preimage and collision resistant.
+
+**Claim 2**: Public key must be fixed to prevent signature malleability.
+
+**Claim 3**: Ephemeral key `k` must be fixed to prevent transaction ID changes.
+
+**Claim 4**: SIGHASH flag should be fixed to prevent unintended transaction modifications.
+
+## Application to SmartLedger-BSV
+
+### Implementation Considerations
+
+1. **Script Size Optimization**: 
+   - nChain's example shows ~1KB transaction sizes with optimizations
+   - Endianness reversal operations add significant overhead (~500 bytes)
+   - Alt stack usage can save ~200 bytes by storing constants
+
+2. **Perpetually Enforcing Locking Scripts (PELS)**:
+   - Enable conditions that persist across spending chains
+   - Useful for covenant-style smart contracts
+   - Critical for maintaining contract state across transactions
+
+3. **Transaction Fee Handling**:
+   - Can use SIGHASH_SINGLE|ANYONECANPAY for fee flexibility
+   - Alternative: Build fee deduction into locking script logic
+   - Diminishing output values can limit total spend iterations
+
+### Integration with SmartContract Interface
+
+Our SmartLedger-BSV implementation leverages these PUSHTX principles in:
+
+- **Transaction validation**: Ensuring spending transactions meet contract conditions
+- **State preservation**: Maintaining contract state across transaction chains  
+- **Security enforcement**: Preventing unauthorized modifications to contract logic
+- **Covenant implementation**: Creating self-enforcing contract conditions
+
+## Key Takeaways for Development
+
+1. **Security First**: Fixed keys and parameters prevent malleability attacks
+2. **Optimization Matters**: Script size directly impacts transaction costs
+3. **Flexibility vs Security**: Balance between enforceable constraints and spending flexibility
+4. **Circular Reference Challenges**: Some transaction fields cannot be predetermined
+5. **Hash Function Assumptions**: Security relies on SHA256 preimage and collision resistance
+
+## Technical Specifications Used
+
+- **Curve**: secp256k1
+- **Hash Function**: Double SHA256
+- **Signature Format**: DER encoding with canonical s values (s ≤ n/2)
+- **Bitcoin SV Version**: Tested on v1.0.8 regtest
+
+## Implementation Notes
+
+- All example scripts from nChain paper are for testing only
+- Mainnet deployment requires thorough security review
+- Endianness handling adds significant complexity
+- Alt stack optimization can reduce script size substantially
+
+---
+
+*This document synthesizes key insights from nChain's WP1605 "PUSHTX and Its Building Blocks" that directly informed SmartLedger-BSV's smart contract implementation and security model.*

package/index.js

@@ -97,17 +97,25 @@ bsv.SmartLedger = {
 bsv.SmartVerify = require('./lib/crypto/smartledger_verify')
 bsv.EllipticFixed = require('./lib/crypto/elliptic-fixed')
 
-// SmartLedger Development & Testing Tools (Node.js only)
+// SmartLedger Development & Testing Tools
+try {
+  // SmartContract Framework - now available in both Node.js and browser
+  bsv.SmartContract = require('./lib/smart_contract')
+} catch (e) {
+  // SmartContract not available - use standalone bsv-smartcontract.min.js
+  if (typeof window === 'undefined') {
+    console.warn('SmartContract module not available:', e.message)
+  }
+}
+
+// Node.js specific tools (advanced development tools)
 if (typeof window === 'undefined' && typeof require === 'function') {
   try {
     bsv.SmartUTXO = require('./lib/smartutxo')
     bsv.SmartMiner = require('./lib/smartminer')
     bsv.CustomScriptHelper = require('./lib/custom-script-helper')
-    
-    // Smart Contract Framework
-    bsv.SmartContract = require('./lib/smart_contract')
   } catch (e) {
-    // Browser environment - these tools not available
+    // Advanced tools not available
   }
 }