ci: move clippy step as a final touch step

Sometimes it is nice to have a fixup commit and be able to
run the tests without having to pass clippy or other repo rules
passing before running the e2e tests.

In other works clippy is a final touch check from the code
prospective, so probably make sense move to the end.

Signed-off-by: Vincenzo Palazzo <[email protected]>

Author: vincenzopalazzo

.github/workflows/ci.yml

@@ -41,20 +41,8 @@ jobs:
       - name: Disallow squash! commits
         run: git log --pretty=format:%s origin/master..HEAD | grep -zv squash!
 
-  clippy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: extractions/setup-just@v2
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: stable
-      - uses: Swatinem/rust-cache@v2
-      - run: cargo clippy --all-targets --all-features -- -D warnings
-
   unit-tests:
     runs-on: ubuntu-latest
-    needs: [ clippy ]
     steps:
       - uses: actions/checkout@v4
       - uses: extractions/setup-just@v2
@@ -66,7 +54,6 @@ jobs:
         run: RUST_BACKTRACE=1 cargo test --workspace --exclude ark-secp256k1
 
   e2e-tests:
-    needs: [ clippy ]
     strategy:
       fail-fast: false
       matrix:
@@ -123,3 +110,15 @@ jobs:
 
       - name: Build crates for WASM
         run: PATH="/opt/homebrew/opt/llvm/bin:$PATH" cargo build -p ark-core -p ark-rest --target wasm32-unknown-unknown
+
+  clippy:
+    runs-on: ubuntu-latest
+    needs: [ unit-tests, e2e-tests, wasm_ubuntu, wasm_macos ]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: extractions/setup-just@v2
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo clippy --all-targets --all-features -- -D warnings

ark-core/src/arknote.rs

