align authorize/deactivate/merge/move/split/lockup with native; tighten wire parity + Pinocchio compliance

Author: ghazalassadipour

instructions_dump.txt

@@ -35,7 +35,7 @@ bincode = "1"
 
 [features]
 # Build for the chain (SBF, no_std, real entrypoint, panic handler)
-sbf = ["bpf-entrypoint", "wire_bincode"]
+sbf = ["bpf-entrypoint", "wire_bincode", "compat_derivation_fallback"]
 
 # Controls the entrypoint module inclusion
 bpf-entrypoint = []
@@ -46,7 +46,8 @@ std = ["bincode"]
 
 # Default host/dev: std + NO entrypoint (keeps IDE/cargo happy)
 default = ["std", "no-entrypoint", "wire_bincode"]
-e2e = ["allow-uninitialized-split"]
+e2e = ["allow-uninitialized-split", "compat_derivation_fallback", "compat_loose_decode"]
+compat_derivation_fallback = []
 seed = []
 cu-trace = []
 wire_bincode = []

program/Cargo.toml

@@ -1,11 +0,0 @@
-name,pin,native
-initialize_checked,651,5089
-authorize_checked,1417,9148
-set_lockup_checked,1367,8505
-delegate,1005,12565
-deactivate,917,10643
-split,2270,16048
-withdraw,827,5644
-merge,2834,9274
-move_lamports,3668,8689
-get_minimum_delegation,429,676

program/benchmarks/current.csv

@@ -0,0 +1,2 @@
+pub mod sha256;
+

program/src/crypto/mod.rs

@@ -0,0 +1,124 @@
+#![allow(clippy::needless_range_loop)]
+
+use core::convert::TryInto;
+
+const H0: [u32; 8] = [
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+];
+
+const K: [u32; 64] = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];
+
+#[inline(always)]
+fn rotr(x: u32, n: u32) -> u32 { (x >> n) | (x << (32 - n)) }
+#[inline(always)]
+fn ch(x: u32, y: u32, z: u32) -> u32 { (x & y) ^ (!x & z) }
+#[inline(always)]
+fn maj(x: u32, y: u32, z: u32) -> u32 { (x & y) ^ (x & z) ^ (y & z) }
+#[inline(always)]
+fn big_sigma0(x: u32) -> u32 { rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22) }
+#[inline(always)]
+fn big_sigma1(x: u32) -> u32 { rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25) }
+#[inline(always)]
+fn small_sigma0(x: u32) -> u32 { rotr(x, 7) ^ rotr(x, 18) ^ (x >> 3) }
+#[inline(always)]
+fn small_sigma1(x: u32) -> u32 { rotr(x, 17) ^ rotr(x, 19) ^ (x >> 10) }
+
+// Hash arbitrary bytes using SHA-256 (no_std, small, 64-byte blocks)
+pub fn hash(data: &[u8]) -> [u8; 32] {
+    let bit_len: u64 = (data.len() as u64) * 8;
+    // Padded length: data + 1 + pad + 8, multiple of 64. Our inputs are small; cap to 3 blocks.
+    let mut padded = [0u8; 192];
+    let mut plen = 0usize;
+
+    // Copy data
+    padded[..data.len()].copy_from_slice(data);
+    plen = data.len();
+    // Append 0x80
+    padded[plen] = 0x80; plen += 1;
+    // Compute zero pad so that there are 8 bytes left in the final block
+    let rem = plen % 64;
+    let pad_zeros = if rem <= 56 { 56 - rem } else { 64 + 56 - rem };
+    for i in 0..pad_zeros { padded[plen + i] = 0; }
+    plen += pad_zeros;
+    // Append length in bits (big-endian)
+    let len_bytes = bit_len.to_be_bytes();
+    padded[plen..plen + 8].copy_from_slice(&len_bytes);
+    plen += 8;
+
+    // Initialize hash state
+    let mut h = H0;
+    let mut w = [0u32; 64];
+
+    // Process each 64-byte block
+    for chunk in padded[..plen].chunks_exact(64) {
+        // Prepare message schedule
+        for t in 0..16 {
+            let i = t * 4;
+            w[t] = u32::from_be_bytes(chunk[i..i + 4].try_into().unwrap());
+        }
+        for t in 16..64 {
+            w[t] = small_sigma1(w[t - 2])
+                .wrapping_add(w[t - 7])
+                .wrapping_add(small_sigma0(w[t - 15]))
+                .wrapping_add(w[t - 16]);
+        }
+
+        // Initialize working variables
+        let (mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut hh) =
+            (h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]);
+
+        // Main compression
+        for t in 0..64 {
+            let t1 = hh
+                .wrapping_add(big_sigma1(e))
+                .wrapping_add(ch(e, f, g))
+                .wrapping_add(K[t])
+                .wrapping_add(w[t]);
+            let t2 = big_sigma0(a).wrapping_add(maj(a, b, c));
+            hh = g;
+            g = f;
+            f = e;
+            e = d.wrapping_add(t1);
+            d = c;
+            c = b;
+            b = a;
+            a = t1.wrapping_add(t2);
+        }
+
+        // Update hash state
+        h[0] = h[0].wrapping_add(a);
+        h[1] = h[1].wrapping_add(b);
+        h[2] = h[2].wrapping_add(c);
+        h[3] = h[3].wrapping_add(d);
+        h[4] = h[4].wrapping_add(e);
+        h[5] = h[5].wrapping_add(f);
+        h[6] = h[6].wrapping_add(g);
+        h[7] = h[7].wrapping_add(hh);
+    }
+
+    // Produce output (big-endian)
+    let mut out = [0u8; 32];
+    for (i, v) in h.iter().enumerate() {
+        out[i * 4..i * 4 + 4].copy_from_slice(&v.to_be_bytes());
+    }
+    out
+}
+