Merge #840: ci: delete broken wasm job

apoelstra · apoelstra · commit b111209b9447 · 2025-08-30T22:34:37.000Z
471cd63 ci: delete broken WASM job (Andrew Poelstra) 0d0263e secp-sys: update raw pointer deref syntax in fuzz version of the crate (Andrew Poelstra) d477198 ci: remove now-removed 'hashes' feature from tests (Andrew Poelstra) Pull request description: The incorrectly-indented wasm test from #819 is causing Github to silently disable all of our checks. If you click through to the "Actions" tab of this repo you can see it failing (with a "syntax error on line 1" nonsense error). For example https://github.com/apoelstra/rust-secp256k1/actions/runs/17178718613/workflow Delete the test, and also fix everything else that broke in the meantime. ACKs for top commit: tcharding: ACK 471cd63 Tree-SHA512: b52f86a203cb08f66ecbe2afc6e85d973193373da9d5a8bc7e10ca4f9b0991a69cf30e851b439ad6c463b468d10a35c87540fabc6b9ed877fadd82df74221fe8
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
@@ -253,20 +253,6 @@ jobs:
       - name: "Run test on i686"
         run: cargo test --target i686-unknown-linux-gnu
 
- WASM:
-   name: WASM - stable toolchain
-   runs-on: ubuntu-latest
-   strategy:
-     fail-fast: false
-     # Note we do not use the recent lock file for wasm testing.
-   steps:
-     - name: "Checkout repo"
-       uses: actions/checkout@v4
-     - name: "Select toolchain"
-       uses: dtolnay/rust-toolchain@stable
-     - name: "Run wasm script"
-       run: ./contrib/wasm.sh
-
   NoStd:                      # 1 job, run no-std test from script.
     name: no-std - nightly toolchain
     needs: Prepare
diff --git a/contrib/test_vars.sh b/contrib/test_vars.sh
@@ -5,10 +5,10 @@
 # shellcheck disable=SC2034
 
 # Test all these features with "std" enabled.
-FEATURES_WITH_STD="hashes global-context global-context-less-secure lowmemory rand recovery serde"
+FEATURES_WITH_STD="global-context global-context-less-secure lowmemory rand recovery serde"
 
 # Test all these features without "std" enabled.
-FEATURES_WITHOUT_STD="hashes global-context global-context-less-secure lowmemory rand recovery serde alloc"
+FEATURES_WITHOUT_STD="global-context global-context-less-secure lowmemory rand recovery serde alloc"
 
 # Run these examples.