@@ -0,0 +1,61 @@
+use crate::vtxo::VirtualUtxoScript;
+use bitcoin::Amount;
+use bitcoin::OutPoint;
+use bitcoin::ScriptBuf;
+use serde::Deserialize;
+use serde::Serialize;
+
+pub const PREIMAGE_LENGTH: usize = 32;
+
+#[derive(Debug, Clone)]
+pub struct ArkNote {
+    pub script: ScriptBuf,
+    pub note_script: ScriptBuf,
+    vtxo_script: VirtualUtxoScript,
+    outpoint: OutPoint,
+    value: Amount,
+    preimage: [u8; PREIMAGE_LENGTH],
+}
+
+impl ArkNote {
+    pub fn new(
+        script: ScriptBuf,
+        note_script: ScriptBuf,
+        vtxo_script: VirtualUtxoScript,
+        outpoint: OutPoint,
+        value: Amount,
+        preimage: [u8; PREIMAGE_LENGTH],
+    ) -> Self {
+        Self {
+            script,
+            note_script,
+            vtxo_script,
+            outpoint,
+            value,
+            preimage,
+        }
+    }
+
+    pub fn vtxo_script(&self) -> &VirtualUtxoScript {
+        &self.vtxo_script
+    }
+
+    pub fn outpoint(&self) -> OutPoint {
+        self.outpoint
+    }
+
+    pub fn value(&self) -> Amount {
+        self.value
+    }
+
+    pub fn preimage(&self) -> &[u8; PREIMAGE_LENGTH] {
+        &self.preimage
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Status {
+    Pending,
+    Confirmed,
+    Failed,
+}

ark-lightning/scripts/generate_ts_vectors.js

@@ -0,0 +1,58 @@
+// Script to generate test vectors from TypeScript SDK for comparison
+// Run this in the arkade-os/ts-sdk repository to get the expected hex values
+
+const { VhtlcScript } = require('../path/to/ts-sdk'); // Adjust path as needed
+
+// Test data from fixtures (same as used in Rust tests)
+const testData = {
+  preimageHash: Buffer.from('4d487dd3753a89bc9fe98401d1196523058251fc', 'hex'),
+  receiver: Buffer.from('021e1bb85455fe3f5aed60d101aa4dbdb9e7714f6226769a97a17a5331dadcd53b', 'hex'),
+  sender: Buffer.from('030192e796452d6df9697c280542e1560557bcf79a347d925895043136225c7cb4', 'hex'),
+  server: Buffer.from('03aad52d58162e9eefeafc7ad8a1cdca8060b5f01df1e7583362d052e266208f88', 'hex'),
+  refundLocktime: 265,
+  unilateralClaimDelay: { type: 'blocks', value: 17 },
+  unilateralRefundDelay: { type: 'blocks', value: 144 },
+  unilateralRefundWithoutReceiverDelay: { type: 'blocks', value: 144 }
+};
+
+try {
+  // Create VHTLC instance
+  const vhtlc = new VhtlcScript(testData);
+  
+  console.log('=== TypeScript SDK VHTLC Script Vectors ===\n');
+  
+  // Export all script hex values
+  const vectors = {
+    claim: vhtlc.claim().script.toString('hex'),
+    refund: vhtlc.refund().script.toString('hex'),
+    refundWithoutReceiver: vhtlc.refundWithoutReceiver().script.toString('hex'),
+    unilateralClaim: vhtlc.unilateralClaim().script.toString('hex'),
+    unilateralRefund: vhtlc.unilateralRefund().script.toString('hex'),
+    unilateralRefundWithoutReceiver: vhtlc.unilateralRefundWithoutReceiver().script.toString('hex')
+  };
+  
+  // Output for comparison
+  console.log('TypeScript SDK Script Vectors:');
+  console.log('1. Claim Script:                          ', vectors.claim);
+  console.log('2. Refund Script:                         ', vectors.refund);
+  console.log('3. Refund Without Receiver Script:        ', vectors.refundWithoutReceiver);
+  console.log('4. Unilateral Claim Script:               ', vectors.unilateralClaim);
+  console.log('5. Unilateral Refund Script:              ', vectors.unilateralRefund);
+  console.log('6. Unilateral Refund Without Receiver:    ', vectors.unilateralRefundWithoutReceiver);
+  
+  // Also output as JSON for easy parsing
+  console.log('\n=== JSON Format ===');
+  console.log(JSON.stringify(vectors, null, 2));
+  
+  // Export taproot address for comparison
+  const address = vhtlc.address('testnet'); // or 'mainnet'
+  console.log('\n=== Address ===');
+  console.log('TypeScript SDK Address:', address);
+  
+} catch (error) {
+  console.error('Error generating TypeScript vectors:', error);
+  console.log('\nPlease ensure:');
+  console.log('1. You are running this in the arkade-os/ts-sdk directory');
+  console.log('2. The path to VhtlcScript is correct');
+  console.log('3. All dependencies are installed (npm install)');
+}

ark-lightning/tests/compare_with_ts_sdk.rs

@@ -0,0 +1,134 @@
+/// Comparison tests with TypeScript SDK output
+/// 
+/// To use this test:
+/// 1. Run generate_ts_vectors.js in the arkade-os/ts-sdk repository
+/// 2. Copy the hex output and paste it into the EXPECTED_TS_VECTORS constant below
+/// 3. Run this test to compare our Rust output with TypeScript SDK output
+
+use ark_lightning::vhtlc::{VhtlcOptions, VhtlcScript};
+use bitcoin::{Sequence, XOnlyPublicKey};
+use hex;
+use std::str::FromStr;
+
+// TODO: Replace these with actual values from TypeScript SDK output
+const EXPECTED_TS_VECTORS: &str = r#"{
+  "claim": "REPLACE_WITH_TS_OUTPUT",
+  "refund": "REPLACE_WITH_TS_OUTPUT", 
+  "refundWithoutReceiver": "REPLACE_WITH_TS_OUTPUT",
+  "unilateralClaim": "REPLACE_WITH_TS_OUTPUT",
+  "unilateralRefund": "REPLACE_WITH_TS_OUTPUT",
+  "unilateralRefundWithoutReceiver": "REPLACE_WITH_TS_OUTPUT"
+}"#;
+
+#[test]
+fn compare_rust_vs_typescript_scripts() {
+    // Same test data as used in TypeScript SDK
+    let sender = XOnlyPublicKey::from_str("0192e796452d6df9697c280542e1560557bcf79a347d925895043136225c7cb4").unwrap();
+    let receiver = XOnlyPublicKey::from_str("1e1bb85455fe3f5aed60d101aa4dbdb9e7714f6226769a97a17a5331dadcd53b").unwrap();
+    let server = XOnlyPublicKey::from_str("aad52d58162e9eefeafc7ad8a1cdca8060b5f01df1e7583362d052e266208f88").unwrap();
+    let preimage_hash: [u8; 20] = hex::decode("4d487dd3753a89bc9fe98401d1196523058251fc")
+        .unwrap()
+        .try_into()
+        .unwrap();
+
+    let options = VhtlcOptions {
+        sender,
+        receiver,
+        server,
+        preimage_hash,
+        refund_locktime: 265,
+        unilateral_claim_delay: Sequence::from_height(17),
+        unilateral_refund_delay: Sequence::from_height(144),
+        unilateral_refund_without_receiver_delay: Sequence::from_height(144),
+    };
+
+    let vhtlc = VhtlcScript::new(options).expect("Failed to create VHTLC");
+
+    // Generate Rust script hex values
+    let rust_vectors = serde_json::json!({
+        "claim": hex::encode(vhtlc.claim_script().as_bytes()),
+        "refund": hex::encode(vhtlc.refund_script().as_bytes()),
+        "refundWithoutReceiver": hex::encode(vhtlc.refund_without_receiver_script().as_bytes()),
+        "unilateralClaim": hex::encode(vhtlc.unilateral_claim_script().as_bytes()),
+        "unilateralRefund": hex::encode(vhtlc.unilateral_refund_script().as_bytes()),
+        "unilateralRefundWithoutReceiver": hex::encode(vhtlc.unilateral_refund_without_receiver_script().as_bytes())
+    });
+
+    println!("=== RUST VS TYPESCRIPT SDK COMPARISON ===\n");
+    
+    // Parse expected TypeScript vectors (when available)
+    if EXPECTED_TS_VECTORS.contains("REPLACE_WITH_TS_OUTPUT") {
+        println!("⚠️  TypeScript SDK vectors not yet provided!");
+        println!("Please:");
+        println!("1. Run generate_ts_vectors.js in the arkade-os/ts-sdk repository");
+        println!("2. Copy the JSON output and replace EXPECTED_TS_VECTORS in this test");
+        println!("3. Re-run this test for comparison");
+        
+        println!("\n=== RUST IMPLEMENTATION OUTPUT ===");
+        println!("{}", serde_json::to_string_pretty(&rust_vectors).unwrap());
+        return;
+    }
+
+    let expected: serde_json::Value = serde_json::from_str(EXPECTED_TS_VECTORS)
+        .expect("Failed to parse expected TypeScript vectors");
+
+    println!("Rust Implementation:");
+    println!("{}", serde_json::to_string_pretty(&rust_vectors).unwrap());
+    
+    println!("\nTypeScript SDK Expected:");
+    println!("{}", serde_json::to_string_pretty(&expected).unwrap());
+
+    // Compare each script
+    compare_script("Claim", &rust_vectors["claim"], &expected["claim"]);
+    compare_script("Refund", &rust_vectors["refund"], &expected["refund"]);
+    compare_script("Refund Without Receiver", &rust_vectors["refundWithoutReceiver"], &expected["refundWithoutReceiver"]);
+    compare_script("Unilateral Claim", &rust_vectors["unilateralClaim"], &expected["unilateralClaim"]);
+    compare_script("Unilateral Refund", &rust_vectors["unilateralRefund"], &expected["unilateralRefund"]);
+    compare_script("Unilateral Refund Without Receiver", &rust_vectors["unilateralRefundWithoutReceiver"], &expected["unilateralRefundWithoutReceiver"]);
+}
+
+fn compare_script(name: &str, rust_hex: &serde_json::Value, ts_hex: &serde_json::Value) {
+    let rust_str = rust_hex.as_str().unwrap();
+    let ts_str = ts_hex.as_str().unwrap();
+    
+    println!("\n=== {} SCRIPT COMPARISON ===", name.to_uppercase());
+    
+    if rust_str == ts_str {
+        println!("✅ MATCH: Scripts are identical");
+        return;
+    }
+    
+    println!("❌ MISMATCH:");
+    println!("Rust:       {}", rust_str);
+    println!("TypeScript: {}", ts_str);
+    
+    // Analyze differences
+    if rust_str.len() != ts_str.len() {
+        println!("Length difference: Rust={} bytes, TypeScript={} bytes", rust_str.len()/2, ts_str.len()/2);
+    }
+    
+    // Find first difference
+    for (i, (r, t)) in rust_str.chars().zip(ts_str.chars()).enumerate() {
+        if r != t {
+            println!("First difference at position {}: Rust='{}', TypeScript='{}'", i, r, t);
+            break;
+        }
+    }
+}
+
+#[test]
+#[ignore] // Run manually when you have TypeScript vectors
+fn manual_script_comparison() {
+    // This test can be manually enabled with specific hex values for debugging
+    let rust_claim_hex = "a9144d487dd3753a89bc9fe98401d1196523058251fc8769201e1bb85455fe3f5aed60d101aa4dbdb9e7714f6226769a97a17a5331dadcd53bad20aad52d58162e9eefeafc7ad8a1cdca8060b5f01df1e7583362d052e266208f88ac";
+    let ts_claim_hex = ""; // Paste TypeScript output here
+    
+    if !ts_claim_hex.is_empty() {
+        println!("Comparing claim scripts:");
+        println!("Rust: {}", rust_claim_hex);
+        println!("TS:   {}", ts_claim_hex);
+        assert_eq!(rust_claim_hex, ts_claim_hex, "Claim scripts should match");
+    } else {
+        println!("Please provide TypeScript SDK hex output for comparison");
+    }
+}