-EXAMPLES="sign_verify:hashes,std sign_verify_recovery:hashes,std,recovery generate_keys:rand,std"
+EXAMPLES="sign_verify:std sign_verify_recovery:std,recovery generate_keys:rand,std"
diff --git a/secp256k1-sys/src/lib.rs b/secp256k1-sys/src/lib.rs
@@ -1617,21 +1617,21 @@ mod fuzz_dummy {
     /// Checks that pk != 0xffff...ffff and pk[1..32] == pk[33..64]
     unsafe fn test_pk_validate(cx: *const Context, pk: *const PublicKey) -> c_int {
         check_context_flags(cx, 0);
-        if (*pk).0[1..32] != (*pk).0[33..64]
-            || ((*pk).0[32] != 0 && (*pk).0[32] != 0xff)
-            || secp256k1_ec_seckey_verify(cx, (*pk).0[0..32].as_ptr()) == 0
+        if (&*pk).0[1..32] != (&*pk).0[33..64]
+            || ((*pk).0[32] != 0 && (&*pk).0[32] != 0xff)
+            || secp256k1_ec_seckey_verify(cx, (&*pk).0[0..32].as_ptr()) == 0
         {
             0
         } else {
             1
         }
     }
     unsafe fn test_cleanup_pk(pk: *mut PublicKey) {
-        (*pk).0[32..].copy_from_slice(&(*pk).0[..32]);
-        if (*pk).0[32] <= 0x7f {
-            (*pk).0[32] = 0;
+        (&mut *pk).0[32..].copy_from_slice(&(&*pk).0[..32]);
+        if (&*pk).0[32] <= 0x7f {
+            (&mut *pk).0[32] = 0;
         } else {
-            (*pk).0[32] = 0xff;
+            (&mut *pk).0[32] = 0xff;
         }
     }
 
@@ -1648,8 +1648,8 @@ mod fuzz_dummy {
                 if *input != 2 && *input != 3 {
                     0
                 } else {
-                    ptr::copy(input.offset(1), (*pk).0[0..32].as_mut_ptr(), 32);
-                    ptr::copy(input.offset(2), (*pk).0[33..64].as_mut_ptr(), 31);
+                    ptr::copy(input.offset(1), (&mut *pk).0[0..32].as_mut_ptr(), 32);
+                    ptr::copy(input.offset(2), (&mut *pk).0[33..64].as_mut_ptr(), 31);
                     if *input == 3 {
                         (*pk).0[32] = 0xff;
                     } else {
@@ -1661,7 +1661,7 @@ mod fuzz_dummy {
                 if *input != 4 && *input != 6 && *input != 7 {
                     0
                 } else {
-                    ptr::copy(input.offset(1), (*pk).0.as_mut_ptr(), 64);
+                    ptr::copy(input.offset(1), (&mut *pk).0.as_mut_ptr(), 64);
                     test_cleanup_pk(pk);
                     test_pk_validate(cx, pk)
                 },
@@ -1708,7 +1708,7 @@ mod fuzz_dummy {
         if secp256k1_ec_seckey_verify(cx, sk) != 1 {
             return 0;
         }
-        ptr::copy(sk, (*pk).0[0..32].as_mut_ptr(), 32);
+        ptr::copy(sk, (&mut *pk).0[0..32].as_mut_ptr(), 32);
         test_cleanup_pk(pk);
         assert_eq!(test_pk_validate(cx, pk), 1);
         1
@@ -1717,7 +1717,7 @@ mod fuzz_dummy {
     pub unsafe fn secp256k1_ec_pubkey_negate(cx: *const Context, pk: *mut PublicKey) -> c_int {
         check_context_flags(cx, 0);
         assert_eq!(test_pk_validate(cx, pk), 1);
-        if secp256k1_ec_seckey_negate(cx, (*pk).0[..32].as_mut_ptr()) != 1 {
+        if secp256k1_ec_seckey_negate(cx, (&mut *pk).0[..32].as_mut_ptr()) != 1 {
             return 0;
         }
         test_cleanup_pk(pk);
@@ -1733,7 +1733,7 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, SECP256K1_START_VERIFY);
         assert_eq!(test_pk_validate(cx, pk), 1);
-        if secp256k1_ec_seckey_tweak_add(cx, (*pk).0[..32].as_mut_ptr(), tweak) != 1 {
+        if secp256k1_ec_seckey_tweak_add(cx, (&mut *pk).0[..32].as_mut_ptr(), tweak) != 1 {
             return 0;
         }
         test_cleanup_pk(pk);
@@ -1749,7 +1749,7 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, 0);
         assert_eq!(test_pk_validate(cx, pk), 1);
-        if secp256k1_ec_seckey_tweak_mul(cx, (*pk).0[..32].as_mut_ptr(), tweak) != 1 {
+        if secp256k1_ec_seckey_tweak_mul(cx, (&mut *pk).0[..32].as_mut_ptr(), tweak) != 1 {
             return 0;
         }
         test_cleanup_pk(pk);
@@ -1770,8 +1770,8 @@ mod fuzz_dummy {
             assert_eq!(test_pk_validate(cx, *ins.offset(i as isize)), 1);
             if secp256k1_ec_seckey_tweak_add(
                 cx,
-                (*out).0[..32].as_mut_ptr(),
-                (**ins.offset(i as isize)).0[..32].as_ptr(),
+                (&mut *out).0[..32].as_mut_ptr(),
+                (&**ins.offset(i as isize)).0[..32].as_ptr(),
             ) != 1
             {
                 return 0;
@@ -1798,7 +1798,7 @@ mod fuzz_dummy {
         }
 
         let scalar_slice = slice::from_raw_parts(scalar, 32);
-        let pk_slice = &(*point).0[..32];
+        let pk_slice = &(&*point).0[..32];
 
         let mut res_arr = [0u8; 32];
         for i in 0..32 {
@@ -1827,7 +1827,7 @@ mod fuzz_dummy {
         // Actually verify
         let sig_sl = slice::from_raw_parts(sig as *const u8, 64);
         let msg_sl = slice::from_raw_parts(msg32 as *const u8, 32);
-        if &sig_sl[..32] == msg_sl && sig_sl[32..] == (*pk).0[0..32] {
+        if &sig_sl[..32] == msg_sl && sig_sl[32..] == (&*pk).0[0..32] {
             1
         } else {
             0
@@ -1873,7 +1873,7 @@ mod fuzz_dummy {
         // Actually verify
         let sig_sl = slice::from_raw_parts(sig64 as *const u8, 64);
         let msg_sl = slice::from_raw_parts(msg32 as *const u8, msglen);
-        if &sig_sl[..32] == msg_sl && sig_sl[32..] == (*pubkey).0[..32] {
+        if &sig_sl[..32] == msg_sl && sig_sl[32..] == (&*pubkey).0[..32] {
             1
         } else {
             0
@@ -1932,8 +1932,8 @@ mod fuzz_dummy {
         }
 
         let seckey_slice = slice::from_raw_parts(seckey, 32);
-        (*keypair).0[..32].copy_from_slice(seckey_slice);
-        (*keypair).0[32..].copy_from_slice(&pk.0);
+        (&mut *keypair).0[..32].copy_from_slice(seckey_slice);
+        (&mut *keypair).0[32..].copy_from_slice(&pk.0);
         1
     }
 
@@ -1944,8 +1944,8 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, 0);
         let inslice = slice::from_raw_parts(input32, 32);
-        (*pubkey).0[..32].copy_from_slice(inslice);
-        (*pubkey).0[32..].copy_from_slice(inslice);
+        (&mut *pubkey).0[..32].copy_from_slice(inslice);
+        (&mut *pubkey).0[32..].copy_from_slice(inslice);
         test_cleanup_pk(pubkey as *mut PublicKey);
         test_pk_validate(cx, pubkey as *mut PublicKey)
     }
@@ -1957,7 +1957,7 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, 0);
         let outslice = slice::from_raw_parts_mut(output32, 32);
-        outslice.copy_from_slice(&(*pubkey).0[..32]);
+        outslice.copy_from_slice(&(&*pubkey).0[..32]);
         1
     }
 
@@ -1971,7 +1971,7 @@ mod fuzz_dummy {
         if !pk_parity.is_null() {
             *pk_parity = ((*pubkey).0[32] == 0).into();
         }
-        (*xonly_pubkey).0.copy_from_slice(&(*pubkey).0);
+        (*xonly_pubkey).0.copy_from_slice(&(&*pubkey).0);
         assert_eq!(test_pk_validate(cx, pubkey), 1);
         1
     }
@@ -1995,9 +1995,9 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, 0);
         if !pk_parity.is_null() {
-            *pk_parity = ((*keypair).0[64] == 0).into();
+            *pk_parity = ((&*keypair).0[64] == 0).into();
         }
-        (*pubkey).0.copy_from_slice(&(*keypair).0[32..]);
+        (&mut *pubkey).0.copy_from_slice(&(&*keypair).0[32..]);
         1
     }
 
@@ -2008,13 +2008,13 @@ mod fuzz_dummy {
     ) -> c_int {
         check_context_flags(cx, SECP256K1_START_VERIFY);
         let mut pk = PublicKey::new();
-        pk.0.copy_from_slice(&(*keypair).0[32..]);
+        pk.0.copy_from_slice(&(&*keypair).0[32..]);
         let mut sk = [0u8; 32];
-        sk.copy_from_slice(&(*keypair).0[..32]);
+        sk.copy_from_slice(&(&*keypair).0[..32]);
         assert_eq!(secp256k1_ec_pubkey_tweak_add(cx, &mut pk, tweak32), 1);
         assert_eq!(secp256k1_ec_seckey_tweak_add(cx, (&mut sk[..]).as_mut_ptr(), tweak32), 1);
-        (*keypair).0[..32].copy_from_slice(&sk);
-        (*keypair).0[32..].copy_from_slice(&pk.0);
+        (&mut *keypair).0[..32].copy_from_slice(&sk);
+        (&mut *keypair).0[32..].copy_from_slice(&pk.0);
         1
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1617,21 +1617,21 @@ mod fuzz_dummy {`
`1617`	`1617`	`/// Checks that pk != 0xffff...ffff and pk[1..32] == pk[33..64]`
`1618`	`1618`	`unsafe fn test_pk_validate(cx: const Context, pk: const PublicKey) -> c_int {`
`1619`	`1619`	`check_context_flags(cx, 0);`
`1620`		`- if (pk).0[1..32] != (pk).0[33..64]`
`1621`		`- \|\| ((pk).0[32] != 0 && (pk).0[32] != 0xff)`
`1622`		`- \|\| secp256k1_ec_seckey_verify(cx, (*pk).0[0..32].as_ptr()) == 0`
	`1620`	`+ if (&pk).0[1..32] != (&pk).0[33..64]`
	`1621`	`+ \|\| ((pk).0[32] != 0 && (&pk).0[32] != 0xff)`
	`1622`	`+ \|\| secp256k1_ec_seckey_verify(cx, (&*pk).0[0..32].as_ptr()) == 0`
`1623`	`1623`	`{`
`1624`	`1624`	`0`
`1625`	`1625`	`} else {`
`1626`	`1626`	`1`
`1627`	`1627`	`}`
`1628`	`1628`	`}`
`1629`	`1629`	`unsafe fn test_cleanup_pk(pk: *mut PublicKey) {`
`1630`		`- (pk).0[32..].copy_from_slice(&(pk).0[..32]);`
`1631`		`- if (*pk).0[32] <= 0x7f {`
`1632`		`- (*pk).0[32] = 0;`
	`1630`	`+ (&mut pk).0[32..].copy_from_slice(&(&pk).0[..32]);`
	`1631`	`+ if (&*pk).0[32] <= 0x7f {`
	`1632`	`+ (&mut *pk).0[32] = 0;`
`1633`	`1633`	`} else {`
`1634`		`- (*pk).0[32] = 0xff;`
	`1634`	`+ (&mut *pk).0[32] = 0xff;`
`1635`	`1635`	`}`
`1636`	`1636`	`}`
`1637`	`1637`
`@@ -1648,8 +1648,8 @@ mod fuzz_dummy {`
`1648`	`1648`	`if input != 2 && input != 3 {`
`1649`	`1649`	`0`
`1650`	`1650`	`} else {`
`1651`		`- ptr::copy(input.offset(1), (*pk).0[0..32].as_mut_ptr(), 32);`
`1652`		`- ptr::copy(input.offset(2), (*pk).0[33..64].as_mut_ptr(), 31);`
	`1651`	`+ ptr::copy(input.offset(1), (&mut *pk).0[0..32].as_mut_ptr(), 32);`
	`1652`	`+ ptr::copy(input.offset(2), (&mut *pk).0[33..64].as_mut_ptr(), 31);`
`1653`	`1653`	`if *input == 3 {`
`1654`	`1654`	`(*pk).0[32] = 0xff;`
`1655`	`1655`	`} else {`
`@@ -1661,7 +1661,7 @@ mod fuzz_dummy {`
`1661`	`1661`	`if input != 4 && input != 6 && *input != 7 {`
`1662`	`1662`	`0`
`1663`	`1663`	`} else {`
`1664`		`- ptr::copy(input.offset(1), (*pk).0.as_mut_ptr(), 64);`
	`1664`	`+ ptr::copy(input.offset(1), (&mut *pk).0.as_mut_ptr(), 64);`
`1665`	`1665`	`test_cleanup_pk(pk);`
`1666`	`1666`	`test_pk_validate(cx, pk)`
`1667`	`1667`	`},`
`@@ -1708,7 +1708,7 @@ mod fuzz_dummy {`
`1708`	`1708`	`if secp256k1_ec_seckey_verify(cx, sk) != 1 {`
`1709`	`1709`	`return 0;`
`1710`	`1710`	`}`
`1711`		`- ptr::copy(sk, (*pk).0[0..32].as_mut_ptr(), 32);`
	`1711`	`+ ptr::copy(sk, (&mut *pk).0[0..32].as_mut_ptr(), 32);`
`1712`	`1712`	`test_cleanup_pk(pk);`
`1713`	`1713`	`assert_eq!(test_pk_validate(cx, pk), 1);`
`1714`	`1714`	`1`
`@@ -1717,7 +1717,7 @@ mod fuzz_dummy {`
`1717`	`1717`	`pub unsafe fn secp256k1_ec_pubkey_negate(cx: const Context, pk: mut PublicKey) -> c_int {`
`1718`	`1718`	`check_context_flags(cx, 0);`
`1719`	`1719`	`assert_eq!(test_pk_validate(cx, pk), 1);`
`1720`		`- if secp256k1_ec_seckey_negate(cx, (*pk).0[..32].as_mut_ptr()) != 1 {`
	`1720`	`+ if secp256k1_ec_seckey_negate(cx, (&mut *pk).0[..32].as_mut_ptr()) != 1 {`
`1721`	`1721`	`return 0;`
`1722`	`1722`	`}`
`1723`	`1723`	`test_cleanup_pk(pk);`
`@@ -1733,7 +1733,7 @@ mod fuzz_dummy {`
`1733`	`1733`	`) -> c_int {`
`1734`	`1734`	`check_context_flags(cx, SECP256K1_START_VERIFY);`
`1735`	`1735`	`assert_eq!(test_pk_validate(cx, pk), 1);`
`1736`		`- if secp256k1_ec_seckey_tweak_add(cx, (*pk).0[..32].as_mut_ptr(), tweak) != 1 {`
	`1736`	`+ if secp256k1_ec_seckey_tweak_add(cx, (&mut *pk).0[..32].as_mut_ptr(), tweak) != 1 {`
`1737`	`1737`	`return 0;`
`1738`	`1738`	`}`
`1739`	`1739`	`test_cleanup_pk(pk);`
`@@ -1749,7 +1749,7 @@ mod fuzz_dummy {`
`1749`	`1749`	`) -> c_int {`
`1750`	`1750`	`check_context_flags(cx, 0);`
`1751`	`1751`	`assert_eq!(test_pk_validate(cx, pk), 1);`
`1752`		`- if secp256k1_ec_seckey_tweak_mul(cx, (*pk).0[..32].as_mut_ptr(), tweak) != 1 {`
	`1752`	`+ if secp256k1_ec_seckey_tweak_mul(cx, (&mut *pk).0[..32].as_mut_ptr(), tweak) != 1 {`
`1753`	`1753`	`return 0;`
`1754`	`1754`	`}`
`1755`	`1755`	`test_cleanup_pk(pk);`
`@@ -1770,8 +1770,8 @@ mod fuzz_dummy {`
`1770`	`1770`	`assert_eq!(test_pk_validate(cx, *ins.offset(i as isize)), 1);`
`1771`	`1771`	`if secp256k1_ec_seckey_tweak_add(`
`1772`	`1772`	`cx,`
`1773`		`- (*out).0[..32].as_mut_ptr(),`
`1774`		`- (**ins.offset(i as isize)).0[..32].as_ptr(),`
	`1773`	`+ (&mut *out).0[..32].as_mut_ptr(),`
	`1774`	`+ (&**ins.offset(i as isize)).0[..32].as_ptr(),`
`1775`	`1775`	`) != 1`
`1776`	`1776`	`{`
`1777`	`1777`	`return 0;`
`@@ -1798,7 +1798,7 @@ mod fuzz_dummy {`
`1798`	`1798`	`}`
`1799`	`1799`
`1800`	`1800`	`let scalar_slice = slice::from_raw_parts(scalar, 32);`
`1801`		`- let pk_slice = &(*point).0[..32];`
	`1801`	`+ let pk_slice = &(&*point).0[..32];`
`1802`	`1802`
`1803`	`1803`	`let mut res_arr = [0u8; 32];`
`1804`	`1804`	`for i in 0..32 {`
`@@ -1827,7 +1827,7 @@ mod fuzz_dummy {`
`1827`	`1827`	`// Actually verify`
`1828`	`1828`	`let sig_sl = slice::from_raw_parts(sig as *const u8, 64);`
`1829`	`1829`	`let msg_sl = slice::from_raw_parts(msg32 as *const u8, 32);`
`1830`		`- if &sig_sl[..32] == msg_sl && sig_sl[32..] == (*pk).0[0..32] {`
	`1830`	`+ if &sig_sl[..32] == msg_sl && sig_sl[32..] == (&*pk).0[0..32] {`
`1831`	`1831`	`1`
`1832`	`1832`	`} else {`
`1833`	`1833`	`0`
`@@ -1873,7 +1873,7 @@ mod fuzz_dummy {`
`1873`	`1873`	`// Actually verify`
`1874`	`1874`	`let sig_sl = slice::from_raw_parts(sig64 as *const u8, 64);`
`1875`	`1875`	`let msg_sl = slice::from_raw_parts(msg32 as *const u8, msglen);`
`1876`		`- if &sig_sl[..32] == msg_sl && sig_sl[32..] == (*pubkey).0[..32] {`
	`1876`	`+ if &sig_sl[..32] == msg_sl && sig_sl[32..] == (&*pubkey).0[..32] {`
`1877`	`1877`	`1`
`1878`	`1878`	`} else {`
`1879`	`1879`	`0`
`@@ -1932,8 +1932,8 @@ mod fuzz_dummy {`
`1932`	`1932`	`}`
`1933`	`1933`
`1934`	`1934`	`let seckey_slice = slice::from_raw_parts(seckey, 32);`
`1935`		`- (*keypair).0[..32].copy_from_slice(seckey_slice);`
`1936`		`- (*keypair).0[32..].copy_from_slice(&pk.0);`
	`1935`	`+ (&mut *keypair).0[..32].copy_from_slice(seckey_slice);`
	`1936`	`+ (&mut *keypair).0[32..].copy_from_slice(&pk.0);`
`1937`	`1937`	`1`
`1938`	`1938`	`}`
`1939`	`1939`
`@@ -1944,8 +1944,8 @@ mod fuzz_dummy {`
`1944`	`1944`	`) -> c_int {`
`1945`	`1945`	`check_context_flags(cx, 0);`
`1946`	`1946`	`let inslice = slice::from_raw_parts(input32, 32);`
`1947`		`- (*pubkey).0[..32].copy_from_slice(inslice);`
`1948`		`- (*pubkey).0[32..].copy_from_slice(inslice);`
	`1947`	`+ (&mut *pubkey).0[..32].copy_from_slice(inslice);`
	`1948`	`+ (&mut *pubkey).0[32..].copy_from_slice(inslice);`
`1949`	`1949`	`test_cleanup_pk(pubkey as *mut PublicKey);`
`1950`	`1950`	`test_pk_validate(cx, pubkey as *mut PublicKey)`
`1951`	`1951`	`}`
`@@ -1957,7 +1957,7 @@ mod fuzz_dummy {`
`1957`	`1957`	`) -> c_int {`
`1958`	`1958`	`check_context_flags(cx, 0);`
`1959`	`1959`	`let outslice = slice::from_raw_parts_mut(output32, 32);`
`1960`		`- outslice.copy_from_slice(&(*pubkey).0[..32]);`
	`1960`	`+ outslice.copy_from_slice(&(&*pubkey).0[..32]);`
`1961`	`1961`	`1`
`1962`	`1962`	`}`
`1963`	`1963`
`@@ -1971,7 +1971,7 @@ mod fuzz_dummy {`
`1971`	`1971`	`if !pk_parity.is_null() {`
`1972`	`1972`	`pk_parity = ((pubkey).0[32] == 0).into();`
`1973`	`1973`	`}`
`1974`		`- (xonly_pubkey).0.copy_from_slice(&(pubkey).0);`
	`1974`	`+ (xonly_pubkey).0.copy_from_slice(&(&pubkey).0);`
`1975`	`1975`	`assert_eq!(test_pk_validate(cx, pubkey), 1);`
`1976`	`1976`	`1`
`1977`	`1977`	`}`
`@@ -1995,9 +1995,9 @@ mod fuzz_dummy {`
`1995`	`1995`	`) -> c_int {`
`1996`	`1996`	`check_context_flags(cx, 0);`
`1997`	`1997`	`if !pk_parity.is_null() {`
`1998`		`- pk_parity = ((keypair).0[64] == 0).into();`
	`1998`	`+ pk_parity = ((&keypair).0[64] == 0).into();`
`1999`	`1999`	`}`
`2000`		`- (pubkey).0.copy_from_slice(&(keypair).0[32..]);`
	`2000`	`+ (&mut pubkey).0.copy_from_slice(&(&keypair).0[32..]);`
`2001`	`2001`	`1`
`2002`	`2002`	`}`
`2003`	`2003`
`@@ -2008,13 +2008,13 @@ mod fuzz_dummy {`
`2008`	`2008`	`) -> c_int {`
`2009`	`2009`	`check_context_flags(cx, SECP256K1_START_VERIFY);`
`2010`	`2010`	`let mut pk = PublicKey::new();`
`2011`		`- pk.0.copy_from_slice(&(*keypair).0[32..]);`
	`2011`	`+ pk.0.copy_from_slice(&(&*keypair).0[32..]);`
`2012`	`2012`	`let mut sk = [0u8; 32];`
`2013`		`- sk.copy_from_slice(&(*keypair).0[..32]);`
	`2013`	`+ sk.copy_from_slice(&(&*keypair).0[..32]);`
`2014`	`2014`	`assert_eq!(secp256k1_ec_pubkey_tweak_add(cx, &mut pk, tweak32), 1);`
`2015`	`2015`	`assert_eq!(secp256k1_ec_seckey_tweak_add(cx, (&mut sk[..]).as_mut_ptr(), tweak32), 1);`
`2016`		`- (*keypair).0[..32].copy_from_slice(&sk);`
`2017`		`- (*keypair).0[32..].copy_from_slice(&pk.0);`
	`2016`	`+ (&mut *keypair).0[..32].copy_from_slice(&sk);`
	`2017`	`+ (&mut *keypair).0[32..].copy_from_slice(&pk.0);`
`2018`	`2018`	`1`
`2019`	`2019`	`}`
`2020`	`2020`