From 7f8a8485b5b2d24f20355cbc17d6d57e7cc62a29 Mon Sep 17 00:00:00 2001
From: Paul <3682187+PaulLaux@users.noreply.github.com>
Date: Wed, 30 Mar 2022 19:10:55 +0300
Subject: [PATCH 01/17] Circleci project setup (#1)

* Added .circleci/config.yml
---
 .circleci/config.yml | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 .circleci/config.yml

diff --git a/.circleci/config.yml b/.circleci/config.yml
new file mode 100644
index 000000000..153b55131
--- /dev/null
+++ b/.circleci/config.yml
@@ -0,0 +1,29 @@
+# Use the latest 2.1 version of CircleCI pipeline process engine.
+# See: https://circleci.com/docs/2.0/configuration-reference
+version: 2.1
+
+# Define a job to be invoked later in a workflow.
+# See: https://circleci.com/docs/2.0/configuration-reference/#jobs
+jobs:
+  cargo-test:
+    # Specify the execution environment. You can specify an image from Dockerhub or use one of our Convenience Images from CircleCI's Developer Hub.
+    # See: https://circleci.com/docs/2.0/configuration-reference/#docker-machine-macos-windows-executor
+    docker:
+      - image: cimg/rust:1.59.0
+    # Add steps to the job
+    # See: https://circleci.com/docs/2.0/configuration-reference/#steps
+    steps:
+      - checkout
+      - run:
+          name: "cargo test"
+          command: |
+            cargo version;
+            cargo test;
+          
+
+# Invoke jobs via workflows
+# See: https://circleci.com/docs/2.0/configuration-reference/#workflows
+workflows:
+  build-and-test:
+    jobs:
+      - cargo-test

From 1328c622abe164adb12f93d528576e0c6504f78a Mon Sep 17 00:00:00 2001
From: Daniel Benarroch <danielbenarroch92@gmail.com>
Date: Tue, 14 Jun 2022 17:33:34 +0200
Subject: [PATCH 02/17] issuer keys implementation (#5)

Implements the issuer keys as

    IssuerAuthorizingKey -> isk
    IssuerVerifyingKey -> ik

Test vectors generated with zcash_test_vectors repo
---
 src/keys.rs              | 113 ++++++++++++++++++++++++++++++++++-----
 src/spec/prf_expand.rs   |   2 +
 src/test_vectors/keys.rs | 102 +++++++++++++++++++++++++++++++++++
 3 files changed, 205 insertions(+), 12 deletions(-)

diff --git a/src/keys.rs b/src/keys.rs
index a7856f915..16c63b42e 100644
--- a/src/keys.rs
+++ b/src/keys.rs
@@ -18,7 +18,7 @@ use zcash_note_encryption::EphemeralKeyBytes;
 
 use crate::{
     address::Address,
-    primitives::redpallas::{self, SpendAuth},
+    primitives::redpallas::{self, SpendAuth, VerificationKey},
     spec::{
         commit_ivk, diversify_hash, extract_p, ka_orchard, ka_orchard_prepared, prf_nf, to_base,
         to_scalar, NonIdentityPallasPoint, NonZeroPallasBase, NonZeroPallasScalar,
@@ -189,21 +189,104 @@ impl SpendValidatingKey {
     pub(crate) fn from_bytes(bytes: &[u8]) -> Option<Self> {
         <[u8; 32]>::try_from(bytes)
             .ok()
-            .and_then(|b| {
-                // Structural validity checks for ak_P:
-                // - The point must not be the identity
-                //   (which for Pallas is canonically encoded as all-zeroes).
-                // - The sign of the y-coordinate must be positive.
-                if b != [0; 32] && b[31] & 0x80 == 0 {
-                    <redpallas::VerificationKey<SpendAuth>>::try_from(b).ok()
-                } else {
-                    None
-                }
-            })
+            .and_then(check_structural_validity)
             .map(SpendValidatingKey)
     }
 }
 
+/// An issuer authorizing key, used to create issuer authorization signatures.
+/// This type enforces that the corresponding public point (ik^ℙ) has ỹ = 0.
+///
+/// $\mathsf{isk}$ as defined in
+/// [Zcash Protocol Spec § 4.2.3: Orchard Key Components][orchardkeycomponents].
+///
+/// [orchardkeycomponents]: https://zips.z.cash/protocol/nu5.pdf#orchardkeycomponents
+#[derive(Clone, Debug)]
+pub struct IssuerAuthorizingKey(redpallas::SigningKey<SpendAuth>);
+
+impl IssuerAuthorizingKey {
+    /// Derives isk from sk. Internal use only, does not enforce all constraints.
+    fn derive_inner(sk: &SpendingKey) -> pallas::Scalar {
+        to_scalar(PrfExpand::ZsaIsk.expand(&sk.0))
+    }
+}
+
+impl From<&SpendingKey> for IssuerAuthorizingKey {
+    fn from(sk: &SpendingKey) -> Self {
+        let isk = Self::derive_inner(sk);
+        // IssuerSigningKey cannot be constructed such that this assertion would fail.
+        assert!(!bool::from(isk.is_zero()));
+        let ret = IssuerAuthorizingKey(isk.to_repr().try_into().unwrap());
+        // If the last bit of repr_P(ik) is 1, negate isk.
+        if (<[u8; 32]>::from(IssuerValidatingKey::from(&ret).0)[31] >> 7) == 1 {
+            IssuerAuthorizingKey((-isk).to_repr().try_into().unwrap())
+        } else {
+            ret
+        }
+    }
+}
+
+/// A key used to validate issuer authorization signatures.
+///
+/// Defined in [Zcash Protocol Spec § 4.2.3: Orchard Key Components][orchardkeycomponents].
+/// Note that this is $\mathsf{ik}^\mathbb{P}$, which by construction is equivalent to
+/// $\mathsf{ik}$ but stored here as a RedPallas verification key.
+///
+/// [orchardkeycomponents]: https://zips.z.cash/protocol/nu5.pdf#orchardkeycomponents
+#[derive(Debug, Clone, PartialOrd, Ord)]
+pub struct IssuerValidatingKey(redpallas::VerificationKey<SpendAuth>);
+impl From<&IssuerAuthorizingKey> for IssuerValidatingKey {
+    fn from(isk: &IssuerAuthorizingKey) -> Self {
+        IssuerValidatingKey((&isk.0).into())
+    }
+}
+
+impl From<&IssuerValidatingKey> for pallas::Point {
+    fn from(issuer_validating_key: &IssuerValidatingKey) -> pallas::Point {
+        pallas::Point::from_bytes(&(&issuer_validating_key.0).into()).unwrap()
+    }
+}
+
+impl PartialEq for IssuerValidatingKey {
+    fn eq(&self, other: &Self) -> bool {
+        <[u8; 32]>::from(&self.0).eq(&<[u8; 32]>::from(&other.0))
+    }
+}
+
+impl Eq for IssuerValidatingKey {}
+
+impl IssuerValidatingKey {
+    /// Converts this spend validating key to its serialized form,
+    /// I2LEOSP_256(ik).
+    pub(crate) fn to_bytes(&self) -> [u8; 32] {
+        // This is correct because the wrapped point must have ỹ = 0, and
+        // so the point repr is the same as I2LEOSP of its x-coordinate.
+        <[u8; 32]>::from(&self.0)
+    }
+
+    pub(crate) fn from_bytes(bytes: &[u8]) -> Option<Self> {
+        <[u8; 32]>::try_from(bytes)
+            .ok()
+            .and_then(check_structural_validity)
+            .map(IssuerValidatingKey)
+    }
+}
+
+/// A function to check structural validity of the validating keys for authorizing transfers and
+/// issuing assets
+/// Structural validity checks for ik_P:
+///  - The point must not be the identity (which for Pallas is canonically encoded as all-zeroes).
+///  - The sign of the y-coordinate must be positive.
+fn check_structural_validity(
+    verification_key_bytes: [u8; 32],
+) -> Option<VerificationKey<SpendAuth>> {
+    if verification_key_bytes != [0; 32] && verification_key_bytes[31] & 0x80 == 0 {
+        <redpallas::VerificationKey<SpendAuth>>::try_from(verification_key_bytes).ok()
+    } else {
+        None
+    }
+}
+
 /// A key used to derive [`Nullifier`]s from [`Note`]s.
 ///
 /// $\mathsf{nk}$ as defined in [Zcash Protocol Spec § 4.2.3: Orchard Key Components][orchardkeycomponents].
@@ -1060,9 +1143,15 @@ mod tests {
             let ask: SpendAuthorizingKey = (&sk).into();
             assert_eq!(<[u8; 32]>::from(&ask.0), tv.ask);
 
+            let isk: IssuerAuthorizingKey = (&sk).into();
+            assert_eq!(<[u8; 32]>::from(&isk.0), tv.isk);
+
             let ak: SpendValidatingKey = (&ask).into();
             assert_eq!(<[u8; 32]>::from(ak.0), tv.ak);
 
+            let ik: IssuerValidatingKey = (&isk).into();
+            assert_eq!(<[u8; 32]>::from(ik.0), tv.ik);
+
             let nk: NullifierDerivingKey = (&sk).into();
             assert_eq!(nk.0.to_repr(), tv.nk);
 
diff --git a/src/spec/prf_expand.rs b/src/spec/prf_expand.rs
index e2f95e7ff..fa7881889 100644
--- a/src/spec/prf_expand.rs
+++ b/src/spec/prf_expand.rs
@@ -10,6 +10,7 @@ pub(crate) enum PrfExpand {
     OrchardNk,
     OrchardRivk,
     Psi,
+    ZsaIsk,
     OrchardZip32Child,
     OrchardDkOvk,
     OrchardRivkInternal,
@@ -24,6 +25,7 @@ impl PrfExpand {
             Self::OrchardNk => 0x07,
             Self::OrchardRivk => 0x08,
             Self::Psi => 0x09,
+            Self::ZsaIsk => 0x0a,
             Self::OrchardZip32Child => 0x81,
             Self::OrchardDkOvk => 0x82,
             Self::OrchardRivkInternal => 0x83,
diff --git a/src/test_vectors/keys.rs b/src/test_vectors/keys.rs
index 39d7dc00d..35cc1acbf 100644
--- a/src/test_vectors/keys.rs
+++ b/src/test_vectors/keys.rs
@@ -4,6 +4,8 @@ pub(crate) struct TestVector {
     pub(crate) sk: [u8; 32],
     pub(crate) ask: [u8; 32],
     pub(crate) ak: [u8; 32],
+    pub(crate) isk: [u8; 32],
+    pub(crate) ik: [u8; 32],
     pub(crate) nk: [u8; 32],
     pub(crate) rivk: [u8; 32],
     pub(crate) ivk: [u8; 32],
@@ -41,6 +43,16 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x12, 0x8b, 0x9a, 0x14, 0x0d, 0x5e, 0x07, 0xc1, 0x51, 0x72, 0x1d, 0xc1, 0x6d, 0x25,
                 0xd4, 0xe2, 0x0f, 0x15,
             ],
+            isk: [
+                0x95, 0x4a, 0x86, 0xc7, 0xa7, 0x15, 0x53, 0xfa, 0x6c, 0x8b, 0x67, 0x58, 0x54, 0x26,
+                0x8e, 0xa5, 0x4c, 0x51, 0xfb, 0x17, 0xd8, 0x3d, 0x80, 0xee, 0x71, 0xd4, 0xae, 0x42,
+                0xa1, 0xf8, 0xc8, 0x16,
+            ],
+            ik: [
+                0x2e, 0x4f, 0xd4, 0xa6, 0xec, 0x39, 0x94, 0x87, 0xd3, 0x78, 0xb4, 0xc7, 0x25, 0xfb,
+                0x9b, 0xaf, 0xbc, 0x01, 0xa5, 0xe2, 0xb7, 0xf3, 0x68, 0x2e, 0xf4, 0x53, 0x95, 0x91,
+                0xbc, 0xf0, 0x59, 0x02,
+            ],
             nk: [
                 0x9f, 0x2f, 0x82, 0x67, 0x38, 0x94, 0x5a, 0xd0, 0x1f, 0x47, 0xf7, 0x0d, 0xb0, 0xc3,
                 0x67, 0xc2, 0x46, 0xc2, 0x0c, 0x61, 0xff, 0x55, 0x83, 0x94, 0x8c, 0x39, 0xde, 0xa9,
@@ -132,6 +144,16 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x2a, 0xd6, 0x43, 0x23, 0x62, 0x9c, 0xfe, 0xd1, 0xe3, 0xaa, 0x24, 0xef, 0x05, 0x2f,
                 0x56, 0xe4, 0x00, 0x2a,
             ],
+            isk: [
+                0xee, 0xf5, 0xe9, 0x1b, 0x36, 0xb8, 0x06, 0x86, 0x72, 0x3d, 0x14, 0xdc, 0xc7, 0x04,
+                0xad, 0x59, 0x67, 0x08, 0x0b, 0x7d, 0x6e, 0x49, 0xaf, 0x97, 0x03, 0x0e, 0x4f, 0xa0,
+                0xbf, 0x5a, 0xd9, 0x0b,
+            ],
+            ik: [
+                0x2e, 0xde, 0xfb, 0x15, 0x8e, 0xa4, 0x48, 0x82, 0x57, 0x2b, 0xcd, 0xb2, 0x35, 0xca,
+                0x36, 0xab, 0x39, 0xc7, 0x47, 0xbb, 0x71, 0xfe, 0x0f, 0x10, 0xfa, 0xa3, 0x9b, 0xfd,
+                0x62, 0x0a, 0xcc, 0x04,
+            ],
             nk: [
                 0xa8, 0xb7, 0x3d, 0x97, 0x9b, 0x6e, 0xaa, 0xda, 0x89, 0x24, 0xbc, 0xbd, 0xc6, 0x3a,
                 0x9e, 0xf4, 0xe8, 0x73, 0x46, 0xf2, 0x30, 0xab, 0xa6, 0xbb, 0xe1, 0xe2, 0xb4, 0x3c,
@@ -223,6 +245,16 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xed, 0xb4, 0x26, 0x65, 0x7b, 0x2d, 0x07, 0x40, 0x66, 0x64, 0xd8, 0x95, 0x31, 0x2e,
                 0xa1, 0xc3, 0xb3, 0x34,
             ],
+            isk: [
+                0x5b, 0x1f, 0xc4, 0x57, 0xae, 0x71, 0x38, 0x3c, 0x53, 0xf4, 0x69, 0x41, 0xb7, 0xcb,
+                0x4c, 0xec, 0x3d, 0xea, 0xc0, 0xc6, 0x03, 0xe2, 0xcd, 0xd0, 0xd1, 0x8d, 0x94, 0x01,
+                0x9e, 0x43, 0xe2, 0x07,
+            ],
+            ik: [
+                0x4f, 0x43, 0xeb, 0x7d, 0x9e, 0x03, 0x6f, 0xa6, 0x15, 0xfd, 0x04, 0xa5, 0xef, 0x6a,
+                0xeb, 0x21, 0x6e, 0x06, 0x9b, 0xe9, 0x2d, 0x30, 0xe8, 0xf7, 0x16, 0x3e, 0xe3, 0x15,
+                0x11, 0x6f, 0x18, 0x32,
+            ],
             nk: [
                 0x04, 0x51, 0x4e, 0xa0, 0x48, 0xb9, 0x43, 0x63, 0xde, 0xa7, 0xcb, 0x3b, 0xe8, 0xd6,
                 0x25, 0x82, 0xac, 0x52, 0x92, 0x2e, 0x08, 0x65, 0xf6, 0x62, 0x74, 0x3b, 0x05, 0xea,
@@ -314,6 +346,16 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xe7, 0x2c, 0x3b, 0x64, 0x00, 0x06, 0xff, 0x08, 0x50, 0x52, 0x80, 0xe4, 0xf0, 0x0f,
                 0xad, 0xf7, 0x63, 0x28,
             ],
+            isk: [
+                0x71, 0xd0, 0x64, 0xaa, 0xa0, 0x82, 0x63, 0xb8, 0xe4, 0xc3, 0xed, 0x70, 0x3c, 0x6f,
+                0x54, 0x25, 0x4a, 0x88, 0x8c, 0x36, 0xec, 0x69, 0x86, 0x62, 0xf7, 0x1f, 0xbb, 0xf4,
+                0x26, 0xd9, 0x09, 0x28,
+            ],
+            ik: [
+                0x12, 0xb3, 0xab, 0xff, 0x96, 0x75, 0x20, 0x9e, 0x94, 0x54, 0x07, 0x0c, 0x14, 0xac,
+                0x15, 0x54, 0x65, 0xae, 0x83, 0xbe, 0x2c, 0x39, 0x46, 0x63, 0x5e, 0x38, 0x77, 0xba,
+                0x67, 0xdf, 0x49, 0x12,
+            ],
             nk: [
                 0xcf, 0x36, 0xad, 0x6a, 0x06, 0x6c, 0xd2, 0x13, 0xe1, 0xd7, 0x67, 0xab, 0x07, 0x1d,
                 0xc1, 0x16, 0x78, 0x85, 0xc4, 0x16, 0x8b, 0xc2, 0xe2, 0x17, 0x54, 0x48, 0x56, 0x3a,
@@ -405,6 +447,16 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xf5, 0x6d, 0x83, 0x20, 0x09, 0xf7, 0x24, 0x2e, 0x1f, 0x7c, 0x77, 0x0a, 0x12, 0x24,
                 0x1d, 0xfa, 0x28, 0x07,
             ],
+            isk: [
+                0x44, 0x36, 0x1a, 0x7b, 0xa6, 0xa1, 0xaa, 0x17, 0x8e, 0x72, 0xaf, 0x47, 0xbd, 0xc1,
+                0x60, 0x40, 0xce, 0x1c, 0x54, 0xdd, 0x4b, 0x56, 0x33, 0x21, 0x55, 0xba, 0x9d, 0x04,
+                0x09, 0x71, 0xd0, 0x07,
+            ],
+            ik: [
+                0x1f, 0x17, 0x2d, 0x79, 0xae, 0xdc, 0xc2, 0x06, 0x8c, 0x3a, 0x09, 0x08, 0x93, 0xe1,
+                0xa1, 0x75, 0xd9, 0xb5, 0x78, 0xf8, 0x91, 0xaf, 0x9a, 0xb6, 0x8d, 0x4f, 0xe1, 0xe9,
+                0x05, 0xa3, 0xb2, 0x11,
+            ],
             nk: [
                 0x51, 0xba, 0xf3, 0x33, 0xcf, 0xf1, 0xf2, 0xd0, 0xc7, 0xe3, 0xcf, 0xf4, 0xd3, 0x01,
                 0x29, 0x9d, 0xc1, 0xef, 0xe9, 0x83, 0x00, 0x31, 0x4a, 0x54, 0x19, 0x38, 0x02, 0x9b,
@@ -496,6 +548,16 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xdf, 0x28, 0xbb, 0x0f, 0x10, 0x21, 0xea, 0x84, 0x3f, 0x86, 0x7f, 0x8a, 0x17, 0x0f,
                 0x5c, 0x33, 0x90, 0x1f,
             ],
+            isk: [
+                0xdc, 0x93, 0x72, 0x9f, 0x3f, 0x28, 0x30, 0xed, 0x79, 0x1c, 0x21, 0xbe, 0xbe, 0x45,
+                0x0f, 0xcf, 0x1f, 0x8f, 0xef, 0x49, 0x81, 0x39, 0xc7, 0x99, 0xd1, 0x63, 0x66, 0x5a,
+                0x8c, 0x51, 0xe5, 0x2d,
+            ],
+            ik: [
+                0x1d, 0xb6, 0x1c, 0x29, 0x3e, 0x3a, 0x93, 0x34, 0x5d, 0x06, 0xb9, 0x0b, 0xd7, 0x1f,
+                0xd3, 0x21, 0x5c, 0x2c, 0x1c, 0x29, 0x53, 0x5a, 0x10, 0xde, 0x9d, 0x31, 0x40, 0xb7,
+                0x4d, 0xb6, 0x1d, 0x07,
+            ],
             nk: [
                 0x9e, 0x99, 0x7d, 0x9d, 0x26, 0x97, 0x87, 0x26, 0x8e, 0x09, 0x2a, 0x7c, 0x85, 0x41,
                 0x7d, 0xa5, 0x30, 0xea, 0x42, 0xfa, 0xc6, 0x68, 0xa7, 0x49, 0xaf, 0x55, 0xdf, 0xb7,
@@ -587,6 +649,16 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x65, 0x43, 0x46, 0x2a, 0x13, 0x7f, 0xfe, 0xa3, 0x7b, 0xaf, 0x41, 0xef, 0x28, 0x6b,
                 0xb7, 0x32, 0xbe, 0x2c,
             ],
+            isk: [
+                0xf2, 0x34, 0x52, 0x32, 0xc9, 0x19, 0xc1, 0x29, 0xe0, 0x4b, 0x0c, 0x46, 0xac, 0x2c,
+                0xa8, 0x50, 0x65, 0xd9, 0x54, 0x85, 0xb9, 0x02, 0xab, 0x0f, 0x98, 0xf9, 0x3a, 0xee,
+                0x59, 0x4b, 0x5f, 0x02,
+            ],
+            ik: [
+                0x2c, 0x83, 0xd9, 0x20, 0xe9, 0xf6, 0x6d, 0xa5, 0x04, 0x86, 0x37, 0xad, 0x9a, 0xa2,
+                0xcc, 0xe6, 0xe1, 0x6e, 0xf4, 0x8f, 0x86, 0x50, 0xea, 0x00, 0xd8, 0xc2, 0xd7, 0x68,
+                0x61, 0x8a, 0xe3, 0x36,
+            ],
             nk: [
                 0xfd, 0x31, 0x64, 0xc6, 0x32, 0xbe, 0xc9, 0x4c, 0xe9, 0xfb, 0x2f, 0x30, 0x22, 0x63,
                 0xb8, 0x84, 0xab, 0xb9, 0xc1, 0x0e, 0x55, 0xe4, 0x48, 0x64, 0x7f, 0x67, 0x98, 0x49,
@@ -678,6 +750,16 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xb3, 0x65, 0x1f, 0xfa, 0x1c, 0x69, 0x69, 0x15, 0xac, 0x00, 0xa2, 0x5e, 0xa3, 0xac,
                 0x7d, 0xff, 0x99, 0x01,
             ],
+            isk: [
+                0x3d, 0xa9, 0x08, 0x88, 0xba, 0x18, 0x24, 0xc8, 0x16, 0x29, 0x2d, 0x7f, 0x17, 0x33,
+                0xac, 0x4c, 0xbe, 0x72, 0x2c, 0x6a, 0x12, 0x1c, 0xc7, 0x80, 0x17, 0x06, 0x26, 0xb7,
+                0x0a, 0x26, 0x95, 0x28,
+            ],
+            ik: [
+                0x16, 0xa8, 0xff, 0x29, 0xb5, 0x17, 0xb5, 0xa8, 0xf7, 0xd0, 0x9b, 0x4e, 0x5e, 0x71,
+                0x3a, 0x9a, 0x78, 0x4c, 0x74, 0x04, 0xd6, 0x1e, 0x3a, 0xf5, 0x30, 0x19, 0xc3, 0x47,
+                0x0e, 0x90, 0x95, 0x22,
+            ],
             nk: [
                 0x02, 0xab, 0x99, 0x5c, 0xe9, 0x8f, 0x63, 0x02, 0x5f, 0xb6, 0x24, 0x28, 0xa0, 0xfb,
                 0xf5, 0x2f, 0x25, 0x22, 0xe6, 0xa2, 0x72, 0x61, 0x07, 0x8a, 0x9f, 0x4d, 0x6a, 0x36,
@@ -769,6 +851,16 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x3b, 0x02, 0xd2, 0x5c, 0xc1, 0x0c, 0x90, 0x71, 0xfc, 0x02, 0x19, 0xe9, 0x7f, 0x93,
                 0x92, 0xd0, 0x67, 0x0c,
             ],
+            isk: [
+                0x01, 0x65, 0x33, 0x68, 0x4f, 0xb9, 0x81, 0x15, 0xa4, 0x05, 0xc9, 0xc7, 0xad, 0x47,
+                0x72, 0x76, 0xab, 0x7c, 0x72, 0xfd, 0x67, 0x1a, 0x27, 0xe3, 0x6c, 0x0a, 0x7a, 0xbe,
+                0x0a, 0x76, 0x90, 0x09,
+            ],
+            ik: [
+                0xff, 0xd7, 0x5f, 0x6f, 0x9e, 0xf4, 0x27, 0xf3, 0x26, 0xcd, 0xbf, 0x3a, 0x98, 0xbc,
+                0xb5, 0x93, 0x63, 0x5a, 0x2c, 0x1a, 0xd7, 0x2b, 0x39, 0x99, 0x12, 0x61, 0xe2, 0x75,
+                0xa9, 0xec, 0x6f, 0x10,
+            ],
             nk: [
                 0x25, 0x91, 0xed, 0xf7, 0xef, 0x4c, 0xf2, 0x18, 0x4c, 0x34, 0xbe, 0x93, 0xfc, 0xf6,
                 0x12, 0x91, 0x50, 0x42, 0xf1, 0x5a, 0xb5, 0x08, 0x4b, 0x14, 0xe1, 0x66, 0x79, 0x5b,
@@ -860,6 +952,16 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x8d, 0x4b, 0x02, 0x5f, 0x8c, 0xc1, 0x60, 0xe1, 0xf4, 0xe9, 0x5f, 0x0a, 0x85, 0x3e,
                 0xbc, 0x41, 0x6a, 0x2b,
             ],
+            isk: [
+                0x76, 0x08, 0x32, 0x9d, 0xfa, 0x77, 0xc4, 0x2c, 0x4f, 0xc7, 0x6a, 0xc2, 0x95, 0x94,
+                0xa2, 0x72, 0x83, 0x93, 0x4f, 0x5a, 0x93, 0x40, 0x71, 0xb9, 0xf8, 0xcd, 0x34, 0x4e,
+                0x1f, 0x98, 0x45, 0x0e,
+            ],
+            ik: [
+                0x72, 0xa0, 0xac, 0x97, 0x8a, 0x2d, 0xa1, 0x61, 0xf4, 0x1f, 0x5b, 0x7a, 0x40, 0xbd,
+                0x83, 0xc0, 0x58, 0x41, 0xf8, 0x1b, 0xc5, 0x11, 0x40, 0x67, 0xb8, 0x85, 0x98, 0x7f,
+                0x48, 0xca, 0x52, 0x2d,
+            ],
             nk: [
                 0x3e, 0x88, 0xf2, 0x07, 0x1f, 0xd9, 0xa2, 0xbb, 0x26, 0xcd, 0xa2, 0xea, 0x85, 0x6a,
                 0xa0, 0xfb, 0x3a, 0x80, 0xa8, 0x7d, 0x2f, 0xb6, 0x13, 0x6f, 0xab, 0x85, 0xe3, 0x6c,

From e6b776295a0dc4505ac27981cc3cacc416186917 Mon Sep 17 00:00:00 2001
From: Paul <3682187+PaulLaux@users.noreply.github.com>
Date: Tue, 14 Jun 2022 21:23:03 +0300
Subject: [PATCH 03/17] Added NoteType to Notes (#2)

* Added NoteType to Notes
* Added NoteType to value commitment derivation
---
 .circleci/config.yml         | 15 ++++++-
 src/action.rs                |  7 +++-
 src/builder.rs               | 18 +++++++--
 src/bundle.rs                |  2 +
 src/circuit.rs               |  3 +-
 src/constants/fixed_bases.rs |  4 ++
 src/keys.rs                  |  2 +
 src/note.rs                  | 19 ++++++++-
 src/note/note_type.rs        | 77 ++++++++++++++++++++++++++++++++++++
 src/note_encryption.rs       |  8 +++-
 src/value.rs                 | 66 ++++++++++++++++++-------------
 11 files changed, 182 insertions(+), 39 deletions(-)
 create mode 100644 src/note/note_type.rs

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 153b55131..ba37a7890 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -2,6 +2,9 @@
 # See: https://circleci.com/docs/2.0/configuration-reference
 version: 2.1
 
+orbs:
+  slack: circleci/slack@4.1
+
 # Define a job to be invoked later in a workflow.
 # See: https://circleci.com/docs/2.0/configuration-reference/#jobs
 jobs:
@@ -17,8 +20,15 @@ jobs:
       - run:
           name: "cargo test"
           command: |
+            sudo apt update && sudo apt-get install libfontconfig libfontconfig1-dev libfreetype6-dev;
             cargo version;
-            cargo test;
+            cargo test --all --all-features;
+      - slack/notify:
+          event: fail
+          template: basic_fail_1
+      - slack/notify:
+          event: pass
+          template: basic_success_1
           
 
 # Invoke jobs via workflows
@@ -26,4 +36,5 @@ jobs:
 workflows:
   build-and-test:
     jobs:
-      - cargo-test
+      - cargo-test:
+          context: CI-Orchard-slack
diff --git a/src/action.rs b/src/action.rs
index d0b73f23e..b6396ed91 100644
--- a/src/action.rs
+++ b/src/action.rs
@@ -126,6 +126,7 @@ pub(crate) mod testing {
 
     use proptest::prelude::*;
 
+    use crate::note::NoteType;
     use crate::{
         note::{
             commitment::ExtractedNoteCommitment, nullifier::testing::arb_nullifier,
@@ -150,7 +151,8 @@ pub(crate) mod testing {
             let cmx = ExtractedNoteCommitment::from(note.commitment());
             let cv_net = ValueCommitment::derive(
                 spend_value - output_value,
-                ValueCommitTrapdoor::zero()
+                ValueCommitTrapdoor::zero(),
+                NoteType::native()
             );
             // FIXME: make a real one from the note.
             let encrypted_note = TransmittedNoteCiphertext {
@@ -181,7 +183,8 @@ pub(crate) mod testing {
             let cmx = ExtractedNoteCommitment::from(note.commitment());
             let cv_net = ValueCommitment::derive(
                 spend_value - output_value,
-                ValueCommitTrapdoor::zero()
+                ValueCommitTrapdoor::zero(),
+                NoteType::native()
             );
 
             // FIXME: make a real one from the note.
diff --git a/src/builder.rs b/src/builder.rs
index 9cbc2a5fb..1a7ccbec1 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -8,6 +8,7 @@ use nonempty::NonEmpty;
 use pasta_curves::pallas;
 use rand::{prelude::SliceRandom, CryptoRng, RngCore};
 
+use crate::note::NoteType;
 use crate::{
     action::Action,
     address::Address,
@@ -160,14 +161,21 @@ impl ActionInfo {
     /// [orchardsend]: https://zips.z.cash/protocol/nu5.pdf#orchardsend
     fn build(self, mut rng: impl RngCore) -> (Action<SigningMetadata>, Circuit) {
         let v_net = self.value_sum();
-        let cv_net = ValueCommitment::derive(v_net, self.rcv.clone());
+        let cv_net = ValueCommitment::derive(v_net, self.rcv, NoteType::native());
 
         let nf_old = self.spend.note.nullifier(&self.spend.fvk);
         let ak: SpendValidatingKey = self.spend.fvk.clone().into();
         let alpha = pallas::Scalar::random(&mut rng);
         let rk = ak.randomize(&alpha);
+        let note_type = self.spend.note.note_type();
 
-        let note = Note::new(self.output.recipient, self.output.value, nf_old, &mut rng);
+        let note = Note::new(
+            self.output.recipient,
+            self.output.value,
+            note_type,
+            nf_old,
+            &mut rng,
+        );
         let cm_new = note.commitment();
         let cmx = cm_new.into();
 
@@ -387,7 +395,11 @@ impl Builder {
 
         // Verify that bsk and bvk are consistent.
         let bvk = (actions.iter().map(|a| a.cv_net()).sum::<ValueCommitment>()
-            - ValueCommitment::derive(value_balance, ValueCommitTrapdoor::zero()))
+            - ValueCommitment::derive(
+                value_balance,
+                ValueCommitTrapdoor::zero(),
+                NoteType::native(),
+            ))
         .into_bvk();
         assert_eq!(redpallas::VerificationKey::from(&bsk), bvk);
 
diff --git a/src/bundle.rs b/src/bundle.rs
index 239cce7c2..4f4e1cb3f 100644
--- a/src/bundle.rs
+++ b/src/bundle.rs
@@ -12,6 +12,7 @@ use memuse::DynamicUsage;
 use nonempty::NonEmpty;
 use zcash_note_encryption::{try_note_decryption, try_output_recovery_with_ovk};
 
+use crate::note::NoteType;
 use crate::{
     action::Action,
     address::Address,
@@ -384,6 +385,7 @@ impl<T: Authorization, V: Copy + Into<i64>> Bundle<T, V> {
             - ValueCommitment::derive(
                 ValueSum::from_raw(self.value_balance.into()),
                 ValueCommitTrapdoor::zero(),
+                NoteType::native(),
             ))
         .into_bvk()
     }
diff --git a/src/circuit.rs b/src/circuit.rs
index d349180ed..0b271d750 100644
--- a/src/circuit.rs
+++ b/src/circuit.rs
@@ -968,6 +968,7 @@ mod tests {
     use rand::{rngs::OsRng, RngCore};
 
     use super::{Circuit, Instance, Proof, ProvingKey, VerifyingKey, K};
+    use crate::note::NoteType;
     use crate::{
         keys::SpendValidatingKey,
         note::Note,
@@ -991,7 +992,7 @@ mod tests {
 
         let value = spent_note.value() - output_note.value();
         let rcv = ValueCommitTrapdoor::random(&mut rng);
-        let cv_net = ValueCommitment::derive(value, rcv.clone());
+        let cv_net = ValueCommitment::derive(value, rcv, NoteType::native());
 
         let path = MerklePath::dummy(&mut rng);
         let anchor = path.root(spent_note.commitment().into());
diff --git a/src/constants/fixed_bases.rs b/src/constants/fixed_bases.rs
index af11e335f..7a86487d3 100644
--- a/src/constants/fixed_bases.rs
+++ b/src/constants/fixed_bases.rs
@@ -19,8 +19,12 @@ pub mod value_commit_v;
 pub const ORCHARD_PERSONALIZATION: &str = "z.cash:Orchard";
 
 /// SWU hash-to-curve personalization for the value commitment generator
+/// TODO: should we change to "NOTE_TYPE_PERSONALIZATION"?
 pub const VALUE_COMMITMENT_PERSONALIZATION: &str = "z.cash:Orchard-cv";
 
+/// SWU hash-to-curve personalization for the note type generator
+// pub const NOTE_TYPE_PERSONALIZATION: &str = "z.cash:Orchard-NoteType";
+
 /// SWU hash-to-curve value for the value commitment generator
 pub const VALUE_COMMITMENT_V_BYTES: [u8; 1] = *b"v";
 
diff --git a/src/keys.rs b/src/keys.rs
index 16c63b42e..8b76c8517 100644
--- a/src/keys.rs
+++ b/src/keys.rs
@@ -1084,6 +1084,7 @@ mod tests {
         testing::{arb_diversifier_index, arb_diversifier_key, arb_esk, arb_spending_key},
         *,
     };
+    use crate::note::NoteType;
     use crate::{
         note::{ExtractedNoteCommitment, Nullifier, RandomSeed},
         value::NoteValue,
@@ -1175,6 +1176,7 @@ mod tests {
             let note = Note::from_parts(
                 addr,
                 NoteValue::from_raw(tv.note_v),
+                NoteType::native(),
                 rho,
                 RandomSeed::from_bytes(tv.note_rseed, &rho).unwrap(),
             )
diff --git a/src/note.rs b/src/note.rs
index 522b137f3..31063864c 100644
--- a/src/note.rs
+++ b/src/note.rs
@@ -19,6 +19,9 @@ pub use self::commitment::{ExtractedNoteCommitment, NoteCommitment};
 pub(crate) mod nullifier;
 pub use self::nullifier::Nullifier;
 
+pub(crate) mod note_type;
+pub use self::note_type::NoteType;
+
 /// The ZIP 212 seed randomness for a note.
 #[derive(Copy, Clone, Debug)]
 pub struct RandomSeed([u8; 32]);
@@ -90,6 +93,8 @@ pub struct Note {
     recipient: Address,
     /// The value of this note.
     value: NoteValue,
+    /// The type of this note.
+    note_type: NoteType,
     /// A unique creation ID for this note.
     ///
     /// This is set to the nullifier of the note that was spent in the [`Action`] that
@@ -129,12 +134,14 @@ impl Note {
     pub fn from_parts(
         recipient: Address,
         value: NoteValue,
+        note_type: NoteType,
         rho: Nullifier,
         rseed: RandomSeed,
     ) -> CtOption<Self> {
         let note = Note {
             recipient,
             value,
+            note_type,
             rho,
             rseed,
         };
@@ -149,11 +156,12 @@ impl Note {
     pub(crate) fn new(
         recipient: Address,
         value: NoteValue,
+        note_type: NoteType,
         rho: Nullifier,
         mut rng: impl RngCore,
     ) -> Self {
         loop {
-            let note = Note::from_parts(recipient, value, rho, RandomSeed::random(&mut rng, &rho));
+            let note = Note::from_parts(recipient, value, note_type, rho, RandomSeed::random(&mut rng, &rho));
             if note.is_some().into() {
                 break note.unwrap();
             }
@@ -176,6 +184,7 @@ impl Note {
         let note = Note::new(
             recipient,
             NoteValue::zero(),
+            NoteType::native(),
             rho.unwrap_or_else(|| Nullifier::dummy(rng)),
             rng,
         );
@@ -193,6 +202,11 @@ impl Note {
         self.value
     }
 
+    /// Returns the note type
+    pub fn note_type(&self) -> NoteType {
+        self.note_type
+    }
+
     /// Returns the rseed value of this note.
     pub fn rseed(&self) -> &RandomSeed {
         &self.rseed
@@ -279,6 +293,7 @@ impl fmt::Debug for TransmittedNoteCiphertext {
 pub mod testing {
     use proptest::prelude::*;
 
+    use crate::note::note_type::testing::arb_note_type;
     use crate::{
         address::testing::arb_address, note::nullifier::testing::arb_nullifier, value::NoteValue,
     };
@@ -298,10 +313,12 @@ pub mod testing {
             recipient in arb_address(),
             rho in arb_nullifier(),
             rseed in arb_rseed(),
+            note_type in arb_note_type(),
         ) -> Note {
             Note {
                 recipient,
                 value,
+                note_type,
                 rho,
                 rseed,
             }
diff --git a/src/note/note_type.rs b/src/note/note_type.rs
new file mode 100644
index 000000000..d0857d61a
--- /dev/null
+++ b/src/note/note_type.rs
@@ -0,0 +1,77 @@
+use group::GroupEncoding;
+use halo2_proofs::arithmetic::CurveExt;
+use pasta_curves::pallas;
+use subtle::CtOption;
+
+use crate::constants::fixed_bases::{VALUE_COMMITMENT_PERSONALIZATION, VALUE_COMMITMENT_V_BYTES};
+use crate::keys::IssuerValidatingKey;
+
+/// Note type identifier.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct NoteType(pub(crate) pallas::Point);
+
+const MAX_ASSET_DESCRIPTION_SIZE: usize = 512;
+
+// the hasher used to derive the assetID
+#[allow(non_snake_case)]
+fn assetID_hasher(msg: Vec<u8>) -> pallas::Point {
+    // TODO(zsa) replace personalization, will require circuit change?
+    pallas::Point::hash_to_curve(VALUE_COMMITMENT_PERSONALIZATION)(&msg)
+}
+
+impl NoteType {
+    /// Deserialize the note_type from a byte array.
+    pub fn from_bytes(bytes: &[u8; 32]) -> CtOption<Self> {
+        pallas::Point::from_bytes(bytes).map(NoteType)
+    }
+
+    /// Serialize the note_type to its canonical byte representation.
+    pub fn to_bytes(self) -> [u8; 32] {
+        self.0.to_bytes()
+    }
+
+    /// $DeriveNoteType$.
+    ///
+    /// Defined in [Zcash Protocol Spec § TBD: Note Types][notetypes].
+    ///
+    /// [notetypes]: https://zips.z.cash/protocol/nu5.pdf#notetypes
+    #[allow(non_snake_case)]
+    pub fn derive(ik: &IssuerValidatingKey, assetDesc: Vec<u8>) -> Self {
+        assert!(assetDesc.len() < MAX_ASSET_DESCRIPTION_SIZE);
+
+        let mut s = vec![];
+        s.extend(ik.to_bytes());
+        s.extend(assetDesc);
+
+        NoteType(assetID_hasher(s))
+    }
+
+    /// Note type for the "native" currency (zec), maintains backward compatibility with Orchard untyped notes.
+    pub fn native() -> Self {
+        NoteType(assetID_hasher(VALUE_COMMITMENT_V_BYTES.to_vec()))
+    }
+}
+
+/// Generators for property testing.
+#[cfg(any(test, feature = "test-dependencies"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "test-dependencies")))]
+pub mod testing {
+    use proptest::prelude::*;
+
+    use super::NoteType;
+
+    use crate::keys::{testing::arb_spending_key, IssuerAuthorizingKey, IssuerValidatingKey};
+
+    prop_compose! {
+        /// Generate a uniformly distributed note type
+        pub fn arb_note_type()(
+            sk in arb_spending_key(),
+            bytes32a in prop::array::uniform32(prop::num::u8::ANY),
+            bytes32b in prop::array::uniform32(prop::num::u8::ANY),
+        ) -> NoteType {
+            let bytes64 = [bytes32a, bytes32b].concat();
+            let isk = IssuerAuthorizingKey::from(&sk);
+            NoteType::derive(&IssuerValidatingKey::from(&isk), bytes64)
+        }
+    }
+}
diff --git a/src/note_encryption.rs b/src/note_encryption.rs
index 8ad06c8a9..39cd318e1 100644
--- a/src/note_encryption.rs
+++ b/src/note_encryption.rs
@@ -10,6 +10,7 @@ use zcash_note_encryption::{
     OUT_PLAINTEXT_SIZE,
 };
 
+use crate::note::NoteType;
 use crate::{
     action::Action,
     keys::{
@@ -75,7 +76,8 @@ where
     let pk_d = get_validated_pk_d(&diversifier)?;
 
     let recipient = Address::from_parts(diversifier, pk_d);
-    let note = Option::from(Note::from_parts(recipient, value, domain.rho, rseed))?;
+    // TODO: add note_type
+    let note = Option::from(Note::from_parts(recipient, value, NoteType::native(), domain.rho, rseed))?;
     Some((note, recipient))
 }
 
@@ -171,6 +173,7 @@ impl Domain for OrchardDomain {
         np[0] = 0x02;
         np[1..12].copy_from_slice(note.recipient().diversifier().as_array());
         np[12..20].copy_from_slice(&note.value().to_bytes());
+        // todo: add note_type
         np[20..52].copy_from_slice(note.rseed().as_bytes());
         np[52..].copy_from_slice(memo);
         NotePlaintextBytes(np)
@@ -358,6 +361,7 @@ mod tests {
     };
 
     use super::{prf_ock_orchard, CompactAction, OrchardDomain, OrchardNoteEncryption};
+    use crate::note::NoteType;
     use crate::{
         action::Action,
         keys::{
@@ -413,7 +417,7 @@ mod tests {
             assert_eq!(ock.as_ref(), tv.ock);
 
             let recipient = Address::from_parts(d, pk_d);
-            let note = Note::from_parts(recipient, value, rho, rseed).unwrap();
+            let note = Note::from_parts(recipient, value, NoteType::native(), rho, rseed).unwrap();
             assert_eq!(ExtractedNoteCommitment::from(note.commitment()), cmx);
 
             let action = Action::from_parts(
diff --git a/src/value.rs b/src/value.rs
index 1cef61c87..5ece74af2 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -52,10 +52,9 @@ use pasta_curves::{
 use rand::RngCore;
 use subtle::CtOption;
 
+use crate::note::NoteType;
 use crate::{
-    constants::fixed_bases::{
-        VALUE_COMMITMENT_PERSONALIZATION, VALUE_COMMITMENT_R_BYTES, VALUE_COMMITMENT_V_BYTES,
-    },
+    constants::fixed_bases::{VALUE_COMMITMENT_PERSONALIZATION, VALUE_COMMITMENT_R_BYTES},
     primitives::redpallas::{self, Binding},
 };
 
@@ -211,7 +210,7 @@ impl TryFrom<ValueSum> for i64 {
 }
 
 /// The blinding factor for a [`ValueCommitment`].
-#[derive(Clone, Debug)]
+#[derive(Clone, Copy, Debug)]
 pub struct ValueCommitTrapdoor(pallas::Scalar);
 
 impl ValueCommitTrapdoor {
@@ -308,9 +307,8 @@ impl ValueCommitment {
     ///
     /// [concretehomomorphiccommit]: https://zips.z.cash/protocol/nu5.pdf#concretehomomorphiccommit
     #[allow(non_snake_case)]
-    pub fn derive(value: ValueSum, rcv: ValueCommitTrapdoor) -> Self {
+    pub fn derive(value: ValueSum, rcv: ValueCommitTrapdoor, note_type: NoteType) -> Self {
         let hasher = pallas::Point::hash_to_curve(VALUE_COMMITMENT_PERSONALIZATION);
-        let V = hasher(&VALUE_COMMITMENT_V_BYTES);
         let R = hasher(&VALUE_COMMITMENT_R_BYTES);
         let abs_value = u64::try_from(value.0.abs()).expect("value must be in valid range");
 
@@ -320,7 +318,9 @@ impl ValueCommitment {
             pallas::Scalar::from(abs_value)
         };
 
-        ValueCommitment(V * value + R * rcv.0)
+        let V_zsa = note_type.0;
+
+        ValueCommitment(V_zsa * value + R * rcv.0)
     }
 
     pub(crate) fn into_bvk(self) -> redpallas::VerificationKey<Binding> {
@@ -423,6 +423,8 @@ pub mod testing {
 
 #[cfg(test)]
 mod tests {
+    use crate::note::note_type::testing::arb_note_type;
+    use crate::note::NoteType;
     use proptest::prelude::*;
 
     use super::{
@@ -431,6 +433,29 @@ mod tests {
     };
     use crate::primitives::redpallas;
 
+    fn _bsk_consistent_with_bvk(values: &[(ValueSum, ValueCommitTrapdoor)], note_type: NoteType) {
+        let value_balance = values
+            .iter()
+            .map(|(value, _)| value)
+            .sum::<Result<ValueSum, OverflowError>>()
+            .expect("we generate values that won't overflow");
+
+        let bsk = values
+            .iter()
+            .map(|(_, rcv)| rcv)
+            .sum::<ValueCommitTrapdoor>()
+            .into_bsk();
+
+        let bvk = (values
+            .iter()
+            .map(|(value, rcv)| ValueCommitment::derive(*value, *rcv, note_type))
+            .sum::<ValueCommitment>()
+            - ValueCommitment::derive(value_balance, ValueCommitTrapdoor::zero(), note_type))
+        .into_bvk();
+
+        assert_eq!(redpallas::VerificationKey::from(&bsk), bvk);
+    }
+
     proptest! {
         #[test]
         fn bsk_consistent_with_bvk(
@@ -438,28 +463,13 @@ mod tests {
                 arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
                     prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor()), n_values)
                 )
-            )
+            ),
+            arb_note_type in arb_note_type(),
         ) {
-            let value_balance = values
-                .iter()
-                .map(|(value, _)| value)
-                .sum::<Result<ValueSum, OverflowError>>()
-                .expect("we generate values that won't overflow");
-
-            let bsk = values
-                .iter()
-                .map(|(_, rcv)| rcv)
-                .sum::<ValueCommitTrapdoor>()
-                .into_bsk();
-
-            let bvk = (values
-                .into_iter()
-                .map(|(value, rcv)| ValueCommitment::derive(value, rcv))
-                .sum::<ValueCommitment>()
-                - ValueCommitment::derive(value_balance, ValueCommitTrapdoor::zero()))
-            .into_bvk();
-
-            assert_eq!(redpallas::VerificationKey::from(&bsk), bvk);
+            // Test with native note type (zec)
+            _bsk_consistent_with_bvk(&values, NoteType::native());
+            // Test with arbitrary note type
+            _bsk_consistent_with_bvk(&values, arb_note_type);
         }
     }
 }

From 088abc6de6266bfafe1cd29c7a474936c20842f4 Mon Sep 17 00:00:00 2001
From: naure <naure@users.noreply.github.com>
Date: Wed, 20 Jul 2022 13:08:58 +0200
Subject: [PATCH 04/17] ZSA note encryption in Orchard crate (#3)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Circleci project setup (#1)

* Added .circleci/config.yml

* Added NoteType to Notes

* reformated file

* updated `derive` for NoteType

* added note_type to value commit derivation

* rustfmt

* updated ci config

* updated ci config

* updated ci config

* updated derive for note_type

* added test for arb note_type

* added test for `native` note type

* zsa-note-encryption: introduce AssetType and encode and decode it in note plaintexts

* zsa-note-encryption: extend the size of compact notes to include asset_type

* fixed clippy warrnings

* rustfmt

* zsa-note-encryption: document parsing requirement

* zsa-note-encryption: revert support of ZSA compact action

* zsa_value: add NoteType method is_native

* zsa-note-encryption: remove dependency on changes in the other crate

* zsa-note-encryption: extract memo of ZSA notes

* zsa-note-encryption: tests (zcash_test_vectors 77c73492)

* zsa-note-encryption: simplify roundtrip test

* zsa-note-encryption: more test vectors (zcash_test_vectors c10da464)

* Circleci project setup (#1)

* Added .circleci/config.yml

* issuer keys implementation (#5)

Implements the issuer keys as

    IssuerAuthorizingKey -> isk
    IssuerVerifyingKey -> ik

Test vectors generated with zcash_test_vectors repo

* Added NoteType to Notes (#2)

* Added NoteType to Notes
* Added NoteType to value commitment derivation

* zsa-note-encryption: use both native and ZSA in proptests

* zsa-note-encryption: test vector commit 51398c93

* zsa-note-encryption: fix after merge

Co-authored-by: Paul <3682187+PaulLaux@users.noreply.github.com>
Co-authored-by: Paul <lauxpaul@protonmail.com>
Co-authored-by: Aurélien Nicolas <info@nau.re>
Co-authored-by: Daniel Benarroch <danielbenarroch92@gmail.com>
---
 .gitignore                          |    1 +
 src/constants/fixed_bases.rs        |    3 +
 src/note.rs                         |    1 +
 src/note/commitment.rs              |   54 +-
 src/note/note_type.rs               |   29 +-
 src/note_encryption.rs              |  140 +-
 src/test_vectors/note_encryption.rs | 3612 +++++++++++++++++++++------
 src/value.rs                        |    2 +-
 8 files changed, 3071 insertions(+), 771 deletions(-)

diff --git a/.gitignore b/.gitignore
index 173b95142..57ee1a9ad 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@
 **/*.rs.bk
 Cargo.lock
 .vscode
+.idea
diff --git a/src/constants/fixed_bases.rs b/src/constants/fixed_bases.rs
index 7a86487d3..bd58a90c2 100644
--- a/src/constants/fixed_bases.rs
+++ b/src/constants/fixed_bases.rs
@@ -34,6 +34,9 @@ pub const VALUE_COMMITMENT_R_BYTES: [u8; 1] = *b"r";
 /// SWU hash-to-curve personalization for the note commitment generator
 pub const NOTE_COMMITMENT_PERSONALIZATION: &str = "z.cash:Orchard-NoteCommit";
 
+/// SWU hash-to-curve personalization for the ZSA note commitment generator
+pub const NOTE_ZSA_COMMITMENT_PERSONALIZATION: &str = "z.cash:ZSA-NoteCommit";
+
 /// SWU hash-to-curve personalization for the IVK commitment generator
 pub const COMMIT_IVK_PERSONALIZATION: &str = "z.cash:Orchard-CommitIvk";
 
diff --git a/src/note.rs b/src/note.rs
index 31063864c..c2edf4988 100644
--- a/src/note.rs
+++ b/src/note.rs
@@ -248,6 +248,7 @@ impl Note {
             g_d.to_bytes(),
             self.recipient.pk_d().to_bytes(),
             self.value,
+            self.note_type,
             self.rho.0,
             self.rseed.psi(&self.rho),
             self.rseed.rcm(&self.rho),
diff --git a/src/note/commitment.rs b/src/note/commitment.rs
index 9de51d28e..95dc92a2c 100644
--- a/src/note/commitment.rs
+++ b/src/note/commitment.rs
@@ -7,7 +7,11 @@ use pasta_curves::pallas;
 use subtle::{ConstantTimeEq, CtOption};
 
 use crate::{
-    constants::{fixed_bases::NOTE_COMMITMENT_PERSONALIZATION, L_ORCHARD_BASE},
+    constants::{
+        fixed_bases::{NOTE_COMMITMENT_PERSONALIZATION, NOTE_ZSA_COMMITMENT_PERSONALIZATION},
+        L_ORCHARD_BASE,
+    },
+    note::note_type::NoteType,
     spec::extract_p,
     value::NoteValue,
 };
@@ -41,22 +45,46 @@ impl NoteCommitment {
         g_d: [u8; 32],
         pk_d: [u8; 32],
         v: NoteValue,
+        note_type: NoteType,
         rho: pallas::Base,
         psi: pallas::Base,
         rcm: NoteCommitTrapdoor,
     ) -> CtOption<Self> {
-        let domain = sinsemilla::CommitDomain::new(NOTE_COMMITMENT_PERSONALIZATION);
-        domain
-            .commit(
-                iter::empty()
-                    .chain(BitArray::<_, Lsb0>::new(g_d).iter().by_vals())
-                    .chain(BitArray::<_, Lsb0>::new(pk_d).iter().by_vals())
-                    .chain(v.to_le_bits().iter().by_vals())
-                    .chain(rho.to_le_bits().iter().by_vals().take(L_ORCHARD_BASE))
-                    .chain(psi.to_le_bits().iter().by_vals().take(L_ORCHARD_BASE)),
-                &rcm.0,
-            )
-            .map(NoteCommitment)
+        let g_d_bits = BitArray::<_, Lsb0>::new(g_d);
+        let pk_d_bits = BitArray::<_, Lsb0>::new(pk_d);
+        let v_bits = v.to_le_bits();
+        let rho_bits = rho.to_le_bits();
+        let psi_bits = psi.to_le_bits();
+
+        let zec_note_bits = iter::empty()
+            .chain(g_d_bits.iter().by_vals())
+            .chain(pk_d_bits.iter().by_vals())
+            .chain(v_bits.iter().by_vals())
+            .chain(rho_bits.iter().by_vals().take(L_ORCHARD_BASE))
+            .chain(psi_bits.iter().by_vals().take(L_ORCHARD_BASE));
+
+        // TODO: make this constant-time.
+        if note_type.is_native().into() {
+            // Commit to ZEC notes as per the Orchard protocol.
+            Self::commit(NOTE_COMMITMENT_PERSONALIZATION, zec_note_bits, rcm)
+        } else {
+            // Commit to non-ZEC notes as per the ZSA protocol.
+            // Append the note type to the Orchard note encoding.
+            let type_bits = BitArray::<_, Lsb0>::new(note_type.to_bytes());
+            let zsa_note_bits = zec_note_bits.chain(type_bits.iter().by_vals());
+
+            // Commit in a different domain than Orchard notes.
+            Self::commit(NOTE_ZSA_COMMITMENT_PERSONALIZATION, zsa_note_bits, rcm)
+        }
+    }
+
+    fn commit(
+        personalization: &str,
+        bits: impl Iterator<Item = bool>,
+        rcm: NoteCommitTrapdoor,
+    ) -> CtOption<Self> {
+        let domain = sinsemilla::CommitDomain::new(personalization);
+        domain.commit(bits, &rcm.0).map(NoteCommitment)
     }
 }
 
diff --git a/src/note/note_type.rs b/src/note/note_type.rs
index d0857d61a..6075259e3 100644
--- a/src/note/note_type.rs
+++ b/src/note/note_type.rs
@@ -1,7 +1,7 @@
 use group::GroupEncoding;
 use halo2_proofs::arithmetic::CurveExt;
 use pasta_curves::pallas;
-use subtle::CtOption;
+use subtle::{Choice, ConstantTimeEq, CtOption};
 
 use crate::constants::fixed_bases::{VALUE_COMMITMENT_PERSONALIZATION, VALUE_COMMITMENT_V_BYTES};
 use crate::keys::IssuerValidatingKey;
@@ -15,7 +15,7 @@ const MAX_ASSET_DESCRIPTION_SIZE: usize = 512;
 // the hasher used to derive the assetID
 #[allow(non_snake_case)]
 fn assetID_hasher(msg: Vec<u8>) -> pallas::Point {
-    // TODO(zsa) replace personalization, will require circuit change?
+    // TODO(zsa) replace personalization
     pallas::Point::hash_to_curve(VALUE_COMMITMENT_PERSONALIZATION)(&msg)
 }
 
@@ -50,6 +50,16 @@ impl NoteType {
     pub fn native() -> Self {
         NoteType(assetID_hasher(VALUE_COMMITMENT_V_BYTES.to_vec()))
     }
+
+    /// The base point used in value commitments.
+    pub fn cv_base(&self) -> pallas::Point {
+        self.0
+    }
+
+    /// Whether this note represents a native or ZSA asset.
+    pub fn is_native(&self) -> Choice {
+        self.0.ct_eq(&Self::native().0)
+    }
 }
 
 /// Generators for property testing.
@@ -58,20 +68,25 @@ impl NoteType {
 pub mod testing {
     use proptest::prelude::*;
 
-    use super::NoteType;
-
     use crate::keys::{testing::arb_spending_key, IssuerAuthorizingKey, IssuerValidatingKey};
 
+    use super::NoteType;
+
     prop_compose! {
         /// Generate a uniformly distributed note type
         pub fn arb_note_type()(
+            is_native in prop::bool::ANY,
             sk in arb_spending_key(),
             bytes32a in prop::array::uniform32(prop::num::u8::ANY),
             bytes32b in prop::array::uniform32(prop::num::u8::ANY),
         ) -> NoteType {
-            let bytes64 = [bytes32a, bytes32b].concat();
-            let isk = IssuerAuthorizingKey::from(&sk);
-            NoteType::derive(&IssuerValidatingKey::from(&isk), bytes64)
+            if is_native {
+                NoteType::native()
+            } else {
+                let bytes64 = [bytes32a, bytes32b].concat();
+                let isk = IssuerAuthorizingKey::from(&sk);
+                NoteType::derive(&IssuerValidatingKey::from(&isk), bytes64)
+            }
         }
     }
 }
diff --git a/src/note_encryption.rs b/src/note_encryption.rs
index 39cd318e1..5d955e2cb 100644
--- a/src/note_encryption.rs
+++ b/src/note_encryption.rs
@@ -1,8 +1,7 @@
 //! In-band secret distribution for Orchard bundles.
 
-use core::fmt;
-
 use blake2b_simd::{Hash, Params};
+use core::fmt;
 use group::ff::PrimeField;
 use zcash_note_encryption::{
     BatchDomain, Domain, EphemeralKeyBytes, NotePlaintextBytes, OutPlaintextBytes,
@@ -25,6 +24,15 @@ use crate::{
 
 const PRF_OCK_ORCHARD_PERSONALIZATION: &[u8; 16] = b"Zcash_Orchardock";
 
+/// The size of the encoding of a ZSA asset type.
+const ZSA_TYPE_SIZE: usize = 32;
+/// The size of the ZSA variant of COMPACT_NOTE_SIZE.
+const COMPACT_ZSA_NOTE_SIZE: usize = COMPACT_NOTE_SIZE + ZSA_TYPE_SIZE;
+/// The size of the memo.
+const MEMO_SIZE: usize = NOTE_PLAINTEXT_SIZE - COMPACT_NOTE_SIZE;
+/// The size of the ZSA variant of the memo.
+const ZSA_MEMO_SIZE: usize = NOTE_PLAINTEXT_SIZE - COMPACT_ZSA_NOTE_SIZE;
+
 /// Defined in [Zcash Protocol Spec § 5.4.2: Pseudo Random Functions][concreteprfs].
 ///
 /// [concreteprfs]: https://zips.z.cash/protocol/nu5.pdf#concreteprfs
@@ -50,6 +58,8 @@ pub(crate) fn prf_ock_orchard(
     )
 }
 
+/// Domain-specific requirements:
+/// - If the note version is 3, the `plaintext` must contain a valid encoding of a ZSA asset type.
 fn orchard_parse_note_plaintext_without_memo<F>(
     domain: &OrchardDomain,
     plaintext: &[u8],
@@ -61,9 +71,8 @@ where
     assert!(plaintext.len() >= COMPACT_NOTE_SIZE);
 
     // Check note plaintext version
-    if plaintext[0] != 0x02 {
-        return None;
-    }
+    // and parse the asset type accordingly.
+    let note_type = parse_version_and_asset_type(plaintext)?;
 
     // The unwraps below are guaranteed to succeed by the assertion above
     let diversifier = Diversifier::from_bytes(plaintext[1..12].try_into().unwrap());
@@ -76,11 +85,25 @@ where
     let pk_d = get_validated_pk_d(&diversifier)?;
 
     let recipient = Address::from_parts(diversifier, pk_d);
-    // TODO: add note_type
-    let note = Option::from(Note::from_parts(recipient, value, NoteType::native(), domain.rho, rseed))?;
+
+    let note = Option::from(Note::from_parts(recipient, value, note_type, domain.rho, rseed))?;
     Some((note, recipient))
 }
 
+fn parse_version_and_asset_type(plaintext: &[u8]) -> Option<NoteType> {
+    // TODO: make this constant-time?
+    match plaintext[0] {
+        0x02 => Some(NoteType::native()),
+        0x03 if plaintext.len() >= COMPACT_ZSA_NOTE_SIZE => {
+            let bytes = &plaintext[COMPACT_NOTE_SIZE..COMPACT_ZSA_NOTE_SIZE]
+                .try_into()
+                .unwrap();
+            NoteType::from_bytes(bytes).into()
+        }
+        _ => None,
+    }
+}
+
 /// Orchard-specific note encryption logic.
 #[derive(Debug)]
 pub struct OrchardDomain {
@@ -125,7 +148,7 @@ impl Domain for OrchardDomain {
     type ValueCommitment = ValueCommitment;
     type ExtractedCommitment = ExtractedNoteCommitment;
     type ExtractedCommitmentBytes = [u8; 32];
-    type Memo = [u8; 512]; // TODO use a more interesting type
+    type Memo = [u8; MEMO_SIZE]; // TODO use a more interesting type
 
     fn derive_esk(note: &Self::Note) -> Option<Self::EphemeralSecretKey> {
         Some(note.esk())
@@ -169,13 +192,23 @@ impl Domain for OrchardDomain {
         _: &Self::Recipient,
         memo: &Self::Memo,
     ) -> NotePlaintextBytes {
+        let is_native: bool = note.note_type().is_native().into();
+
         let mut np = [0; NOTE_PLAINTEXT_SIZE];
-        np[0] = 0x02;
+        np[0] = if is_native { 0x02 } else { 0x03 };
         np[1..12].copy_from_slice(note.recipient().diversifier().as_array());
         np[12..20].copy_from_slice(&note.value().to_bytes());
         // todo: add note_type
         np[20..52].copy_from_slice(note.rseed().as_bytes());
-        np[52..].copy_from_slice(memo);
+        if is_native {
+            np[52..].copy_from_slice(memo);
+        } else {
+            let zsa_type = note.note_type().to_bytes();
+            np[52..84].copy_from_slice(&zsa_type);
+            let short_memo = &memo[0..memo.len() - ZSA_TYPE_SIZE];
+            np[84..].copy_from_slice(short_memo);
+            // TODO: handle full-size memo or make short_memo explicit.
+        };
         NotePlaintextBytes(np)
     }
 
@@ -242,9 +275,20 @@ impl Domain for OrchardDomain {
     }
 
     fn extract_memo(&self, plaintext: &NotePlaintextBytes) -> Self::Memo {
-        plaintext.0[COMPACT_NOTE_SIZE..NOTE_PLAINTEXT_SIZE]
-            .try_into()
-            .unwrap()
+        let mut memo = [0; MEMO_SIZE];
+        match get_note_version(plaintext) {
+            0x02 => {
+                let full_memo = &plaintext.0[COMPACT_NOTE_SIZE..NOTE_PLAINTEXT_SIZE];
+                memo.copy_from_slice(full_memo);
+            }
+            0x03 => {
+                // ZSA note plaintext have a shorter memo.
+                let short_memo = &plaintext.0[COMPACT_ZSA_NOTE_SIZE..NOTE_PLAINTEXT_SIZE];
+                memo[..ZSA_MEMO_SIZE].copy_from_slice(short_memo);
+            }
+            _ => {}
+        };
+        memo
     }
 
     fn extract_pk_d(out_plaintext: &OutPlaintextBytes) -> Option<Self::DiversifiedTransmissionKey> {
@@ -272,6 +316,10 @@ impl BatchDomain for OrchardDomain {
     }
 }
 
+fn get_note_version(plaintext: &NotePlaintextBytes) -> u8 {
+    plaintext.0[0]
+}
+
 /// Implementation of in-band secret distribution for Orchard bundles.
 pub type OrchardNoteEncryption = zcash_note_encryption::NoteEncryption<OrchardDomain>;
 
@@ -294,7 +342,7 @@ pub struct CompactAction {
     nullifier: Nullifier,
     cmx: ExtractedNoteCommitment,
     ephemeral_key: EphemeralKeyBytes,
-    enc_ciphertext: [u8; 52],
+    enc_ciphertext: [u8; COMPACT_NOTE_SIZE],
 }
 
 impl fmt::Debug for CompactAction {
@@ -309,7 +357,7 @@ impl<T> From<&Action<T>> for CompactAction {
             nullifier: *action.nullifier(),
             cmx: *action.cmx(),
             ephemeral_key: action.ephemeral_key(),
-            enc_ciphertext: action.encrypted_note().enc_ciphertext[..52]
+            enc_ciphertext: action.encrypted_note().enc_ciphertext[..COMPACT_NOTE_SIZE]
                 .try_into()
                 .unwrap(),
         }
@@ -354,13 +402,13 @@ impl CompactAction {
 
 #[cfg(test)]
 mod tests {
+    use proptest::prelude::*;
     use rand::rngs::OsRng;
     use zcash_note_encryption::{
-        try_compact_note_decryption, try_note_decryption, try_output_recovery_with_ovk,
+        try_compact_note_decryption, try_note_decryption, try_output_recovery_with_ovk, Domain,
         EphemeralKeyBytes,
     };
 
-    use super::{prf_ock_orchard, CompactAction, OrchardDomain, OrchardNoteEncryption};
     use crate::note::NoteType;
     use crate::{
         action::Action,
@@ -368,12 +416,55 @@ mod tests {
             DiversifiedTransmissionKey, Diversifier, EphemeralSecretKey, IncomingViewingKey,
             OutgoingViewingKey, PreparedIncomingViewingKey,
         },
-        note::{ExtractedNoteCommitment, Nullifier, RandomSeed, TransmittedNoteCiphertext},
+        note::{
+            testing::arb_note, ExtractedNoteCommitment, Nullifier, RandomSeed,
+            TransmittedNoteCiphertext,
+        },
         primitives::redpallas,
         value::{NoteValue, ValueCommitment},
         Address, Note,
     };
 
+    use super::{get_note_version, orchard_parse_note_plaintext_without_memo};
+    use super::{prf_ock_orchard, CompactAction, OrchardDomain, OrchardNoteEncryption};
+
+    proptest! {
+    #[test]
+    fn test_encoding_roundtrip(
+        note in arb_note(NoteValue::from_raw(10)),
+    ) {
+        let memo = &crate::test_vectors::note_encryption::test_vectors()[0].memo;
+
+        // Encode.
+        let plaintext = OrchardDomain::note_plaintext_bytes(&note, &note.recipient(), memo);
+
+        // Decode.
+        let domain = OrchardDomain { rho: note.rho() };
+        let parsed_version = get_note_version(&plaintext);
+        let parsed_memo = domain.extract_memo(&plaintext);
+
+        let (parsed_note, parsed_recipient) = orchard_parse_note_plaintext_without_memo(&domain, &plaintext.0,
+            |diversifier| {
+                assert_eq!(diversifier, &note.recipient().diversifier());
+                Some(*note.recipient().pk_d())
+            }
+        ).expect("Plaintext parsing failed");
+
+        // Check.
+        assert_eq!(parsed_note, note);
+        assert_eq!(parsed_recipient, note.recipient());
+        if parsed_note.note_type().is_native().into() {
+            assert_eq!(parsed_version, 0x02);
+            assert_eq!(&parsed_memo, memo);
+        } else {
+            assert_eq!(parsed_version, 0x03);
+            let mut short_memo = *memo;
+            short_memo[512 - 32..].copy_from_slice(&[0; 32]);
+            assert_eq!(parsed_memo, short_memo);
+        }
+    }
+    }
+
     #[test]
     fn test_vectors() {
         let test_vectors = crate::test_vectors::note_encryption::test_vectors();
@@ -417,7 +508,17 @@ mod tests {
             assert_eq!(ock.as_ref(), tv.ock);
 
             let recipient = Address::from_parts(d, pk_d);
+<<<<<<< HEAD
             let note = Note::from_parts(recipient, value, NoteType::native(), rho, rseed).unwrap();
+=======
+
+            let note_type = match tv.note_type {
+                None => NoteType::native(),
+                Some(type_bytes) => NoteType::from_bytes(&type_bytes).unwrap(),
+            };
+
+            let note = Note::from_parts(recipient, value, note_type, rho, rseed);
+>>>>>>> ZSA note encryption in Orchard crate (#3)
             assert_eq!(ExtractedNoteCommitment::from(note.commitment()), cmx);
 
             let action = Action::from_parts(
@@ -456,7 +557,8 @@ mod tests {
                     assert_eq!(decrypted_note, note);
                     assert_eq!(decrypted_to, recipient);
                 }
-                None => panic!("Compact note decryption failed"),
+                None => assert!(tv.note_type.is_some(), "Compact note decryption failed"),
+                // Ignore that ZSA notes are not detected in compact decryption.
             }
 
             match try_output_recovery_with_ovk(&domain, &ovk, &action, &cv_net, &tv.c_out) {
diff --git a/src/test_vectors/note_encryption.rs b/src/test_vectors/note_encryption.rs
index 10ac4f5e0..7d2b7c960 100644
--- a/src/test_vectors/note_encryption.rs
+++ b/src/test_vectors/note_encryption.rs
@@ -1,4 +1,4 @@
-//! Test vectors for Orchard key components.
+// From https://github.com/zcash-hackworks/zcash-test-vectors/ (orchard_note_encryption)
 
 pub(crate) struct TestVector {
     pub(crate) incoming_viewing_key: [u8; 64],
@@ -20,10 +20,10 @@ pub(crate) struct TestVector {
     pub(crate) ock: [u8; 32],
     pub(crate) op: [u8; 64],
     pub(crate) c_out: [u8; 80],
+    pub(crate) note_type: Option<[u8; 32]>,
 }
 
 pub(crate) fn test_vectors() -> Vec<TestVector> {
-    // From https://github.com/zcash-hackworks/zcash-test-vectors/blob/master/orchard_note_encryption.py
     vec![
         TestVector {
             incoming_viewing_key: [
@@ -97,34 +97,34 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xc1, 0x3e, 0x71, 0x01,
             ],
             rho: [
-                0xc5, 0x96, 0xfb, 0xd3, 0x2e, 0xbb, 0xcb, 0xad, 0xae, 0x60, 0xd2, 0x85, 0xc7, 0xd7,
-                0x5f, 0xa8, 0x36, 0xf9, 0xd2, 0xfa, 0x86, 0x10, 0x0a, 0xb8, 0x58, 0xea, 0x2d, 0xe1,
-                0xf1, 0x1c, 0x83, 0x06,
+                0xca, 0x1f, 0xeb, 0x30, 0xca, 0x11, 0x17, 0x76, 0xc0, 0x41, 0x74, 0x66, 0xbd, 0x69,
+                0xb3, 0xd2, 0x13, 0x88, 0x2e, 0xef, 0x55, 0xe6, 0x0b, 0x6d, 0x9e, 0x2a, 0x98, 0xe7,
+                0x05, 0xee, 0xf3, 0x27,
             ],
             cmx: [
-                0xa5, 0x70, 0x6f, 0x3d, 0x1b, 0x68, 0x8e, 0x9d, 0xc6, 0x34, 0xee, 0xe4, 0xe6, 0x5b,
-                0x02, 0x8a, 0x43, 0xee, 0xae, 0xd2, 0x43, 0x5b, 0xea, 0x2a, 0xe3, 0xd5, 0x16, 0x05,
-                0x75, 0xc1, 0x1a, 0x3b,
+                0x23, 0x75, 0x7c, 0x51, 0x58, 0x21, 0xcb, 0xc1, 0x84, 0x3c, 0x9a, 0x45, 0x7b, 0x7e,
+                0x6a, 0xe6, 0x01, 0xad, 0xd2, 0xea, 0x10, 0xb9, 0xc8, 0x6d, 0x6b, 0x31, 0x7c, 0xe2,
+                0xf1, 0x7b, 0xd9, 0x21,
             ],
             esk: [
-                0x56, 0x66, 0x9d, 0x64, 0x3f, 0x78, 0x0b, 0x6a, 0xd8, 0xb3, 0xd3, 0x5a, 0xd7, 0x46,
-                0x8a, 0xaa, 0x73, 0x27, 0x66, 0x57, 0x5f, 0x84, 0xa9, 0x5d, 0x20, 0xa6, 0x25, 0xff,
-                0x38, 0x77, 0xea, 0x3f,
+                0x5b, 0xfe, 0x46, 0x9c, 0x33, 0xe4, 0x47, 0xba, 0x45, 0x6b, 0x8b, 0xfe, 0x9b, 0x38,
+                0x5b, 0x39, 0x31, 0xb4, 0xba, 0xeb, 0x8f, 0x70, 0x23, 0xfe, 0x8e, 0x33, 0x35, 0x4f,
+                0xff, 0xf1, 0xbd, 0x1a,
             ],
             ephemeral_key: [
-                0xad, 0xdb, 0x47, 0xb6, 0xac, 0x5d, 0xfc, 0x16, 0x55, 0x89, 0x23, 0xd3, 0xa8, 0xf3,
-                0x76, 0x09, 0x5c, 0x69, 0x5c, 0x04, 0x7c, 0x4e, 0x32, 0x66, 0xae, 0x67, 0x69, 0x87,
-                0xf7, 0xe3, 0x13, 0x81,
+                0x8a, 0x5e, 0x13, 0x2c, 0x3a, 0x07, 0x04, 0xf2, 0x45, 0x6f, 0xbd, 0x77, 0x7a, 0x13,
+                0xd6, 0xec, 0x57, 0x65, 0x56, 0x71, 0xdb, 0x07, 0x2a, 0x7d, 0x27, 0x6a, 0xd9, 0x69,
+                0xf5, 0xec, 0x45, 0x17,
             ],
             shared_secret: [
-                0x30, 0x3c, 0x1c, 0x3f, 0x2b, 0xcb, 0xb9, 0xd8, 0x49, 0x70, 0x15, 0xa6, 0xdf, 0xca,
-                0x95, 0x4e, 0xce, 0x0d, 0x3b, 0x6c, 0xf1, 0x0a, 0xb9, 0xf7, 0x19, 0xeb, 0x89, 0x19,
-                0x9e, 0xdf, 0xe9, 0x89,
+                0x36, 0xd5, 0x4c, 0xab, 0xc6, 0x7f, 0x6c, 0xc7, 0x26, 0xa7, 0x30, 0xf3, 0xa0, 0xce,
+                0xed, 0x58, 0x53, 0xf0, 0x8c, 0xd3, 0x81, 0x46, 0xc8, 0x34, 0x25, 0x98, 0x98, 0x7c,
+                0x21, 0x50, 0x48, 0xa5,
             ],
             k_enc: [
-                0xef, 0x9d, 0x62, 0x25, 0x68, 0x7c, 0x2c, 0x91, 0x7b, 0x5c, 0xad, 0xa1, 0x75, 0x23,
-                0xe8, 0xfb, 0xdb, 0x08, 0x82, 0x25, 0xaf, 0x2d, 0xb5, 0x72, 0xbb, 0x40, 0x0e, 0x44,
-                0x8b, 0x5e, 0xa8, 0x71,
+                0x82, 0xc4, 0x32, 0x65, 0x33, 0x7f, 0x1a, 0xb3, 0x7b, 0x18, 0xdf, 0x27, 0x75, 0x48,
+                0x61, 0x82, 0x63, 0xb8, 0x02, 0x4d, 0x9b, 0x14, 0x5a, 0x05, 0xad, 0xe2, 0xeb, 0x54,
+                0x79, 0x18, 0x03, 0x20,
             ],
             p_enc: [
                 0x02, 0x56, 0xe8, 0x4b, 0x1a, 0xdc, 0x94, 0x23, 0xc3, 0x67, 0x6c, 0x04, 0x8d, 0x5f,
@@ -170,69 +170,70 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xee, 0xcc, 0x40, 0xa9,
             ],
             c_enc: [
-                0x1a, 0x9a, 0xdb, 0x14, 0x24, 0x98, 0xe3, 0xdc, 0xc7, 0x6f, 0xed, 0x77, 0x86, 0x14,
-                0xdd, 0x31, 0x6c, 0x02, 0xfb, 0xb8, 0xba, 0x92, 0x44, 0xae, 0x4c, 0x2e, 0x32, 0xa0,
-                0x7d, 0xae, 0xec, 0xa4, 0x12, 0x26, 0xb9, 0x8b, 0xfe, 0x74, 0xf9, 0xfc, 0xb2, 0x28,
-                0xcf, 0xc1, 0x00, 0xf3, 0x18, 0x0f, 0x57, 0x75, 0xec, 0xe3, 0x8b, 0xe7, 0xed, 0x45,
-                0xd9, 0x40, 0x21, 0xf4, 0x40, 0x1b, 0x2a, 0x4d, 0x75, 0x82, 0xb4, 0x28, 0xd4, 0x9e,
-                0xc7, 0xf5, 0xb5, 0xa4, 0x98, 0x97, 0x3e, 0x60, 0xe3, 0x8e, 0x74, 0xf5, 0xc3, 0xe5,
-                0x77, 0x82, 0x7c, 0x38, 0x28, 0x57, 0xd8, 0x16, 0x6b, 0x54, 0xe6, 0x4f, 0x66, 0xef,
-                0x5c, 0x7e, 0x8c, 0x9b, 0xaa, 0x2a, 0x3f, 0xa9, 0xe3, 0x7d, 0x08, 0x77, 0x17, 0xd5,
-                0xe9, 0x6b, 0xc2, 0xf7, 0x3d, 0x03, 0x14, 0x50, 0xdc, 0x24, 0x32, 0xba, 0x49, 0xd8,
-                0xb7, 0x4d, 0xb2, 0x13, 0x09, 0x9e, 0xa9, 0xba, 0x04, 0xeb, 0x63, 0xb6, 0x57, 0x4d,
-                0x46, 0xc0, 0x3c, 0xe7, 0x90, 0x0d, 0x4a, 0xc4, 0xbb, 0x18, 0x8e, 0xe9, 0x03, 0x0d,
-                0x7f, 0x69, 0xc8, 0x95, 0xa9, 0x4f, 0xc1, 0x82, 0xf2, 0x25, 0xa9, 0x4f, 0x0c, 0xde,
-                0x1b, 0x49, 0x88, 0x68, 0x71, 0xa3, 0x76, 0x34, 0x1e, 0xa9, 0x41, 0x71, 0xbe, 0xfd,
-                0x95, 0xa8, 0x30, 0xfa, 0x18, 0x40, 0x70, 0x97, 0xdc, 0xa5, 0x11, 0x02, 0x54, 0x63,
-                0xd4, 0x37, 0xe9, 0x69, 0x5c, 0xaa, 0x07, 0x9a, 0x2f, 0x68, 0xcd, 0xc7, 0xf2, 0xc1,
-                0x32, 0x67, 0xbf, 0xf4, 0x19, 0x51, 0x37, 0xfa, 0x89, 0x53, 0x25, 0x2a, 0x81, 0xb2,
-                0xaf, 0xa1, 0x58, 0x2b, 0x9b, 0xfb, 0x4a, 0xc9, 0x60, 0x37, 0xed, 0x29, 0x91, 0xd3,
-                0xcb, 0xc7, 0xd5, 0x4a, 0xff, 0x6e, 0x62, 0x1b, 0x06, 0xa7, 0xb2, 0xb9, 0xca, 0xf2,
-                0x95, 0x5e, 0xfa, 0xf4, 0xea, 0x8e, 0xfc, 0xfd, 0x02, 0x3a, 0x3c, 0x17, 0x48, 0xdf,
-                0x3c, 0xbd, 0x43, 0xe0, 0xb9, 0xa8, 0xb0, 0x94, 0x56, 0x88, 0xd5, 0x20, 0x56, 0xc1,
-                0xd1, 0x6e, 0xea, 0x37, 0xe7, 0x98, 0xba, 0x31, 0xdc, 0x3e, 0x5d, 0x49, 0x52, 0xbd,
-                0x51, 0xec, 0x76, 0x9d, 0x57, 0x88, 0xb6, 0xe3, 0x5f, 0xe9, 0x04, 0x2b, 0x95, 0xd4,
-                0xd2, 0x17, 0x81, 0x40, 0x0e, 0xaf, 0xf5, 0x86, 0x16, 0xad, 0x56, 0x27, 0x96, 0x63,
-                0x6a, 0x50, 0xb8, 0xed, 0x6c, 0x7f, 0x98, 0x1d, 0xc7, 0xba, 0x81, 0x4e, 0xff, 0x15,
-                0x2c, 0xb2, 0x28, 0xa2, 0xea, 0xd2, 0xf8, 0x32, 0x66, 0x2f, 0xa4, 0xa4, 0xa5, 0x07,
-                0x97, 0xb0, 0xf8, 0x5b, 0x62, 0xd0, 0x8b, 0x1d, 0xd2, 0xd8, 0xe4, 0x3b, 0x4a, 0x5b,
-                0xfb, 0xb1, 0x59, 0xed, 0x57, 0x8e, 0xf7, 0x47, 0x5d, 0xe0, 0xad, 0xa1, 0x3e, 0x17,
-                0xad, 0x87, 0xcc, 0x23, 0x05, 0x67, 0x2b, 0xcc, 0x55, 0xa8, 0x88, 0x13, 0x17, 0xfd,
-                0xc1, 0xbf, 0xc4, 0x59, 0xb6, 0x8b, 0x2d, 0xf7, 0x0c, 0xad, 0x37, 0x70, 0xed, 0x0f,
-                0xd0, 0x2d, 0x64, 0xb9, 0x6f, 0x2b, 0xbf, 0x6f, 0x8f, 0x63, 0x2e, 0x86, 0x6c, 0xa5,
-                0xd1, 0x96, 0xd2, 0x48, 0xad, 0x05, 0xc3, 0xde, 0x64, 0x41, 0x48, 0xa8, 0x0b, 0x51,
-                0xad, 0xa9, 0x5b, 0xd0, 0x8d, 0x73, 0xcd, 0xbb, 0x45, 0x26, 0x4f, 0x3b, 0xd1, 0x13,
-                0x83, 0x5b, 0x46, 0xf9, 0xbe, 0x7b, 0x6d, 0x23, 0xa4, 0x3b, 0xdd, 0xfe, 0x1e, 0x74,
-                0x08, 0xc9, 0x70, 0x31, 0xe1, 0xa8, 0x21, 0x4b, 0xab, 0x46, 0x39, 0x10, 0x44, 0xb7,
-                0x00, 0xd3, 0x8f, 0x51, 0x92, 0xc5, 0x7f, 0xe6, 0xf8, 0x71, 0x59, 0xb5, 0x55, 0x12,
-                0x09, 0x4e, 0x29, 0xd2, 0xce, 0xba, 0xb8, 0x68, 0xc8, 0xf1, 0xad, 0xba, 0xd5, 0x70,
-                0x77, 0xcb, 0xeb, 0x5e, 0x69, 0x65, 0x85, 0x82, 0xbf, 0x98, 0xd1, 0x9d, 0x64, 0xf4,
-                0x4b, 0x0d, 0x50, 0xc7, 0xe2, 0x20, 0x9a, 0xb3, 0xfc, 0x56, 0xb4, 0xf4, 0x09, 0x12,
-                0x3a, 0xae, 0xb0, 0x26, 0x3a, 0x22, 0x45, 0x1b, 0xc1, 0x4e, 0xd7, 0x56, 0xd0, 0x48,
-                0x38, 0x5a, 0xed, 0xbb, 0x86, 0xa8, 0x46, 0x77, 0xbb, 0x2d, 0x21, 0xc5, 0x2c, 0xc9,
-                0x49, 0x41, 0x47, 0xbf, 0x0f, 0xb1, 0x02, 0x74, 0x52, 0x82, 0x99, 0x09, 0x09, 0x72,
-                0x62, 0x28, 0x18, 0x6e, 0x02, 0xc8,
+                0x93, 0xe0, 0x48, 0x74, 0xb5, 0x83, 0x7c, 0x26, 0x1d, 0xaf, 0x1a, 0x27, 0xb7, 0x83,
+                0xec, 0x48, 0x65, 0xd3, 0xbb, 0x72, 0x8e, 0xb1, 0x61, 0xda, 0xed, 0xb8, 0x44, 0x6a,
+                0xb3, 0x8f, 0x07, 0x8e, 0xa8, 0x66, 0x2e, 0x4d, 0x2e, 0x9d, 0x00, 0xa3, 0x95, 0x27,
+                0xdc, 0xde, 0x51, 0x7a, 0xc3, 0xdb, 0xf9, 0xd2, 0x7e, 0x3c, 0x79, 0xfa, 0x88, 0x1a,
+                0xbb, 0x48, 0xb7, 0x0d, 0xbc, 0x28, 0xdd, 0xf4, 0xaf, 0x81, 0xae, 0xed, 0x2a, 0x29,
+                0x86, 0x00, 0x51, 0x08, 0x48, 0xed, 0xbd, 0xc4, 0x2e, 0x88, 0x95, 0x48, 0x70, 0xd5,
+                0xd6, 0x01, 0xcd, 0xf2, 0x90, 0x18, 0x1b, 0x53, 0x91, 0x05, 0xb9, 0xf6, 0x13, 0x86,
+                0xcb, 0x07, 0x84, 0x6b, 0xc8, 0xe3, 0x19, 0xdf, 0xab, 0x8e, 0x10, 0x97, 0x66, 0xa2,
+                0x8c, 0x1e, 0x0b, 0xbf, 0x91, 0x32, 0x02, 0xce, 0xcd, 0x1b, 0x48, 0x17, 0xa2, 0x28,
+                0x2f, 0xc2, 0x9e, 0xd4, 0x4d, 0x9b, 0x04, 0x04, 0x9d, 0xe5, 0x5a, 0xcf, 0x54, 0x99,
+                0xe5, 0xf5, 0x65, 0xd4, 0x8b, 0x8f, 0x19, 0x72, 0xc0, 0x43, 0x84, 0x77, 0x96, 0x23,
+                0x0d, 0xc6, 0x8f, 0x32, 0x57, 0xc0, 0x85, 0x29, 0x14, 0x8c, 0x8e, 0x0c, 0x32, 0x7b,
+                0x25, 0xb4, 0x59, 0x87, 0x7c, 0xde, 0xd9, 0x8f, 0xf7, 0x8e, 0x81, 0xfa, 0x69, 0x2e,
+                0x14, 0xf8, 0xfd, 0xa1, 0xfe, 0x52, 0x4f, 0xf1, 0x50, 0x18, 0x1f, 0x73, 0x6e, 0xd3,
+                0xa8, 0x8e, 0xc7, 0x89, 0xdc, 0x15, 0x95, 0x4a, 0x02, 0x63, 0x9a, 0x8a, 0x20, 0xca,
+                0x38, 0xd8, 0x99, 0xbf, 0xd1, 0xc5, 0x73, 0xb0, 0x41, 0xee, 0x7b, 0xf2, 0x2b, 0x96,
+                0x75, 0xbd, 0xa8, 0xc4, 0xb0, 0x58, 0xa0, 0x5a, 0x49, 0x33, 0x03, 0xb1, 0x1f, 0x35,
+                0x81, 0xc1, 0x9d, 0x2d, 0xa9, 0x96, 0x6a, 0x71, 0x06, 0x6e, 0xc1, 0x7d, 0xcc, 0xd3,
+                0x48, 0x20, 0x7e, 0xb3, 0x14, 0xf6, 0xcf, 0xc9, 0xd0, 0x6a, 0x62, 0x14, 0xc6, 0x72,
+                0x10, 0x97, 0xa5, 0x2e, 0x27, 0x76, 0x66, 0x7c, 0x6b, 0xe9, 0xc8, 0x86, 0x2b, 0x17,
+                0x3d, 0xb0, 0xe8, 0x04, 0xb1, 0x2c, 0xaa, 0xe9, 0xd9, 0xfa, 0x09, 0xf3, 0xf4, 0x8c,
+                0xaf, 0x4b, 0xf7, 0x56, 0xa2, 0x78, 0x95, 0x0a, 0x25, 0x4e, 0xc4, 0x14, 0x76, 0x77,
+                0xaa, 0xca, 0x21, 0x42, 0x96, 0x08, 0x1a, 0x2f, 0x62, 0x4a, 0x92, 0x78, 0x94, 0x6e,
+                0x68, 0x9d, 0xd9, 0x14, 0x02, 0x90, 0x92, 0xe7, 0xfa, 0x8f, 0xbc, 0x8a, 0x04, 0x46,
+                0x7d, 0x60, 0xed, 0xff, 0x5d, 0x97, 0xcb, 0x65, 0x09, 0xa0, 0xc7, 0x2c, 0xed, 0x77,
+                0xac, 0xa8, 0x71, 0x30, 0x8e, 0x7d, 0xe2, 0xbe, 0xb1, 0x52, 0x0a, 0x34, 0x17, 0xd7,
+                0x21, 0x3a, 0x9a, 0xbd, 0x47, 0x35, 0x8c, 0x4f, 0x32, 0x9f, 0x0f, 0x64, 0x41, 0x92,
+                0x10, 0xa9, 0x9d, 0xb2, 0xde, 0x6e, 0x6d, 0x89, 0x21, 0xb0, 0xf4, 0xf9, 0x9f, 0xd6,
+                0x45, 0xfa, 0xe0, 0xd6, 0x29, 0xce, 0x22, 0x11, 0x90, 0x5f, 0x25, 0xf4, 0x0d, 0x12,
+                0x0b, 0x63, 0x27, 0x93, 0x75, 0xb5, 0x43, 0xc3, 0x1e, 0x3b, 0x55, 0x7e, 0x57, 0xa7,
+                0xa8, 0x7c, 0x61, 0x79, 0xeb, 0xd3, 0x4f, 0x6d, 0xbb, 0x92, 0x0e, 0xc5, 0xe0, 0x5d,
+                0x6a, 0x77, 0xec, 0xdf, 0x36, 0xb4, 0x57, 0xba, 0xb4, 0x56, 0x6c, 0x40, 0x8f, 0xb5,
+                0x7d, 0xfc, 0xdd, 0xda, 0xa4, 0x2c, 0x51, 0x34, 0xaf, 0x3e, 0x97, 0x8d, 0xbf, 0xd0,
+                0xdf, 0xb0, 0xca, 0x4f, 0xfa, 0xf1, 0x65, 0x0a, 0xbe, 0xe1, 0x62, 0x5f, 0x7f, 0x4b,
+                0xf8, 0x25, 0x06, 0x01, 0x00, 0x64, 0x5b, 0x54, 0xc0, 0x04, 0x1f, 0xbf, 0xbd, 0xef,
+                0xf7, 0xb9, 0x38, 0x04, 0xe9, 0xcc, 0x0c, 0xcd, 0x6f, 0x27, 0xbe, 0x40, 0x01, 0x6c,
+                0x32, 0xd4, 0x2f, 0xe3, 0x66, 0xfa, 0xaa, 0x86, 0x87, 0xc2, 0xd1, 0x92, 0x61, 0x9f,
+                0x56, 0x5b, 0x0c, 0x70, 0xea, 0x6a, 0x3f, 0x79, 0xd5, 0x3a, 0x52, 0x41, 0xe6, 0x9c,
+                0x3c, 0xa6, 0x87, 0xa1, 0x12, 0xfb, 0x16, 0xc2, 0x5c, 0xc0, 0x83, 0x17, 0xdb, 0xa4,
+                0x23, 0x97, 0x0c, 0x32, 0xdf, 0xb4, 0xbd, 0x69, 0x22, 0xe3, 0x36, 0xab, 0xf2, 0xfd,
+                0xe2, 0xc3, 0xaa, 0x5d, 0xb2, 0x93, 0xef, 0x27, 0x47, 0x87, 0x6c, 0x8b, 0xd8, 0x6e,
+                0xa1, 0x87, 0xcb, 0x60, 0x1a, 0xf7,
             ],
             ock: [
-                0x4e, 0x9d, 0x45, 0x94, 0x6b, 0x3e, 0xea, 0xe7, 0xfe, 0x30, 0x5d, 0x5b, 0x90, 0x50,
-                0x36, 0x14, 0x1f, 0x9f, 0x40, 0x09, 0xa6, 0x29, 0x4b, 0x96, 0xc7, 0x22, 0xa4, 0xa0,
-                0xbe, 0x68, 0x5d, 0xff,
+                0xb3, 0x25, 0xeb, 0xe5, 0x7a, 0x2c, 0x40, 0xa8, 0xb2, 0x11, 0xcf, 0xdf, 0x72, 0xa1,
+                0xa2, 0x44, 0xf1, 0x53, 0x42, 0x85, 0x98, 0x88, 0xa3, 0x64, 0x52, 0x3e, 0xfd, 0x2a,
+                0xc6, 0x6a, 0x1a, 0xd6,
             ],
             op: [
                 0x63, 0xf7, 0x12, 0x5d, 0xf4, 0x83, 0x6f, 0xd2, 0x81, 0x6b, 0x02, 0x4e, 0xe7, 0x0e,
                 0xfe, 0x09, 0xfb, 0x9a, 0x7b, 0x38, 0x63, 0xc6, 0xea, 0xcd, 0xf9, 0x5e, 0x03, 0x89,
-                0x49, 0x50, 0x69, 0x2c, 0x56, 0x66, 0x9d, 0x64, 0x3f, 0x78, 0x0b, 0x6a, 0xd8, 0xb3,
-                0xd3, 0x5a, 0xd7, 0x46, 0x8a, 0xaa, 0x73, 0x27, 0x66, 0x57, 0x5f, 0x84, 0xa9, 0x5d,
-                0x20, 0xa6, 0x25, 0xff, 0x38, 0x77, 0xea, 0x3f,
+                0x49, 0x50, 0x69, 0x2c, 0x5b, 0xfe, 0x46, 0x9c, 0x33, 0xe4, 0x47, 0xba, 0x45, 0x6b,
+                0x8b, 0xfe, 0x9b, 0x38, 0x5b, 0x39, 0x31, 0xb4, 0xba, 0xeb, 0x8f, 0x70, 0x23, 0xfe,
+                0x8e, 0x33, 0x35, 0x4f, 0xff, 0xf1, 0xbd, 0x1a,
             ],
             c_out: [
-                0xcb, 0xdf, 0x68, 0xa5, 0x7f, 0xb4, 0xa4, 0x6f, 0x34, 0x60, 0xff, 0x22, 0x7b, 0xc6,
-                0x18, 0xda, 0xe1, 0x12, 0x29, 0x45, 0xb3, 0x80, 0xc7, 0xe5, 0x49, 0xcf, 0x4a, 0x6e,
-                0x8b, 0xf3, 0x75, 0x49, 0xba, 0xe1, 0x89, 0x1f, 0xd8, 0xd1, 0xa4, 0x94, 0x4f, 0xdf,
-                0x41, 0x0f, 0x07, 0x02, 0xed, 0xa5, 0x44, 0x2f, 0x0e, 0xa0, 0x1a, 0x5d, 0xf0, 0x12,
-                0xa0, 0xae, 0x4d, 0x84, 0xed, 0x79, 0x80, 0x33, 0x28, 0xbd, 0x1f, 0xd5, 0xfa, 0xc7,
-                0x19, 0x21, 0x6a, 0x77, 0x6d, 0xe6, 0x4f, 0xd1, 0x67, 0xdb,
-            ],
+                0x55, 0xb8, 0x90, 0x7c, 0x6d, 0x45, 0x4b, 0x83, 0x63, 0x4f, 0x1b, 0x9a, 0x1a, 0xa3,
+                0xc3, 0xc9, 0x8a, 0xdc, 0x77, 0xd9, 0x6c, 0x2f, 0x62, 0x49, 0xec, 0x66, 0xdb, 0xae,
+                0x4d, 0x0c, 0xc9, 0x40, 0xd7, 0x26, 0xbc, 0xd1, 0xec, 0x91, 0x18, 0x9f, 0xd3, 0x04,
+                0x9a, 0x33, 0xf2, 0xea, 0x7d, 0x8b, 0x74, 0xaa, 0xc1, 0x7c, 0xda, 0x38, 0x83, 0x80,
+                0x2d, 0xb5, 0x96, 0x9d, 0x8d, 0x2f, 0x32, 0x25, 0x91, 0x9c, 0xe3, 0x88, 0x26, 0x41,
+                0x5c, 0xc6, 0xb3, 0x38, 0x94, 0x4b, 0x48, 0x99, 0x54, 0x8b,
+            ],
+            note_type: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -306,34 +307,34 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x25, 0x7a, 0xd8, 0xb3,
             ],
             rho: [
-                0x33, 0x88, 0xda, 0x05, 0x06, 0xda, 0x9e, 0xa2, 0xd5, 0x16, 0x73, 0x9b, 0x95, 0x1c,
-                0x7c, 0xc0, 0x58, 0x53, 0x36, 0xb4, 0x4d, 0xf9, 0xb3, 0xb5, 0x0e, 0x48, 0x93, 0xe4,
-                0xb1, 0x84, 0x92, 0x11,
+                0xc1, 0xe1, 0x59, 0x5b, 0x8d, 0xe7, 0x55, 0x97, 0x66, 0xe5, 0xa6, 0x72, 0x5f, 0x5b,
+                0xe5, 0x74, 0x2f, 0x43, 0xbf, 0x40, 0x62, 0x3b, 0x71, 0x49, 0xca, 0xe2, 0x67, 0x5c,
+                0x4d, 0xb2, 0xc7, 0x31,
             ],
             cmx: [
-                0x9e, 0x04, 0x32, 0xb2, 0xb3, 0x33, 0xcd, 0xe8, 0xce, 0x92, 0x1b, 0x77, 0xca, 0x7e,
-                0x9e, 0x41, 0x51, 0xe3, 0x74, 0xd5, 0x16, 0xcd, 0xa1, 0x17, 0x63, 0x83, 0x6a, 0xf3,
-                0xb6, 0x6f, 0x5b, 0x15,
+                0x59, 0xb6, 0xf3, 0xd4, 0x03, 0x22, 0x3d, 0x6c, 0xe4, 0x3d, 0xed, 0xae, 0xe2, 0x35,
+                0xfc, 0xa9, 0x5c, 0xc8, 0xb2, 0x49, 0x94, 0x1c, 0xcd, 0xb6, 0x6f, 0x3f, 0x61, 0x1c,
+                0xc5, 0xe9, 0xf9, 0x0f,
             ],
             esk: [
-                0x68, 0x65, 0x87, 0xce, 0x53, 0xc3, 0x39, 0xf9, 0xce, 0xcf, 0x4d, 0x80, 0x4a, 0x17,
-                0x09, 0x39, 0x2b, 0x6a, 0xb1, 0x08, 0xea, 0x2c, 0x57, 0x79, 0x92, 0x1c, 0xd5, 0xda,
-                0x8a, 0x6e, 0x1a, 0x08,
+                0x10, 0x87, 0x4a, 0x74, 0x22, 0x7a, 0xc7, 0x99, 0x5e, 0xdd, 0xdd, 0x73, 0x4d, 0x0e,
+                0x00, 0xdc, 0xc9, 0xf4, 0x8a, 0x01, 0xdd, 0x5c, 0x4c, 0xb1, 0x22, 0xc0, 0x61, 0xe0,
+                0xbd, 0xc9, 0xce, 0x14,
             ],
             ephemeral_key: [
-                0x91, 0x92, 0x3e, 0xd8, 0x2b, 0x76, 0xd7, 0x97, 0x30, 0x7c, 0xaa, 0x23, 0x02, 0xc0,
-                0xcf, 0x75, 0x56, 0x12, 0x17, 0x24, 0x98, 0x67, 0x53, 0x2a, 0xe5, 0x1c, 0x2e, 0xa0,
-                0x05, 0xed, 0xad, 0xb6,
+                0xd2, 0x9e, 0x0d, 0x00, 0x1e, 0xe7, 0x1e, 0x05, 0x99, 0x08, 0x65, 0x04, 0xd8, 0x62,
+                0xc7, 0xf5, 0x2b, 0x08, 0x60, 0x77, 0x0d, 0x8a, 0x4b, 0x42, 0xa8, 0x68, 0x11, 0xac,
+                0x31, 0x69, 0x85, 0x8c,
             ],
             shared_secret: [
-                0x53, 0xd7, 0xe4, 0x84, 0x3a, 0x36, 0xd5, 0x79, 0xb5, 0xa7, 0xc1, 0x04, 0x11, 0x96,
-                0xbd, 0x4c, 0x85, 0x80, 0x5c, 0xcd, 0x0a, 0x3f, 0x95, 0xbc, 0x9e, 0x71, 0x06, 0x90,
-                0xd1, 0x1b, 0x7a, 0xaa,
+                0x11, 0xa0, 0xac, 0x79, 0x9a, 0x29, 0xb0, 0xed, 0x19, 0x5e, 0xd8, 0x7b, 0x13, 0x83,
+                0x22, 0x26, 0x3b, 0xbb, 0x9c, 0x31, 0x00, 0x8c, 0x29, 0x59, 0xaf, 0x2f, 0xc6, 0x36,
+                0x68, 0x7e, 0xd9, 0xb0,
             ],
             k_enc: [
-                0xc2, 0xe3, 0x38, 0x9d, 0x6f, 0xc3, 0xcd, 0x06, 0x7f, 0x59, 0x0a, 0x93, 0x73, 0x05,
-                0x04, 0xad, 0x9b, 0x63, 0xc4, 0x55, 0x45, 0x69, 0xb9, 0x62, 0x0f, 0x3e, 0xf0, 0xb0,
-                0x65, 0x94, 0xde, 0xd6,
+                0x4b, 0xbf, 0x80, 0xe7, 0xa1, 0x70, 0x3a, 0xc1, 0x4a, 0xd7, 0xb5, 0x44, 0x8a, 0x2e,
+                0x8e, 0x79, 0x49, 0x30, 0x49, 0xd1, 0x9a, 0x6a, 0x51, 0x31, 0x67, 0xd5, 0x5b, 0xdd,
+                0x58, 0x6a, 0xc0, 0xd9,
             ],
             p_enc: [
                 0x02, 0x55, 0x6e, 0x5e, 0x1b, 0xf5, 0x1b, 0xc6, 0xa6, 0x11, 0x58, 0xf7, 0x40, 0x50,
@@ -379,69 +380,70 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x8b, 0x1e, 0x88, 0x6f,
             ],
             c_enc: [
-                0x6d, 0x21, 0x18, 0x0a, 0xc4, 0x74, 0x94, 0x57, 0x8a, 0x90, 0x06, 0xaf, 0x5b, 0xeb,
-                0x4e, 0x34, 0x55, 0x59, 0xab, 0xdb, 0x0e, 0x23, 0xed, 0x52, 0x65, 0xaf, 0x79, 0xce,
-                0x0c, 0xc5, 0x96, 0x71, 0xea, 0x31, 0x7b, 0x3e, 0xb1, 0x52, 0x93, 0xd1, 0xe0, 0x4a,
-                0x9a, 0xd8, 0x39, 0x69, 0xab, 0x9e, 0x17, 0x08, 0xf2, 0x28, 0x85, 0x3a, 0x28, 0x1f,
-                0xcf, 0x6c, 0x97, 0x60, 0xae, 0x71, 0x96, 0x5b, 0xb1, 0xd4, 0x45, 0x2e, 0x5e, 0xd0,
-                0x06, 0x00, 0xab, 0x58, 0x94, 0x27, 0x75, 0xb7, 0x4e, 0x12, 0x62, 0xb4, 0x22, 0x5d,
-                0x3b, 0x61, 0x9c, 0x31, 0x65, 0x96, 0xd7, 0xcf, 0x9c, 0x93, 0xbd, 0xb5, 0x2a, 0xfa,
-                0x77, 0x8a, 0xa1, 0x20, 0x8d, 0x56, 0xd0, 0x69, 0xe5, 0x6e, 0x27, 0x79, 0x61, 0x4d,
-                0x56, 0xf4, 0x36, 0x10, 0x72, 0xbc, 0x15, 0x16, 0xa9, 0xb4, 0x56, 0x2a, 0x4f, 0x54,
-                0x63, 0xa5, 0x13, 0xc4, 0x59, 0x42, 0x15, 0x70, 0xf3, 0x34, 0xef, 0xb6, 0xbc, 0xd2,
-                0x08, 0xf8, 0xf8, 0x05, 0x0e, 0x15, 0x3d, 0x4e, 0x61, 0xf3, 0x1e, 0xdd, 0xbb, 0x5a,
-                0x98, 0xf1, 0x70, 0xd3, 0xd0, 0x80, 0xe8, 0xec, 0x3f, 0x65, 0x20, 0xb6, 0xa2, 0xd6,
-                0x08, 0x83, 0xa5, 0x87, 0xff, 0x0e, 0x98, 0x21, 0x1c, 0x73, 0x45, 0x16, 0xb5, 0xdc,
-                0xc7, 0x5e, 0xf2, 0x3c, 0xfb, 0x9f, 0x55, 0xf1, 0xde, 0xed, 0xf1, 0x26, 0xc2, 0xce,
-                0x17, 0x27, 0x3f, 0x41, 0xdb, 0xbb, 0xbd, 0x2f, 0x49, 0xe3, 0x55, 0x77, 0x6e, 0xc0,
-                0x46, 0x98, 0x35, 0xf7, 0x9d, 0x94, 0x80, 0x42, 0xf8, 0x42, 0x0f, 0x11, 0xe1, 0xab,
-                0xd7, 0x45, 0x06, 0xb7, 0x8b, 0x5e, 0x41, 0xcb, 0xe0, 0xc7, 0x07, 0x17, 0xf4, 0x6e,
-                0x7e, 0xb9, 0xac, 0xdc, 0x35, 0x1c, 0x94, 0x98, 0x83, 0x3a, 0xfd, 0xed, 0x93, 0x06,
-                0xa0, 0x43, 0x5b, 0x10, 0xb8, 0x3a, 0xe3, 0x95, 0xd5, 0x7f, 0x5b, 0x0a, 0x5d, 0x41,
-                0xa9, 0x34, 0x2d, 0x02, 0xec, 0x58, 0xb6, 0xee, 0x16, 0x87, 0x77, 0x50, 0x16, 0xb8,
-                0x74, 0x9b, 0x28, 0x7a, 0xbd, 0xd3, 0xed, 0x1a, 0x83, 0x5e, 0xa8, 0xf3, 0xb1, 0x4d,
-                0x08, 0x18, 0xfe, 0x0d, 0x5d, 0x9a, 0x48, 0xeb, 0x02, 0x13, 0x64, 0x0e, 0xec, 0xc1,
-                0x9a, 0x5d, 0x16, 0x61, 0xdb, 0x82, 0x2b, 0x77, 0x9b, 0x08, 0x0c, 0xd8, 0xba, 0x7f,
-                0x3a, 0x27, 0x23, 0x21, 0xee, 0x5d, 0xa2, 0x27, 0x8c, 0x53, 0x85, 0x67, 0xd0, 0xd9,
-                0xbb, 0x28, 0xce, 0x64, 0x21, 0x31, 0x15, 0x03, 0xa4, 0xa0, 0x17, 0x14, 0xcf, 0x91,
-                0x01, 0x55, 0x2b, 0xa5, 0xef, 0xc8, 0x5c, 0x94, 0xd5, 0xe5, 0x09, 0x72, 0x7e, 0x5e,
-                0x01, 0x1c, 0x15, 0xb1, 0xb2, 0xec, 0xdf, 0xf3, 0x99, 0xc0, 0xbe, 0x33, 0x42, 0xab,
-                0x6e, 0xdd, 0xa8, 0xe3, 0xed, 0x81, 0x1a, 0x7d, 0x9c, 0x9c, 0xa4, 0xbb, 0x71, 0xa5,
-                0x63, 0xe1, 0x59, 0x78, 0xbf, 0x8e, 0x64, 0x04, 0xac, 0x79, 0x6e, 0xb7, 0x81, 0xfd,
-                0x2c, 0xf2, 0x19, 0x1b, 0x2f, 0x4d, 0x40, 0x76, 0xd9, 0x3c, 0xcc, 0x80, 0xf7, 0xe5,
-                0x92, 0xfa, 0x66, 0x9b, 0x72, 0x26, 0x57, 0x82, 0xee, 0x8f, 0x5c, 0xe3, 0x03, 0x12,
-                0xd3, 0x51, 0x2b, 0x35, 0x49, 0x0a, 0xfe, 0x00, 0x6b, 0xad, 0xb1, 0x62, 0x0d, 0x1b,
-                0x0c, 0x79, 0xfb, 0xc4, 0xbe, 0xc5, 0x65, 0xd7, 0x46, 0x1d, 0x68, 0xef, 0x72, 0x27,
-                0x79, 0x11, 0x77, 0x6c, 0xd5, 0xa7, 0xb5, 0xfc, 0x6f, 0xa8, 0xb3, 0xee, 0xfd, 0x7a,
-                0x39, 0xe8, 0xe5, 0xb4, 0xf6, 0xa5, 0x0c, 0x7d, 0x58, 0xd9, 0xeb, 0x08, 0x38, 0x0d,
-                0x32, 0x0b, 0x36, 0xea, 0x04, 0x37, 0x00, 0xac, 0xa7, 0x64, 0xb4, 0x8c, 0x3d, 0xa4,
-                0x93, 0x67, 0xfa, 0x93, 0x35, 0x6a, 0xaa, 0x4f, 0x87, 0x08, 0xea, 0x6e, 0x34, 0x59,
-                0x81, 0x84, 0x5b, 0xe7, 0x37, 0x6d, 0xa7, 0x98, 0x40, 0x53, 0xef, 0x7d, 0xd4, 0xb6,
-                0xa7, 0x27, 0x92, 0x35, 0x6a, 0x6c, 0x34, 0x62, 0x68, 0x88, 0xcc, 0x70, 0xde, 0x49,
-                0x9e, 0xf9, 0x10, 0x26, 0x95, 0xd9, 0xdb, 0x12, 0xaf, 0x29, 0x62, 0xfc, 0x75, 0xd4,
-                0x36, 0x56, 0x19, 0xdb, 0x0e, 0x87, 0x6c, 0xdb, 0x82, 0x02, 0xe8, 0x16, 0xfd, 0xc2,
-                0xcd, 0xf3, 0x7a, 0xd3, 0xbe, 0x3b,
+                0x1b, 0x42, 0x34, 0x80, 0xbf, 0x37, 0x67, 0xf5, 0xeb, 0xfc, 0x40, 0xb8, 0xc8, 0x9c,
+                0xc5, 0x34, 0xf1, 0x65, 0xc3, 0x5d, 0x19, 0xc8, 0xda, 0x6c, 0x32, 0x10, 0xe9, 0x52,
+                0xca, 0xd8, 0x23, 0xa7, 0x84, 0x60, 0x21, 0xc3, 0xde, 0x4a, 0x86, 0x93, 0xb7, 0x1e,
+                0x28, 0x7f, 0x46, 0x86, 0xac, 0x0a, 0xdd, 0xce, 0xd9, 0x4e, 0xba, 0x81, 0x0a, 0x99,
+                0x8b, 0x82, 0x3a, 0x4a, 0xd2, 0x41, 0xaa, 0x9f, 0x4a, 0x3a, 0xe4, 0x82, 0x5d, 0xe9,
+                0x95, 0xdd, 0x58, 0x73, 0x56, 0x62, 0x44, 0xbb, 0xd8, 0x75, 0xd0, 0x1b, 0xf3, 0x28,
+                0xe8, 0x22, 0xca, 0xfd, 0xb8, 0x3e, 0xd7, 0x75, 0x3a, 0x88, 0x85, 0xd7, 0xae, 0xf2,
+                0x45, 0x5a, 0x15, 0x2e, 0x23, 0xdf, 0xa2, 0xd6, 0x99, 0xb3, 0x5c, 0x33, 0xd3, 0x61,
+                0x07, 0x2a, 0xe5, 0xc5, 0x12, 0x43, 0x4d, 0x34, 0x6f, 0x6c, 0x56, 0xfb, 0x5f, 0x11,
+                0xb0, 0xb6, 0x47, 0xcb, 0xca, 0xfe, 0x02, 0xd8, 0x84, 0x55, 0xa6, 0x30, 0xa3, 0x50,
+                0x86, 0x2b, 0x3c, 0xd1, 0x51, 0x3b, 0x6d, 0x6e, 0x41, 0x17, 0xc7, 0x5e, 0xc4, 0xb1,
+                0x2f, 0xd7, 0x5a, 0x90, 0xf8, 0x2d, 0xce, 0xa1, 0xc7, 0x71, 0xfd, 0xda, 0x24, 0xec,
+                0xf0, 0xa3, 0xe5, 0xb2, 0xe8, 0xa2, 0x24, 0x23, 0x6e, 0xf0, 0x9a, 0x93, 0xab, 0x59,
+                0xe5, 0x9b, 0xdf, 0xb8, 0x72, 0x86, 0x0c, 0xc2, 0xd9, 0x11, 0x34, 0xca, 0xf2, 0x13,
+                0x98, 0x48, 0xe3, 0x9a, 0xa6, 0x4b, 0xa2, 0xe6, 0xd7, 0x25, 0x20, 0x54, 0xf3, 0x7a,
+                0xd5, 0x5c, 0x2c, 0xe5, 0xf8, 0x1b, 0x33, 0xcc, 0xb6, 0x8a, 0x94, 0x73, 0x71, 0x24,
+                0x3a, 0x77, 0xe8, 0x43, 0x67, 0xd9, 0xd3, 0x5b, 0x11, 0x68, 0x14, 0x10, 0xea, 0x79,
+                0x8b, 0x03, 0x87, 0xb8, 0xf1, 0x0b, 0x1f, 0x89, 0xc6, 0x8a, 0xd1, 0xcc, 0xa9, 0xa3,
+                0xe0, 0x32, 0xf3, 0x49, 0x98, 0x79, 0xc8, 0x9a, 0xe6, 0x38, 0x2f, 0x38, 0x97, 0x22,
+                0x01, 0x1f, 0x49, 0x25, 0x14, 0x3e, 0xa8, 0x50, 0x73, 0xe4, 0xff, 0x0c, 0xcf, 0x6d,
+                0x77, 0x9b, 0xc3, 0xbf, 0x4c, 0x1b, 0x95, 0xfc, 0x7c, 0xf7, 0xf9, 0x91, 0xa2, 0x16,
+                0x2a, 0xb9, 0x45, 0x41, 0xf3, 0x99, 0x8e, 0xf6, 0xbc, 0x3f, 0xe8, 0x02, 0x54, 0xab,
+                0xa4, 0x1f, 0x15, 0x23, 0x15, 0x03, 0x45, 0x1b, 0x15, 0xe1, 0x08, 0x52, 0xf8, 0x5b,
+                0xd2, 0xd1, 0x15, 0x93, 0x53, 0x14, 0xcd, 0x80, 0xc1, 0x23, 0xbe, 0x0b, 0x53, 0x0f,
+                0xaa, 0xd6, 0xb5, 0x07, 0x49, 0x68, 0x22, 0x1d, 0xa0, 0x4b, 0x54, 0x6d, 0x96, 0x21,
+                0x63, 0x29, 0x9d, 0x52, 0xce, 0xf4, 0x1e, 0x29, 0x6d, 0xa5, 0x9c, 0xb0, 0x76, 0xdb,
+                0xe8, 0x99, 0x70, 0x4b, 0x61, 0x73, 0x0c, 0x19, 0xbd, 0x22, 0x1a, 0xd2, 0xbd, 0x29,
+                0x81, 0xea, 0x95, 0x1b, 0xe0, 0x2c, 0x9f, 0x5b, 0xdf, 0x92, 0xd9, 0x87, 0x07, 0x46,
+                0xb2, 0xa5, 0x8c, 0x3d, 0x18, 0xa7, 0xd3, 0xe5, 0xe2, 0xc6, 0x3a, 0xc2, 0x61, 0x58,
+                0x37, 0xbe, 0x1c, 0x6f, 0xe0, 0x03, 0x65, 0x6c, 0x1b, 0x3d, 0x71, 0x50, 0x5f, 0x5e,
+                0x21, 0x88, 0x10, 0x4e, 0x98, 0x91, 0x1b, 0x6a, 0x5e, 0x3f, 0x52, 0x82, 0xfa, 0xc0,
+                0xc8, 0xfa, 0x1b, 0xa3, 0x6f, 0xfc, 0x07, 0xdc, 0x7a, 0x40, 0x9d, 0xf2, 0xeb, 0xa8,
+                0xc7, 0x5f, 0x70, 0xbd, 0x59, 0xa6, 0xf0, 0x65, 0x1d, 0xc1, 0xb1, 0xb5, 0x96, 0xde,
+                0x6a, 0xce, 0xc7, 0x78, 0xe2, 0xe3, 0x2f, 0x1e, 0xd4, 0x6d, 0xf7, 0xa9, 0xae, 0xf5,
+                0x1d, 0xfe, 0x5a, 0xa5, 0x24, 0x36, 0xea, 0x07, 0xf5, 0x05, 0xd3, 0x39, 0xf2, 0x03,
+                0x45, 0x86, 0x61, 0xc8, 0x3a, 0x9a, 0x5a, 0x27, 0xaa, 0x48, 0xb5, 0xec, 0x47, 0xf8,
+                0xd6, 0x0d, 0x2a, 0x41, 0x00, 0x1f, 0xce, 0x30, 0xff, 0x75, 0x3a, 0x8a, 0x8c, 0xe4,
+                0x92, 0xef, 0xcd, 0x1f, 0x75, 0x3b, 0x7f, 0x4a, 0xd7, 0x36, 0x62, 0x64, 0x47, 0xd1,
+                0xb6, 0xf0, 0x7a, 0x61, 0x7d, 0x4b, 0xfc, 0xdb, 0x48, 0xaf, 0xef, 0x08, 0x2d, 0xae,
+                0x1d, 0x76, 0x54, 0x4e, 0x8b, 0x63, 0xad, 0xcb, 0xb6, 0x0e, 0x14, 0x96, 0x69, 0x32,
+                0x60, 0xc7, 0x20, 0xe6, 0x72, 0x1e, 0x00, 0x20, 0xef, 0xa3, 0xf8, 0xd8, 0x8d, 0x15,
+                0xb5, 0xaa, 0x48, 0xa1, 0xb2, 0x2c,
             ],
             ock: [
-                0x91, 0x36, 0x59, 0x30, 0x9e, 0xcf, 0xcd, 0xfd, 0x7e, 0x0c, 0xef, 0x23, 0xf8, 0x80,
-                0xae, 0x4c, 0xf4, 0xd8, 0xcf, 0x67, 0x78, 0xb9, 0xc4, 0xe6, 0xf4, 0xc7, 0x71, 0x7b,
-                0xf5, 0xca, 0xf0, 0x9e,
+                0xab, 0xd0, 0xc2, 0x46, 0x97, 0xe4, 0x5b, 0x8b, 0xc4, 0x83, 0x0f, 0xb1, 0x46, 0x53,
+                0x2e, 0xa0, 0xac, 0x84, 0x55, 0x81, 0xca, 0x35, 0x39, 0xd3, 0x41, 0x24, 0x73, 0x54,
+                0x09, 0xd0, 0x15, 0xac,
             ],
             op: [
                 0xb4, 0xca, 0xc5, 0x6f, 0x06, 0x2b, 0xfb, 0x2e, 0x27, 0x15, 0xea, 0xf9, 0xc8, 0xfc,
                 0xdb, 0xc2, 0x0c, 0x86, 0x79, 0x3f, 0x23, 0x57, 0xdd, 0xd0, 0x4a, 0xad, 0x39, 0xf9,
-                0x4a, 0xd7, 0xc7, 0x84, 0x68, 0x65, 0x87, 0xce, 0x53, 0xc3, 0x39, 0xf9, 0xce, 0xcf,
-                0x4d, 0x80, 0x4a, 0x17, 0x09, 0x39, 0x2b, 0x6a, 0xb1, 0x08, 0xea, 0x2c, 0x57, 0x79,
-                0x92, 0x1c, 0xd5, 0xda, 0x8a, 0x6e, 0x1a, 0x08,
+                0x4a, 0xd7, 0xc7, 0x84, 0x10, 0x87, 0x4a, 0x74, 0x22, 0x7a, 0xc7, 0x99, 0x5e, 0xdd,
+                0xdd, 0x73, 0x4d, 0x0e, 0x00, 0xdc, 0xc9, 0xf4, 0x8a, 0x01, 0xdd, 0x5c, 0x4c, 0xb1,
+                0x22, 0xc0, 0x61, 0xe0, 0xbd, 0xc9, 0xce, 0x14,
             ],
             c_out: [
-                0x4d, 0xf8, 0xda, 0x22, 0xec, 0x17, 0xf4, 0x16, 0xe0, 0x59, 0x1a, 0xac, 0xc1, 0x6b,
-                0x6d, 0xd2, 0xbb, 0xbf, 0x47, 0xbe, 0x04, 0x30, 0x3d, 0xc8, 0x85, 0xd3, 0x5a, 0xc3,
-                0xf9, 0x92, 0x3e, 0xea, 0x41, 0xf3, 0x6b, 0x3a, 0x4a, 0x5c, 0x5e, 0x73, 0x3e, 0x32,
-                0x6e, 0x96, 0xdb, 0xe5, 0x5e, 0xf9, 0xe7, 0xe8, 0x42, 0x27, 0x0c, 0xbf, 0x46, 0x7c,
-                0xdc, 0x16, 0x0e, 0xbf, 0x4f, 0x10, 0x9a, 0xd6, 0x92, 0x0a, 0x6a, 0xed, 0x4a, 0x01,
-                0x71, 0xd9, 0x06, 0xe3, 0xe8, 0x13, 0x32, 0xe6, 0xc5, 0x61,
-            ],
+                0xea, 0xdf, 0x7e, 0xeb, 0x10, 0x2d, 0xb1, 0x88, 0x58, 0x54, 0xc2, 0x9e, 0xb7, 0xb0,
+                0x5c, 0x7c, 0x96, 0xbb, 0xb8, 0x90, 0x00, 0x2c, 0x4e, 0xd1, 0x14, 0xed, 0x62, 0xf5,
+                0xf9, 0xcc, 0xb4, 0x41, 0x6b, 0x5e, 0xdd, 0xd9, 0xad, 0xb5, 0x5c, 0xe9, 0xc7, 0xa0,
+                0xd8, 0x44, 0x2b, 0xbc, 0x8a, 0xfa, 0x5c, 0x77, 0xb9, 0x90, 0xad, 0x6d, 0x46, 0x12,
+                0x4d, 0xde, 0x70, 0x49, 0x48, 0x72, 0xb2, 0x20, 0x8a, 0x7c, 0x58, 0x02, 0xdf, 0xe9,
+                0xbd, 0x1c, 0xa1, 0x9b, 0xef, 0x4b, 0x37, 0xc6, 0x13, 0xb2,
+            ],
+            note_type: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -515,34 +517,34 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xc5, 0xb3, 0x73, 0x3e,
             ],
             rho: [
-                0xbe, 0xf8, 0xcf, 0x16, 0x98, 0xe4, 0x78, 0x47, 0xd3, 0x8e, 0x1a, 0xaa, 0x88, 0x86,
-                0x10, 0x77, 0xcd, 0xb5, 0xad, 0x4c, 0xf6, 0x6f, 0xe4, 0x2f, 0xd6, 0x52, 0x57, 0x81,
-                0xb6, 0xd3, 0x4f, 0x1e,
+                0xc8, 0x8d, 0x00, 0x84, 0x84, 0xc5, 0xd7, 0x98, 0x20, 0xab, 0x68, 0xc6, 0x7d, 0x08,
+                0x36, 0x72, 0xb0, 0x7f, 0x72, 0x7d, 0x44, 0xd0, 0xcd, 0x14, 0x73, 0x88, 0x00, 0xf8,
+                0x25, 0xb9, 0xff, 0x16,
             ],
             cmx: [
-                0xd8, 0x19, 0xa6, 0x37, 0x7a, 0xce, 0x33, 0xf9, 0x21, 0xf2, 0x29, 0xf9, 0x32, 0x86,
-                0x6d, 0x9f, 0xcd, 0xb9, 0xd0, 0x42, 0x6a, 0xfa, 0xca, 0x9e, 0x60, 0x50, 0xb4, 0x7a,
-                0x83, 0x19, 0xd6, 0x0d,
+                0x0b, 0x74, 0x59, 0x61, 0x6f, 0xc6, 0x93, 0x95, 0xe6, 0x44, 0x36, 0xcf, 0x4a, 0xe9,
+                0x44, 0x1d, 0x37, 0x4b, 0x29, 0x04, 0x9e, 0x4c, 0x86, 0x22, 0x3a, 0x03, 0x83, 0xf4,
+                0xe0, 0x24, 0x69, 0x05,
             ],
             esk: [
-                0x59, 0xd1, 0x0a, 0x5b, 0x94, 0x15, 0x8a, 0x3f, 0x3a, 0x78, 0xb3, 0x5d, 0xa9, 0xc6,
-                0x27, 0xbe, 0xdf, 0x7c, 0xfb, 0x84, 0x7e, 0x3e, 0x59, 0x86, 0xec, 0x8a, 0xd7, 0xf7,
-                0x4c, 0xd9, 0xb2, 0x1b,
+                0xc4, 0x92, 0x42, 0xce, 0xe7, 0xe0, 0x86, 0x8f, 0x2a, 0x75, 0xa1, 0xc4, 0x12, 0xbc,
+                0x44, 0xd5, 0x4c, 0x97, 0x09, 0xf6, 0x59, 0xde, 0xd3, 0x26, 0x95, 0x72, 0x92, 0x93,
+                0x59, 0xe0, 0x4c, 0x3a,
             ],
             ephemeral_key: [
-                0x5b, 0xcb, 0xf9, 0xf1, 0xd7, 0xdd, 0x68, 0xe7, 0xcc, 0x6d, 0x6c, 0x78, 0x49, 0x50,
-                0xd1, 0xc2, 0xe0, 0xbe, 0x6a, 0x84, 0xa7, 0xa8, 0x8d, 0x6f, 0x7a, 0x20, 0x98, 0xc3,
-                0xdc, 0xae, 0x3f, 0x2f,
+                0x0e, 0x04, 0xd8, 0x52, 0x5d, 0xd6, 0x8f, 0x7a, 0xe8, 0x68, 0xca, 0x81, 0x1e, 0x88,
+                0x33, 0xa7, 0xf4, 0x7d, 0x7a, 0xad, 0xd3, 0x76, 0x03, 0xac, 0xe6, 0x07, 0xee, 0x6c,
+                0x86, 0x6b, 0xce, 0x23,
             ],
             shared_secret: [
-                0x37, 0x35, 0x1c, 0xe2, 0x57, 0xb2, 0x79, 0x4d, 0x86, 0xa5, 0x3d, 0x26, 0x8d, 0xc9,
-                0x00, 0x06, 0x40, 0xc2, 0x76, 0xf3, 0xf4, 0x65, 0xe1, 0xaa, 0x70, 0xbf, 0xde, 0xf4,
-                0x99, 0xa3, 0xd7, 0xaa,
+                0x4a, 0x7a, 0x54, 0xac, 0x00, 0x41, 0x95, 0x98, 0xb0, 0x76, 0x01, 0x53, 0xe2, 0x6a,
+                0xcc, 0xd2, 0x15, 0x05, 0x24, 0x16, 0x65, 0x17, 0x13, 0xee, 0xa1, 0x89, 0x19, 0xf3,
+                0xe2, 0x62, 0xd3, 0xb6,
             ],
             k_enc: [
-                0xea, 0x22, 0x99, 0x65, 0x39, 0xd3, 0x74, 0xda, 0x6a, 0x75, 0x34, 0x39, 0x5a, 0xe9,
-                0x23, 0x36, 0xfc, 0xa7, 0x85, 0x11, 0x20, 0xdd, 0x1a, 0xe4, 0x9e, 0x45, 0xb3, 0x3e,
-                0x0b, 0xed, 0xe9, 0xac,
+                0x30, 0x62, 0x6d, 0x92, 0xeb, 0x62, 0x0f, 0xd4, 0xa9, 0x28, 0xb4, 0x3f, 0xd5, 0x50,
+                0x69, 0x74, 0x71, 0x76, 0x7d, 0xe4, 0x49, 0x6c, 0xfd, 0xad, 0xb1, 0xda, 0x18, 0xfc,
+                0x0c, 0xdd, 0x5a, 0xa6,
             ],
             p_enc: [
                 0x02, 0x08, 0xab, 0x2e, 0xe9, 0x9d, 0x4d, 0x9b, 0x98, 0x3d, 0xdd, 0x22, 0x47, 0xee,
@@ -588,69 +590,70 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x55, 0x21, 0x93, 0xb1,
             ],
             c_enc: [
-                0x12, 0xd6, 0x64, 0xed, 0x05, 0xd6, 0x46, 0x26, 0x89, 0xd4, 0xf2, 0x4a, 0xee, 0x5a,
-                0x4f, 0x0f, 0x32, 0x35, 0xff, 0x11, 0x0b, 0x2d, 0xf9, 0x9f, 0x67, 0xd8, 0xc5, 0xb3,
-                0x68, 0xdd, 0x47, 0x69, 0xd8, 0x44, 0xd3, 0xdd, 0xa0, 0x3f, 0x58, 0xc5, 0x48, 0x63,
-                0x62, 0xe8, 0x90, 0x81, 0xa5, 0xdf, 0xd0, 0xa6, 0x06, 0xa3, 0x91, 0x26, 0x4b, 0x56,
-                0xca, 0x3a, 0xfc, 0x4f, 0xe0, 0xe4, 0xc3, 0x05, 0xf3, 0x07, 0x78, 0x09, 0x4a, 0x00,
-                0xb7, 0x33, 0x4b, 0xdd, 0x82, 0x45, 0xac, 0x56, 0x0e, 0xf3, 0x29, 0xbc, 0x68, 0x97,
-                0xd4, 0xd7, 0xba, 0x31, 0xac, 0x84, 0x54, 0x44, 0x1a, 0x15, 0xc8, 0xd3, 0xce, 0xcc,
-                0x71, 0x32, 0xdf, 0x0d, 0x9d, 0x0e, 0xcf, 0x92, 0x84, 0x34, 0xa0, 0xd2, 0x8c, 0x1b,
-                0x00, 0x48, 0x52, 0x01, 0xec, 0x33, 0xbe, 0x9a, 0x28, 0x74, 0xb4, 0x29, 0x6c, 0x04,
-                0x22, 0xc7, 0xe7, 0xa0, 0xa3, 0xa2, 0x2e, 0xc7, 0xe7, 0x21, 0xa4, 0x79, 0x22, 0x8d,
-                0xa2, 0x8b, 0x47, 0x37, 0xaf, 0x52, 0x06, 0xdf, 0x7d, 0x74, 0xe4, 0x84, 0xc4, 0xf7,
-                0xa8, 0x56, 0xbe, 0x8c, 0xd0, 0x4b, 0x21, 0x26, 0xb5, 0x27, 0x11, 0xe7, 0xb0, 0xaf,
-                0x75, 0xc7, 0x52, 0x84, 0xa1, 0x57, 0x20, 0x40, 0xe8, 0xad, 0xe5, 0x85, 0xe8, 0xa4,
-                0x82, 0x80, 0x03, 0x59, 0x67, 0x46, 0xc4, 0x0c, 0x9d, 0x76, 0x0d, 0x92, 0x74, 0xb1,
-                0x25, 0x42, 0x2b, 0x63, 0x48, 0x1a, 0x17, 0xff, 0xba, 0xb8, 0xc2, 0xde, 0x13, 0xb2,
-                0x19, 0xf5, 0x8a, 0x35, 0x95, 0x2d, 0x88, 0x7a, 0xed, 0xe8, 0xe0, 0x2f, 0x10, 0x33,
-                0x8c, 0x23, 0x98, 0x23, 0xfb, 0x43, 0x49, 0x51, 0x84, 0x47, 0x12, 0xf6, 0x8d, 0x6e,
-                0x4f, 0xef, 0xae, 0x2b, 0x79, 0x5b, 0xa9, 0x78, 0xe9, 0x81, 0xc1, 0x09, 0x27, 0xab,
-                0xbc, 0x16, 0x30, 0x66, 0xa0, 0xe9, 0x60, 0xb3, 0xb8, 0xa3, 0x26, 0xc0, 0x39, 0x85,
-                0x81, 0x10, 0x93, 0x99, 0xf6, 0xed, 0x60, 0x44, 0x9a, 0xa8, 0x58, 0xd5, 0xdd, 0x27,
-                0xdb, 0xf8, 0x89, 0x9f, 0x9c, 0x9a, 0x50, 0x20, 0x5f, 0x25, 0xd0, 0xcc, 0x50, 0xb2,
-                0xde, 0xe3, 0x63, 0x54, 0xc5, 0xe4, 0x48, 0x4d, 0x36, 0xf6, 0x3c, 0x97, 0x63, 0xd8,
-                0x41, 0xad, 0x5e, 0x00, 0x21, 0x63, 0x6a, 0x85, 0x7c, 0xfb, 0x79, 0xa5, 0x12, 0x3c,
-                0x3d, 0xfb, 0x77, 0x3d, 0x0c, 0x1b, 0xeb, 0x9f, 0x90, 0xa9, 0x72, 0xd0, 0xfc, 0x80,
-                0x5f, 0x65, 0x5d, 0x69, 0x40, 0x85, 0x23, 0xb9, 0x9b, 0x62, 0xa8, 0xfa, 0xbe, 0xf0,
-                0xc0, 0x24, 0xf2, 0x1f, 0x50, 0xe4, 0xc1, 0x12, 0xe2, 0xfe, 0xdd, 0x58, 0xca, 0xe9,
-                0x60, 0x9a, 0xc6, 0xf7, 0xcc, 0x79, 0x83, 0x86, 0xc9, 0xd9, 0x06, 0x42, 0x1c, 0xa5,
-                0x7c, 0xf8, 0x1b, 0x09, 0x6b, 0xba, 0xda, 0x64, 0xd0, 0xee, 0x76, 0x95, 0x18, 0x9d,
-                0x5f, 0xb1, 0x7a, 0xe2, 0x53, 0x1d, 0xbb, 0x2c, 0x00, 0x58, 0x5a, 0x26, 0xa6, 0x8c,
-                0x27, 0xf9, 0x77, 0x77, 0x84, 0x1a, 0x3e, 0x39, 0x30, 0xc7, 0x0f, 0xc3, 0xfa, 0x8e,
-                0x2b, 0x7f, 0xc2, 0x1e, 0x87, 0xcf, 0x9f, 0x63, 0xb3, 0x63, 0xb8, 0x8d, 0xaa, 0x1f,
-                0xb6, 0x7b, 0xda, 0xe8, 0xe5, 0x5b, 0x68, 0x51, 0x6d, 0x19, 0xdf, 0xef, 0xec, 0x9b,
-                0x3d, 0x38, 0xe6, 0xe1, 0xd0, 0xa6, 0xe4, 0x51, 0xd6, 0xd1, 0xf5, 0x2d, 0x1f, 0x96,
-                0xdd, 0x0d, 0x53, 0x6d, 0x68, 0xd2, 0x69, 0x86, 0x70, 0x9f, 0x41, 0xe7, 0x60, 0x74,
-                0x05, 0x5b, 0xf7, 0x52, 0xbf, 0x38, 0x86, 0x92, 0xc8, 0x2c, 0xfd, 0xa1, 0xeb, 0xb0,
-                0x17, 0x8b, 0x8e, 0x0c, 0x85, 0xad, 0x7b, 0x15, 0x99, 0x14, 0x42, 0x8e, 0x30, 0x21,
-                0xda, 0xe3, 0x01, 0x0d, 0x65, 0x6c, 0x10, 0x36, 0xf4, 0xa5, 0x7e, 0x7f, 0xad, 0xe0,
-                0xfc, 0x32, 0x2a, 0xa6, 0xfd, 0xde, 0x71, 0x4a, 0x8c, 0x53, 0x78, 0x79, 0xe7, 0x04,
-                0x41, 0x6f, 0x51, 0x04, 0xdb, 0xbc, 0x8f, 0xf2, 0x42, 0xc1, 0x6d, 0x2d, 0xf4, 0xa8,
-                0x41, 0xeb, 0x6b, 0x45, 0x3a, 0x12, 0x83, 0xf6, 0x5f, 0xe1, 0x0d, 0x70, 0xc8, 0x76,
-                0x41, 0x8e, 0x44, 0x4a, 0xb3, 0x1b, 0x93, 0x71, 0xa2, 0x7d, 0x36, 0xd8, 0x6e, 0x8f,
-                0x1c, 0x32, 0x77, 0xca, 0xfd, 0xf8,
+                0x81, 0x56, 0x2d, 0xbe, 0xf7, 0xbb, 0x35, 0x3a, 0x62, 0xe7, 0xc8, 0x1e, 0xbe, 0x68,
+                0x15, 0x6c, 0xb7, 0x5c, 0x5c, 0x7e, 0x3d, 0x96, 0xbb, 0xcd, 0x7d, 0xaf, 0xf5, 0x0c,
+                0xb0, 0x95, 0x7d, 0x33, 0xdd, 0x99, 0x77, 0x9f, 0x7d, 0x3d, 0x72, 0xb1, 0x8d, 0xeb,
+                0x7a, 0x69, 0x75, 0x10, 0xe0, 0x13, 0x5b, 0x8d, 0xf4, 0x83, 0xa4, 0xd7, 0x1d, 0x1a,
+                0xb1, 0x08, 0x09, 0x6e, 0x76, 0x08, 0x91, 0xd5, 0x31, 0x07, 0xf0, 0x3d, 0xea, 0x4a,
+                0xe8, 0xe4, 0xd3, 0xfe, 0xbd, 0x98, 0x77, 0xf8, 0x57, 0x0a, 0xa3, 0x09, 0xd0, 0x97,
+                0xd4, 0x23, 0xbb, 0x76, 0x3f, 0xb3, 0xe7, 0xe9, 0xbe, 0x3c, 0x8f, 0xa0, 0x34, 0xc0,
+                0x1d, 0x66, 0x4f, 0x47, 0xa0, 0xe7, 0x13, 0x3c, 0xa1, 0x1a, 0x48, 0xcd, 0x0e, 0xea,
+                0x46, 0x35, 0xfa, 0x77, 0x25, 0x0a, 0x17, 0xbd, 0xf7, 0xb7, 0x32, 0xc8, 0x98, 0x46,
+                0x51, 0x57, 0x4f, 0xd4, 0xf9, 0x9f, 0x7a, 0xa0, 0xdb, 0x28, 0xc2, 0x97, 0x31, 0x52,
+                0xbf, 0x42, 0x6e, 0xe9, 0xa4, 0xd8, 0x41, 0xa9, 0x1d, 0x5d, 0x33, 0x57, 0x18, 0xee,
+                0xcb, 0xc9, 0xc8, 0xb2, 0xa2, 0x00, 0x15, 0x70, 0xfe, 0x8b, 0x77, 0x91, 0x43, 0xdf,
+                0x22, 0x95, 0x98, 0xa5, 0xbe, 0x25, 0x48, 0xcf, 0x35, 0x84, 0x25, 0x18, 0xcc, 0x1d,
+                0xbc, 0x78, 0xcc, 0x2f, 0x0f, 0xc8, 0xea, 0x35, 0x7c, 0xe6, 0xc1, 0x7e, 0xb9, 0x7c,
+                0x61, 0x38, 0xd5, 0x3e, 0x6c, 0x8e, 0x00, 0xf0, 0x7f, 0x80, 0x01, 0x25, 0x18, 0x2b,
+                0x25, 0xa5, 0xe8, 0x75, 0xc5, 0x37, 0x72, 0x09, 0x52, 0x72, 0x22, 0x37, 0x1f, 0x72,
+                0xbf, 0xbd, 0x46, 0x28, 0x44, 0xab, 0x06, 0xf3, 0xb3, 0xa1, 0xeb, 0xa3, 0x44, 0x23,
+                0xb6, 0x9a, 0xbf, 0x5d, 0xe6, 0x64, 0xba, 0x83, 0xcd, 0x43, 0xb6, 0xa8, 0xe9, 0xd5,
+                0xb7, 0xc5, 0x2a, 0xdb, 0x86, 0x15, 0x04, 0x1b, 0x90, 0xd9, 0x08, 0x83, 0x1a, 0x6f,
+                0xf9, 0x2d, 0xb4, 0x8a, 0x14, 0xac, 0x4d, 0xfa, 0x67, 0xd0, 0x2c, 0x72, 0xe0, 0xc8,
+                0x63, 0x15, 0x7d, 0x98, 0xf8, 0xf5, 0x45, 0x37, 0x92, 0x97, 0x43, 0xc9, 0x69, 0xbc,
+                0x91, 0xc2, 0xc1, 0x37, 0x52, 0x04, 0x98, 0x3c, 0x99, 0x99, 0x97, 0x5f, 0xfa, 0x5e,
+                0xe5, 0xfe, 0x1f, 0x69, 0x71, 0x99, 0x40, 0x5f, 0x09, 0x66, 0xe3, 0x1f, 0x34, 0xe1,
+                0x52, 0x38, 0x44, 0x38, 0x18, 0x44, 0x98, 0x2b, 0x2c, 0x3b, 0x49, 0xa2, 0x09, 0xff,
+                0xa3, 0xce, 0xe9, 0x79, 0xa8, 0x5b, 0x19, 0xb8, 0x50, 0xf4, 0x1d, 0xcc, 0xc4, 0x63,
+                0xe2, 0x2e, 0x24, 0xa3, 0x04, 0x9d, 0x37, 0xb1, 0xfb, 0x37, 0x0d, 0xeb, 0xdd, 0xf4,
+                0xde, 0x05, 0x46, 0x24, 0x5e, 0x4f, 0x02, 0xa9, 0x84, 0x98, 0xaf, 0x53, 0x2e, 0x27,
+                0xac, 0xae, 0x5c, 0x7e, 0xd1, 0x43, 0xe6, 0xe9, 0xcc, 0xfa, 0x74, 0x35, 0x16, 0x02,
+                0x16, 0x57, 0xac, 0xb2, 0x5e, 0x44, 0x47, 0x84, 0x5c, 0x5f, 0x9c, 0x59, 0x64, 0x60,
+                0x7c, 0x4a, 0x78, 0x72, 0x1d, 0x98, 0x1a, 0x7f, 0xf2, 0xfd, 0xf6, 0xc0, 0x33, 0x62,
+                0x8b, 0xff, 0xd6, 0xf0, 0xb8, 0xde, 0x0c, 0xd6, 0x35, 0xec, 0x22, 0xf8, 0xb5, 0x0e,
+                0xd6, 0x37, 0xfe, 0x4e, 0x00, 0xf9, 0xd3, 0xc3, 0xd4, 0xf1, 0x81, 0x0b, 0x09, 0xb7,
+                0x5c, 0x96, 0xe2, 0xfc, 0xf1, 0x11, 0x85, 0x31, 0x7e, 0xdf, 0xa3, 0x9d, 0x19, 0x25,
+                0xde, 0xd8, 0x14, 0xdd, 0xe0, 0xef, 0x00, 0xa3, 0xfb, 0x47, 0xaf, 0x5d, 0x81, 0x20,
+                0x94, 0xaf, 0x13, 0xd0, 0x1c, 0x98, 0x56, 0x9f, 0xf7, 0x73, 0x57, 0x87, 0xfa, 0x9b,
+                0xd0, 0x1f, 0xa0, 0x69, 0x28, 0x27, 0x5f, 0xdd, 0x10, 0x38, 0x96, 0x5f, 0xb0, 0x6f,
+                0xb3, 0x5e, 0xdb, 0x73, 0x80, 0xdd, 0x3c, 0x42, 0x41, 0x9e, 0x0c, 0x0e, 0xde, 0x4c,
+                0x48, 0x6a, 0x9d, 0xb4, 0x95, 0x38, 0x86, 0xae, 0xc6, 0xad, 0x30, 0x70, 0x28, 0xeb,
+                0x26, 0xa3, 0x7e, 0xf4, 0x71, 0x56, 0x7a, 0xd4, 0xbd, 0x4e, 0xaa, 0xb7, 0xa8, 0x2c,
+                0xb0, 0xd6, 0xb5, 0xf0, 0x5e, 0x89, 0x4e, 0x53, 0x25, 0x82, 0x1d, 0x92, 0xbe, 0xd2,
+                0xb8, 0x6f, 0xb2, 0x43, 0x37, 0xd5, 0x79, 0x28, 0x8f, 0x6d, 0xf7, 0x34, 0x77, 0x1d,
+                0x9e, 0xf8, 0x35, 0x8b, 0xa9, 0x1a,
             ],
             ock: [
-                0xca, 0x6f, 0x98, 0xe6, 0xcf, 0x9f, 0xc3, 0x6a, 0xf5, 0xf6, 0x98, 0x82, 0x74, 0x2d,
-                0x06, 0xec, 0x5d, 0x29, 0xac, 0x2a, 0x02, 0x89, 0x44, 0xa2, 0x01, 0x89, 0xd5, 0x1c,
-                0x8a, 0x9b, 0xdc, 0xd6,
+                0xb6, 0x36, 0xc3, 0x9a, 0x6b, 0xad, 0x22, 0x63, 0xb2, 0x44, 0x1e, 0xd5, 0xbb, 0xdb,
+                0x01, 0x35, 0x88, 0xfb, 0x46, 0x27, 0x01, 0xe6, 0xf8, 0x76, 0x64, 0x6c, 0x8c, 0x17,
+                0xfa, 0x2e, 0xfd, 0xe8,
             ],
             op: [
                 0x82, 0xfe, 0xf6, 0x43, 0xdb, 0xf4, 0x2d, 0xca, 0x51, 0x56, 0xfb, 0x51, 0xd4, 0xc4,
                 0xee, 0x00, 0x8a, 0x72, 0xf0, 0xdb, 0xc3, 0xf3, 0x1e, 0xfa, 0xb0, 0x75, 0xf2, 0x75,
-                0x15, 0x37, 0x14, 0x0d, 0x59, 0xd1, 0x0a, 0x5b, 0x94, 0x15, 0x8a, 0x3f, 0x3a, 0x78,
-                0xb3, 0x5d, 0xa9, 0xc6, 0x27, 0xbe, 0xdf, 0x7c, 0xfb, 0x84, 0x7e, 0x3e, 0x59, 0x86,
-                0xec, 0x8a, 0xd7, 0xf7, 0x4c, 0xd9, 0xb2, 0x1b,
+                0x15, 0x37, 0x14, 0x0d, 0xc4, 0x92, 0x42, 0xce, 0xe7, 0xe0, 0x86, 0x8f, 0x2a, 0x75,
+                0xa1, 0xc4, 0x12, 0xbc, 0x44, 0xd5, 0x4c, 0x97, 0x09, 0xf6, 0x59, 0xde, 0xd3, 0x26,
+                0x95, 0x72, 0x92, 0x93, 0x59, 0xe0, 0x4c, 0x3a,
             ],
             c_out: [
-                0xa9, 0x5e, 0x1a, 0x22, 0x45, 0x65, 0x29, 0x5e, 0x9b, 0x55, 0x3a, 0xdd, 0xe8, 0xb0,
-                0x14, 0x47, 0x5c, 0x68, 0x7b, 0x5d, 0x13, 0x49, 0xc1, 0xdf, 0x8a, 0xd4, 0xb7, 0xcf,
-                0xd3, 0xdf, 0xc1, 0x00, 0x6c, 0x7c, 0x37, 0xde, 0x67, 0x6d, 0x6f, 0xde, 0x31, 0x8e,
-                0x2f, 0xdf, 0xcc, 0x2e, 0x2e, 0x23, 0x2c, 0xc5, 0xf8, 0x85, 0x28, 0x39, 0xe7, 0xef,
-                0xab, 0x8b, 0x20, 0x0e, 0xbc, 0x6a, 0x4d, 0xf8, 0x2a, 0x75, 0x21, 0xce, 0x0f, 0x38,
-                0x4f, 0xe2, 0x7a, 0x0d, 0xec, 0x59, 0xe9, 0xd2, 0xc0, 0xe3,
-            ],
+                0x46, 0xba, 0x14, 0xf8, 0x3f, 0xf5, 0xab, 0x76, 0x0f, 0x14, 0x20, 0xeb, 0xde, 0xd9,
+                0x86, 0xfd, 0x93, 0x78, 0x27, 0xbc, 0x05, 0x69, 0x2e, 0xca, 0xdb, 0x65, 0x2e, 0xbb,
+                0xc8, 0xf6, 0xd9, 0xb5, 0x2e, 0xc3, 0x97, 0x87, 0xd8, 0xeb, 0xdd, 0x50, 0x6c, 0xa1,
+                0xa8, 0x5d, 0xc3, 0xd5, 0xba, 0x4c, 0x5b, 0x41, 0x52, 0x61, 0xb0, 0x75, 0x3a, 0xc1,
+                0x0e, 0x01, 0x86, 0x45, 0x32, 0xa3, 0x57, 0x2c, 0x68, 0xaf, 0xe4, 0x0a, 0xc3, 0xc0,
+                0x95, 0x7b, 0x7a, 0xfc, 0x23, 0xfd, 0x5e, 0x05, 0x17, 0xaa,
+            ],
+            note_type: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -724,34 +727,34 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x32, 0xb5, 0x0e, 0x96,
             ],
             rho: [
-                0x18, 0x89, 0x8e, 0x75, 0x21, 0x7b, 0x32, 0x9b, 0x3a, 0x56, 0x7b, 0x09, 0x37, 0x89,
-                0xa4, 0xd8, 0x19, 0xcd, 0xb0, 0x34, 0x88, 0xb8, 0x10, 0xda, 0x22, 0x0c, 0x3f, 0x59,
-                0xba, 0x03, 0x39, 0x26,
+                0xa9, 0x0a, 0x9b, 0x8a, 0xb1, 0x35, 0x9d, 0xc9, 0x6b, 0xda, 0xe9, 0x0e, 0x52, 0x74,
+                0x78, 0x8c, 0xb0, 0xc4, 0x26, 0xef, 0xf2, 0x60, 0x43, 0x61, 0x85, 0x39, 0x8b, 0xff,
+                0xf5, 0x0e, 0x92, 0x37,
             ],
             cmx: [
-                0x23, 0xad, 0xc3, 0xbf, 0x35, 0x0e, 0xb0, 0x84, 0xbd, 0x28, 0xbc, 0x2d, 0xcf, 0xb7,
-                0x98, 0x3f, 0xf6, 0xb3, 0xb6, 0xf2, 0xeb, 0x2d, 0x6f, 0x12, 0x4f, 0xfc, 0x46, 0x85,
-                0xab, 0xe8, 0xde, 0x3a,
+                0x05, 0xb5, 0xe3, 0x20, 0x76, 0xda, 0xe0, 0x94, 0x83, 0x35, 0xac, 0x3d, 0x65, 0x1c,
+                0x6d, 0xbe, 0xa6, 0x4c, 0xe9, 0x11, 0x42, 0x3e, 0x2f, 0x2c, 0x7c, 0x1b, 0xdf, 0xa6,
+                0xb1, 0x41, 0x41, 0x30,
             ],
             esk: [
-                0x34, 0x39, 0x22, 0x52, 0xc9, 0xcc, 0x9f, 0x45, 0x4b, 0x54, 0x2c, 0xf1, 0xb8, 0x88,
-                0xb3, 0xab, 0x02, 0xe6, 0x05, 0xa8, 0xda, 0x26, 0x10, 0x7d, 0x98, 0x02, 0xf1, 0x53,
-                0x6a, 0x9e, 0x9f, 0x2b,
+                0x8b, 0x14, 0x62, 0x2d, 0x2f, 0x91, 0xf1, 0x69, 0x8d, 0x53, 0xfe, 0x47, 0x9a, 0x1e,
+                0x5c, 0x00, 0x64, 0x98, 0xb9, 0x8b, 0x85, 0xb4, 0x50, 0xbd, 0x92, 0x3a, 0x5d, 0x00,
+                0xcb, 0x52, 0xa6, 0x13,
             ],
             ephemeral_key: [
-                0x91, 0xaf, 0x13, 0x8e, 0xd9, 0x95, 0x44, 0x66, 0x95, 0x16, 0x1b, 0x14, 0x2d, 0xc2,
-                0xde, 0x59, 0xac, 0x23, 0x05, 0xec, 0xbe, 0xc6, 0x29, 0x33, 0xf5, 0x2f, 0x2a, 0xa1,
-                0xf9, 0xb2, 0x71, 0x86,
+                0x86, 0xee, 0x66, 0xa6, 0xc7, 0xd9, 0xb5, 0xc4, 0xf0, 0xe2, 0xd2, 0xa0, 0xe1, 0x56,
+                0x1e, 0x2a, 0xfa, 0x55, 0x41, 0xa7, 0x24, 0xee, 0x02, 0x7f, 0xc7, 0x0b, 0xb7, 0xe8,
+                0x0a, 0x2c, 0x60, 0x98,
             ],
             shared_secret: [
-                0xe1, 0xd3, 0xaf, 0x73, 0x6a, 0xb9, 0xc6, 0x11, 0x6f, 0x46, 0x8f, 0x91, 0x66, 0x80,
-                0x63, 0x20, 0x35, 0x0f, 0x7e, 0x73, 0x51, 0x3b, 0xa6, 0x05, 0x50, 0xeb, 0x2d, 0xf0,
-                0x1f, 0xf7, 0x83, 0x2d,
+                0x88, 0xd1, 0x38, 0x2c, 0x14, 0x42, 0x02, 0xd0, 0xd7, 0x55, 0x75, 0x87, 0xb0, 0xd5,
+                0xd0, 0x21, 0x69, 0x29, 0x2a, 0x25, 0x05, 0x43, 0xcb, 0x0a, 0x06, 0xc3, 0x4f, 0x45,
+                0x2f, 0x7b, 0x3b, 0x36,
             ],
             k_enc: [
-                0xb4, 0x3e, 0x43, 0x3e, 0x16, 0x45, 0xeb, 0x51, 0x5e, 0x4a, 0x4c, 0x7d, 0x10, 0xc9,
-                0x3d, 0x08, 0xf2, 0xf1, 0xc3, 0x30, 0x95, 0xbf, 0x8c, 0x80, 0x0a, 0x04, 0x17, 0x62,
-                0xab, 0x5c, 0xf8, 0x2c,
+                0xe3, 0x73, 0xd8, 0x6e, 0xc9, 0xdd, 0xdd, 0x64, 0x5d, 0x9a, 0x6d, 0x06, 0xef, 0xce,
+                0x22, 0xb8, 0x96, 0x42, 0x1d, 0x57, 0xa4, 0x4d, 0x37, 0xa6, 0x50, 0x4a, 0x5d, 0x19,
+                0xdf, 0x21, 0x73, 0x73,
             ],
             p_enc: [
                 0x02, 0xaa, 0x14, 0x92, 0x9c, 0x57, 0x89, 0x85, 0x85, 0xce, 0x66, 0x5a, 0xfa, 0x3f,
@@ -797,69 +800,70 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x72, 0x65, 0x57, 0x53,
             ],
             c_enc: [
-                0x27, 0x62, 0x0d, 0xf5, 0xdb, 0x17, 0x76, 0x6e, 0xbd, 0x9a, 0x99, 0xd6, 0x9a, 0x9a,
-                0x49, 0x38, 0x73, 0x21, 0xf0, 0xc9, 0x47, 0x25, 0x23, 0x57, 0xb5, 0xb7, 0x48, 0x49,
-                0x38, 0xe3, 0xf5, 0xff, 0x9f, 0x32, 0x0e, 0x80, 0x6c, 0x4b, 0x54, 0xc3, 0x6e, 0x41,
-                0x2e, 0x8a, 0x6e, 0xad, 0xe3, 0x5b, 0x83, 0x01, 0xf7, 0x34, 0xf3, 0x71, 0x2e, 0x6a,
-                0xac, 0xe6, 0x99, 0xf5, 0x9e, 0x11, 0x2a, 0x7b, 0xf5, 0x44, 0x59, 0xdc, 0x5d, 0x9f,
-                0x7b, 0xbf, 0x3b, 0x9f, 0x74, 0x6c, 0x45, 0xbb, 0xed, 0x69, 0xa4, 0x25, 0x1b, 0x29,
-                0xf3, 0xd2, 0x15, 0xc2, 0x9f, 0x76, 0x1c, 0x7d, 0x05, 0x88, 0x19, 0xf0, 0xdd, 0x4e,
-                0x70, 0x71, 0xb0, 0x77, 0xcb, 0x00, 0xcb, 0x93, 0x62, 0xa4, 0x98, 0x16, 0x88, 0x0d,
-                0x49, 0xb7, 0x11, 0xf9, 0x20, 0x65, 0xf1, 0x53, 0x2e, 0x58, 0x18, 0x0b, 0xbd, 0xb4,
-                0x91, 0xdb, 0xbb, 0x96, 0x8a, 0x09, 0xb5, 0x63, 0xce, 0x1d, 0x29, 0x87, 0x6f, 0xd0,
-                0x52, 0x6d, 0x65, 0xda, 0x67, 0x27, 0xad, 0x40, 0xf9, 0x64, 0x02, 0xf9, 0x9a, 0xa5,
-                0xac, 0x06, 0x42, 0x51, 0xc4, 0x65, 0xe3, 0xc7, 0xdb, 0x1f, 0xfe, 0xef, 0xac, 0xd7,
-                0xf5, 0x1b, 0xa4, 0xf1, 0x9c, 0x6c, 0x17, 0x87, 0xa0, 0xff, 0xb4, 0x9d, 0xbb, 0x7b,
-                0x0a, 0x2b, 0x15, 0x64, 0x03, 0xd6, 0x6c, 0x22, 0x13, 0xe5, 0x1d, 0x58, 0xea, 0xef,
-                0xe8, 0x6d, 0x5d, 0xef, 0x0d, 0x24, 0xb7, 0xf2, 0xf8, 0xc1, 0x10, 0x32, 0x9a, 0x3a,
-                0x73, 0xcb, 0x33, 0x50, 0x14, 0x0e, 0x6b, 0xf7, 0x2c, 0xb6, 0xaa, 0x22, 0x2d, 0xef,
-                0x5a, 0x47, 0xe2, 0x1a, 0xf0, 0xb9, 0xae, 0xeb, 0x74, 0x8c, 0x01, 0xc6, 0x7a, 0xb6,
-                0xc9, 0xfd, 0x6e, 0x53, 0x6a, 0x0d, 0x92, 0x76, 0x61, 0x51, 0xb1, 0xac, 0x7c, 0xc9,
-                0x85, 0x5c, 0xa9, 0x8d, 0xea, 0x74, 0x85, 0x14, 0xef, 0xee, 0x89, 0xe8, 0x9a, 0x01,
-                0x68, 0xf5, 0xdd, 0xf4, 0xac, 0x2b, 0x7c, 0xe1, 0xc9, 0xc2, 0x92, 0xfb, 0xef, 0x2f,
-                0x45, 0x51, 0xa8, 0x88, 0xc3, 0x34, 0x5c, 0x65, 0x92, 0x30, 0x39, 0xfc, 0x21, 0xf7,
-                0x31, 0x55, 0x9b, 0xd9, 0x24, 0xbc, 0x2c, 0x15, 0x5b, 0xc0, 0xbe, 0x80, 0x38, 0x4a,
-                0x9e, 0x49, 0xbd, 0xa6, 0x9a, 0x70, 0x6b, 0x1a, 0xd6, 0xa2, 0x62, 0xab, 0xc6, 0x26,
-                0x50, 0x77, 0x2f, 0xd7, 0xea, 0xbc, 0x3f, 0x75, 0xa9, 0xac, 0xca, 0xa2, 0x8b, 0xcd,
-                0xea, 0x65, 0xf9, 0x4e, 0x16, 0xcc, 0x3d, 0x05, 0x38, 0xe5, 0x49, 0x86, 0x0a, 0x60,
-                0x12, 0x5b, 0xb4, 0xbc, 0x0c, 0x23, 0xe3, 0x22, 0x27, 0x68, 0x2c, 0x09, 0xb5, 0xaa,
-                0x30, 0x4a, 0x16, 0x09, 0x2a, 0xd4, 0xa3, 0xe2, 0xf6, 0x28, 0x3c, 0x38, 0x51, 0x80,
-                0x6e, 0x72, 0x17, 0x3f, 0x7d, 0x32, 0x97, 0xed, 0x92, 0xe5, 0x32, 0x40, 0x39, 0xa7,
-                0x31, 0x4f, 0x5f, 0xb7, 0x38, 0x6e, 0x09, 0x94, 0xf5, 0x2f, 0x8c, 0xcc, 0xf1, 0x87,
-                0xd6, 0x20, 0x41, 0x0c, 0xce, 0x9d, 0x0b, 0x91, 0x93, 0xac, 0xec, 0x6d, 0x4c, 0x9b,
-                0xd3, 0x4e, 0x08, 0x80, 0x58, 0x0a, 0xbe, 0xae, 0xd9, 0x7c, 0xb7, 0x80, 0x0f, 0x6a,
-                0xbc, 0x67, 0xc2, 0x5c, 0x49, 0x19, 0x2e, 0x37, 0xdc, 0xf3, 0x3d, 0x1a, 0x59, 0x16,
-                0x47, 0x5a, 0xe9, 0x99, 0x90, 0xd8, 0x29, 0xc1, 0xd5, 0x9e, 0x69, 0x2f, 0x47, 0x36,
-                0x93, 0xbc, 0xe3, 0x58, 0x5a, 0xec, 0xd3, 0xc1, 0x3b, 0xae, 0x15, 0xcb, 0xef, 0xf2,
-                0x98, 0x52, 0x2a, 0xab, 0xf4, 0x6b, 0xea, 0x3a, 0xbf, 0x63, 0x30, 0xa5, 0x6e, 0x37,
-                0x24, 0x51, 0x81, 0x32, 0xce, 0x94, 0x39, 0x41, 0x6a, 0x28, 0xe9, 0x52, 0x0d, 0xdf,
-                0x64, 0x17, 0x00, 0xb4, 0x6f, 0x37, 0x49, 0x50, 0xf3, 0x27, 0xaf, 0x3d, 0x0b, 0x3d,
-                0x3b, 0x3f, 0x61, 0xa8, 0x84, 0xcf, 0x4f, 0x82, 0x02, 0x56, 0xfb, 0x91, 0x65, 0xdc,
-                0xa0, 0xe4, 0x32, 0x60, 0xfc, 0xb5, 0x63, 0xef, 0x1a, 0xb4, 0xe7, 0x12, 0xef, 0x07,
-                0x23, 0xd6, 0x75, 0x90, 0xa4, 0xff, 0xc3, 0x66, 0xc4, 0xa7, 0x92, 0x50, 0x29, 0x93,
-                0x1b, 0xf0, 0x87, 0x3d, 0xac, 0xaa, 0xe9, 0x38, 0x5d, 0x9a, 0xd9, 0x1a, 0xed, 0x75,
-                0x93, 0x9d, 0x8b, 0xd1, 0xaf, 0x5d,
+                0xe7, 0x67, 0x81, 0xae, 0x63, 0x84, 0x1f, 0xff, 0xea, 0x30, 0x21, 0x96, 0x15, 0x94,
+                0xc2, 0x2a, 0x87, 0x20, 0xc7, 0xd8, 0xaa, 0x80, 0x8b, 0xc8, 0x6e, 0x71, 0xa3, 0x6a,
+                0xd7, 0xf8, 0x6f, 0xf8, 0x7c, 0x07, 0xd3, 0xc6, 0x50, 0xa0, 0x8e, 0x23, 0xe9, 0xb5,
+                0x4f, 0x00, 0xb4, 0x0b, 0xa0, 0x15, 0x91, 0x69, 0xdf, 0xca, 0x34, 0xc1, 0x40, 0xce,
+                0x93, 0x40, 0x19, 0xb2, 0xea, 0xa8, 0xea, 0x84, 0x35, 0x80, 0xb3, 0x5f, 0x14, 0xea,
+                0x51, 0x92, 0xde, 0x8a, 0x12, 0xf9, 0xab, 0xc9, 0x06, 0x10, 0x15, 0xe1, 0x47, 0x9e,
+                0xf9, 0x8d, 0x19, 0xa5, 0x34, 0xe9, 0xe4, 0x61, 0x64, 0xc3, 0xca, 0xc4, 0xeb, 0x54,
+                0x26, 0x4c, 0xed, 0xcd, 0x83, 0xaf, 0xc2, 0xac, 0x2e, 0x08, 0x7e, 0x39, 0xdf, 0xba,
+                0xe7, 0x6b, 0xd5, 0x50, 0xcc, 0x64, 0xa4, 0x04, 0xd2, 0x0c, 0x22, 0xca, 0x00, 0x3b,
+                0xf7, 0x5b, 0x12, 0xfb, 0xb8, 0xc7, 0x15, 0x13, 0x72, 0x70, 0x0b, 0x43, 0x9b, 0x3e,
+                0x06, 0x57, 0xec, 0xc3, 0x07, 0x70, 0x8f, 0xc3, 0x74, 0x94, 0xbd, 0x06, 0x39, 0xe8,
+                0xe1, 0xea, 0xea, 0x37, 0x8f, 0x27, 0xa1, 0x35, 0x74, 0xb7, 0x1f, 0xa4, 0x88, 0x3b,
+                0x80, 0x71, 0x2c, 0x7b, 0xeb, 0x5c, 0x30, 0x5f, 0x8d, 0x67, 0xe9, 0x19, 0x97, 0xf8,
+                0x03, 0x19, 0xdd, 0xb1, 0x15, 0xb9, 0x51, 0x23, 0x89, 0x7a, 0xae, 0x5f, 0x2d, 0x14,
+                0xff, 0xcf, 0xac, 0x7f, 0x65, 0x49, 0xca, 0x54, 0x8f, 0x6e, 0xab, 0xdf, 0x74, 0x81,
+                0x70, 0x27, 0xd4, 0x2d, 0x92, 0xd5, 0xcd, 0xf8, 0x8e, 0xd8, 0xd5, 0x11, 0xd1, 0xb5,
+                0xc4, 0x32, 0x2f, 0x77, 0x79, 0x74, 0x88, 0x6c, 0x0e, 0xd0, 0x13, 0x99, 0x18, 0x0a,
+                0xfa, 0x59, 0x7d, 0xd2, 0xb7, 0x7c, 0x58, 0xb2, 0x7c, 0x8a, 0x61, 0x20, 0x69, 0xe3,
+                0x86, 0xad, 0x63, 0x4c, 0xb0, 0x17, 0xa8, 0xe9, 0xf4, 0x8e, 0x37, 0xc4, 0x3e, 0xe8,
+                0x73, 0x3a, 0x0a, 0xcb, 0x69, 0xf8, 0xed, 0x9f, 0x6f, 0x30, 0x5f, 0x3b, 0xd1, 0xe9,
+                0x82, 0xb9, 0x4b, 0x1e, 0x51, 0xf4, 0xba, 0x98, 0x5b, 0x20, 0xec, 0x97, 0x4a, 0xc9,
+                0xa7, 0x93, 0xaa, 0x26, 0x4d, 0x61, 0x5b, 0x9d, 0xea, 0x48, 0x59, 0xa4, 0xd4, 0xca,
+                0xa7, 0x0d, 0x7a, 0x6b, 0x65, 0x30, 0x76, 0x85, 0xab, 0x53, 0x4e, 0x54, 0x55, 0x63,
+                0x1f, 0x6d, 0x68, 0xa4, 0x51, 0xd8, 0xaf, 0x2d, 0x41, 0x82, 0x52, 0x80, 0x0f, 0x68,
+                0x42, 0x31, 0xaf, 0xc2, 0x6d, 0x1f, 0xef, 0xc4, 0x03, 0xd7, 0x5f, 0x2e, 0x12, 0x0f,
+                0x5b, 0xe2, 0xb6, 0x74, 0x48, 0x60, 0x09, 0x26, 0x7c, 0xbc, 0x0c, 0xb0, 0x01, 0xbb,
+                0x47, 0xf0, 0xff, 0x46, 0x97, 0xea, 0xf5, 0x3d, 0xc9, 0x9c, 0x10, 0x77, 0x3a, 0x38,
+                0xcd, 0x06, 0xb4, 0x8b, 0xa3, 0x91, 0x19, 0xdb, 0x49, 0x84, 0xd0, 0x9a, 0x5b, 0xde,
+                0x13, 0x89, 0x0e, 0xa0, 0x61, 0x3d, 0x0c, 0xe0, 0x04, 0x3e, 0xae, 0x9a, 0x20, 0x89,
+                0x14, 0x1f, 0xd9, 0x46, 0x59, 0x13, 0xc1, 0xcc, 0x33, 0x27, 0xa5, 0x59, 0x42, 0xb9,
+                0xfd, 0x8f, 0xb8, 0x1c, 0x84, 0x7d, 0x8f, 0xdd, 0xf8, 0xbd, 0xba, 0xcf, 0xa0, 0xfb,
+                0x05, 0x52, 0xc1, 0xfe, 0x4c, 0xc4, 0xc0, 0x7f, 0x4d, 0xcf, 0x15, 0x1c, 0x5e, 0x74,
+                0xe8, 0xd6, 0x9b, 0x2b, 0x8b, 0xf7, 0xfd, 0x95, 0xec, 0xeb, 0x65, 0x5e, 0x00, 0x53,
+                0x58, 0x16, 0xd3, 0x8b, 0x4a, 0x28, 0xd4, 0xa9, 0xae, 0xeb, 0xb6, 0x9a, 0xb4, 0xdd,
+                0x12, 0xbf, 0x13, 0xfd, 0x5a, 0x45, 0x9b, 0x6b, 0xb6, 0x83, 0xff, 0xd9, 0xdd, 0x7b,
+                0x0d, 0x0c, 0xe7, 0x29, 0x67, 0x75, 0x80, 0x8a, 0x84, 0x3f, 0x3b, 0x8c, 0xc7, 0x89,
+                0xfd, 0x5f, 0x43, 0xe0, 0x84, 0xd8, 0x7d, 0x6a, 0xda, 0x8d, 0x1f, 0x28, 0xc2, 0x64,
+                0xe6, 0x44, 0xe9, 0xad, 0x96, 0x5c, 0x28, 0x08, 0x8a, 0x52, 0xe4, 0xb3, 0x56, 0x42,
+                0xf9, 0xb5, 0xe0, 0x66, 0x49, 0x90, 0x96, 0x3b, 0xc2, 0x3b, 0x9b, 0xb4, 0x8f, 0x46,
+                0x74, 0x73, 0x53, 0x58, 0x0e, 0xcc, 0x45, 0x20, 0xcf, 0xf1, 0xfa, 0x7f, 0x8f, 0xbc,
+                0x03, 0x0e, 0x64, 0x7d, 0xf1, 0x44, 0xee, 0x6c, 0xa5, 0xb3, 0x16, 0xb3, 0xaf, 0x90,
+                0x48, 0x9a, 0x80, 0x9d, 0x9c, 0x9f,
             ],
             ock: [
-                0x2a, 0xec, 0x11, 0xd4, 0xae, 0x79, 0x84, 0xe1, 0x69, 0xd1, 0xdf, 0xf1, 0xff, 0x0f,
-                0x9a, 0xf5, 0x19, 0x96, 0x34, 0x51, 0xa4, 0x1c, 0x9f, 0x5a, 0xdc, 0x58, 0xe4, 0xf9,
-                0x0a, 0xf3, 0x8d, 0x47,
+                0x85, 0x6e, 0x1a, 0x97, 0x09, 0xb0, 0xc4, 0x16, 0x93, 0x3f, 0x59, 0x70, 0x71, 0x5c,
+                0x56, 0xe2, 0xe0, 0x5c, 0x2e, 0xa9, 0x7d, 0x81, 0x51, 0x25, 0x70, 0x14, 0x79, 0xc3,
+                0x3a, 0x5d, 0x91, 0xcb,
             ],
             op: [
                 0x78, 0xa4, 0xe3, 0x39, 0x88, 0xd7, 0x1d, 0x71, 0x8e, 0x59, 0x55, 0x55, 0x28, 0x4c,
                 0x24, 0x9a, 0x62, 0xb7, 0x12, 0x88, 0x06, 0xa5, 0x4c, 0x3b, 0x36, 0xa3, 0xaa, 0x57,
-                0x14, 0x93, 0x16, 0x36, 0x34, 0x39, 0x22, 0x52, 0xc9, 0xcc, 0x9f, 0x45, 0x4b, 0x54,
-                0x2c, 0xf1, 0xb8, 0x88, 0xb3, 0xab, 0x02, 0xe6, 0x05, 0xa8, 0xda, 0x26, 0x10, 0x7d,
-                0x98, 0x02, 0xf1, 0x53, 0x6a, 0x9e, 0x9f, 0x2b,
+                0x14, 0x93, 0x16, 0x36, 0x8b, 0x14, 0x62, 0x2d, 0x2f, 0x91, 0xf1, 0x69, 0x8d, 0x53,
+                0xfe, 0x47, 0x9a, 0x1e, 0x5c, 0x00, 0x64, 0x98, 0xb9, 0x8b, 0x85, 0xb4, 0x50, 0xbd,
+                0x92, 0x3a, 0x5d, 0x00, 0xcb, 0x52, 0xa6, 0x13,
             ],
             c_out: [
-                0xe6, 0xeb, 0x22, 0x47, 0xc9, 0x33, 0xe2, 0x4c, 0x9d, 0xf1, 0x28, 0xb1, 0xe0, 0x4e,
-                0x8b, 0xc0, 0x5c, 0x65, 0xeb, 0x31, 0x97, 0xdf, 0x9b, 0xa8, 0x70, 0xd8, 0xa0, 0xa1,
-                0x8d, 0x9c, 0x24, 0xb7, 0xc9, 0x78, 0xc3, 0x4d, 0x3c, 0x7b, 0xbd, 0x21, 0xe8, 0x7b,
-                0x22, 0x39, 0x21, 0x87, 0x54, 0xd9, 0x67, 0x3a, 0x56, 0xa2, 0x73, 0x58, 0x0f, 0x6b,
-                0x41, 0xc6, 0x91, 0xe5, 0xfd, 0x30, 0x9c, 0xd5, 0xd1, 0xd2, 0x6d, 0x57, 0x63, 0xa9,
-                0xe8, 0xd2, 0x71, 0xc9, 0x77, 0x05, 0x0e, 0x05, 0xdc, 0x96,
-            ],
+                0x72, 0x36, 0xea, 0xb9, 0xf0, 0x12, 0x98, 0xc8, 0x4f, 0x38, 0x28, 0xf6, 0xac, 0x15,
+                0x42, 0x76, 0xb5, 0xb7, 0x64, 0x62, 0xf5, 0x74, 0x2d, 0x69, 0xdc, 0x47, 0x7a, 0x10,
+                0x5d, 0xc2, 0x71, 0x1b, 0x12, 0xe9, 0xb5, 0x82, 0x8c, 0x01, 0x76, 0xfe, 0xf4, 0x4a,
+                0x54, 0x0f, 0x60, 0x95, 0x8e, 0x5a, 0x3e, 0xd6, 0xa2, 0xcc, 0x5e, 0xdd, 0xe9, 0x13,
+                0xd1, 0x4c, 0xf8, 0xe8, 0xe2, 0x8e, 0xa2, 0x5c, 0x18, 0x62, 0x7a, 0x84, 0xa2, 0xbe,
+                0x96, 0x1f, 0x44, 0x72, 0x67, 0x67, 0xe9, 0xf8, 0x43, 0x1b,
+            ],
+            note_type: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -933,34 +937,34 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xd2, 0x50, 0x21, 0x17,
             ],
             rho: [
-                0x23, 0x39, 0xa8, 0x95, 0x29, 0xcf, 0x35, 0x7b, 0x06, 0x7d, 0xd2, 0x8b, 0xe4, 0x06,
-                0x6e, 0x16, 0x23, 0x6d, 0xc5, 0xd7, 0x87, 0x06, 0x14, 0x9a, 0x72, 0x8c, 0x3e, 0x3d,
-                0x9d, 0xc1, 0x08, 0x1c,
+                0x8d, 0x67, 0xe3, 0xba, 0x4d, 0xbc, 0x9d, 0xa5, 0xe8, 0x38, 0x23, 0xa1, 0x23, 0x11,
+                0x63, 0x96, 0x51, 0xa4, 0xff, 0xa9, 0x5f, 0x27, 0xc1, 0x83, 0x0d, 0x91, 0xd8, 0xb7,
+                0x3c, 0xfb, 0xf1, 0x31,
             ],
             cmx: [
-                0xe3, 0x04, 0xcf, 0x08, 0xc7, 0x86, 0xaf, 0xcb, 0x1d, 0x65, 0x2f, 0x7a, 0x94, 0x17,
-                0x29, 0x32, 0x01, 0x51, 0x71, 0x37, 0x93, 0x82, 0x89, 0x42, 0xcb, 0x88, 0xd0, 0x1f,
-                0x68, 0x60, 0x4e, 0x1f,
+                0xea, 0x7c, 0x13, 0xf7, 0xe1, 0x20, 0x5e, 0x78, 0xc8, 0xce, 0x4e, 0xe4, 0xfd, 0xcd,
+                0xb7, 0xee, 0x76, 0x92, 0x8d, 0xdf, 0x6d, 0xbe, 0x1b, 0x2d, 0x6f, 0x69, 0x81, 0xb7,
+                0xc9, 0x65, 0x79, 0x10,
             ],
             esk: [
-                0x0f, 0xba, 0x68, 0x76, 0xb3, 0x76, 0x5d, 0xff, 0x4f, 0x4c, 0x40, 0xaf, 0x89, 0x3e,
-                0x4b, 0xd1, 0x34, 0x3a, 0x53, 0x4c, 0xdf, 0x50, 0x20, 0x15, 0x6b, 0x5e, 0xd1, 0xf6,
-                0xbf, 0x62, 0xbe, 0x3c,
+                0x85, 0x7b, 0xa2, 0x47, 0xd4, 0x68, 0xe1, 0x8d, 0xfe, 0x96, 0x73, 0xe9, 0x05, 0x99,
+                0x23, 0xc2, 0x2e, 0x9b, 0x70, 0x0d, 0x56, 0x3d, 0xf8, 0xa9, 0x89, 0xcc, 0x63, 0x00,
+                0x06, 0x15, 0xb2, 0x0d,
             ],
             ephemeral_key: [
-                0xdf, 0xe0, 0xf0, 0x0e, 0xb2, 0xb2, 0xf7, 0x08, 0x04, 0x19, 0x1b, 0x5b, 0x2d, 0xdf,
-                0x57, 0x8f, 0x6a, 0xda, 0x21, 0x1b, 0x8b, 0x41, 0x7d, 0x95, 0xd2, 0xb7, 0x34, 0xff,
-                0xa2, 0x2d, 0x81, 0x30,
+                0x89, 0xfd, 0x2c, 0xf3, 0x79, 0x56, 0xba, 0xaf, 0x11, 0x27, 0xbb, 0x0e, 0x33, 0x40,
+                0x01, 0x09, 0xdb, 0x03, 0x50, 0xf4, 0xab, 0xb7, 0xd6, 0xd8, 0x1f, 0xa5, 0x84, 0x8e,
+                0x1b, 0xb1, 0x69, 0x26,
             ],
             shared_secret: [
-                0x0e, 0xc6, 0x82, 0xc8, 0xdc, 0x66, 0x41, 0x41, 0x02, 0x4f, 0x92, 0x9d, 0x1a, 0xe5,
-                0xd3, 0x9c, 0x39, 0x4d, 0x05, 0xa2, 0x4d, 0xad, 0x0e, 0x4a, 0x6f, 0x94, 0x98, 0xed,
-                0x5f, 0x87, 0xd4, 0x88,
+                0xdb, 0xa6, 0x37, 0x94, 0xb6, 0x7c, 0x49, 0x6d, 0x01, 0x1c, 0xfb, 0x6b, 0xba, 0x29,
+                0x7c, 0xa5, 0x7d, 0x18, 0xc7, 0xa9, 0xad, 0xdf, 0xfb, 0xc8, 0x37, 0x17, 0x6a, 0xcf,
+                0x3a, 0x30, 0x1e, 0x23,
             ],
             k_enc: [
-                0xb1, 0x24, 0x5f, 0xb6, 0x37, 0x47, 0xc0, 0x13, 0x39, 0xcd, 0xe8, 0xf9, 0x35, 0x98,
-                0xdf, 0xb2, 0xd3, 0x99, 0xec, 0x5e, 0x03, 0xbe, 0xa1, 0x3f, 0x3d, 0xbf, 0x01, 0xca,
-                0xdb, 0x93, 0xc9, 0xba,
+                0x80, 0xe7, 0x52, 0x2c, 0xb0, 0x32, 0x51, 0xc8, 0x55, 0x34, 0x1f, 0x06, 0xf9, 0x41,
+                0x33, 0x41, 0xe1, 0x6e, 0x83, 0xb4, 0x89, 0xe1, 0x5a, 0x0a, 0x00, 0x65, 0xc3, 0x3b,
+                0xf3, 0x81, 0x58, 0xc4,
             ],
             p_enc: [
                 0x02, 0xe0, 0x66, 0xb5, 0xe7, 0x96, 0x86, 0xe9, 0xf3, 0x6e, 0xce, 0xc7, 0x7e, 0x65,
@@ -1006,69 +1010,70 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xd7, 0x6b, 0xa4, 0x80,
             ],
             c_enc: [
-                0x31, 0xec, 0x78, 0xd4, 0x02, 0x14, 0xc1, 0xbc, 0x7b, 0x25, 0x94, 0x7b, 0x42, 0xf3,
-                0x54, 0x34, 0x60, 0x72, 0x90, 0x27, 0x7c, 0x44, 0xc4, 0x89, 0xe9, 0x38, 0x72, 0x2f,
-                0x7c, 0x12, 0xff, 0x55, 0xc4, 0xf1, 0xdf, 0xbe, 0x0f, 0x1a, 0x65, 0xb1, 0x5c, 0x0c,
-                0xc4, 0x7a, 0x46, 0xc9, 0xbb, 0x33, 0x5b, 0xd1, 0xa3, 0xe7, 0xe6, 0x62, 0xee, 0x85,
-                0x84, 0x57, 0x6b, 0x6f, 0x42, 0x81, 0x95, 0xc9, 0x8c, 0x72, 0xfb, 0x99, 0x75, 0xc7,
-                0x17, 0x9c, 0x4c, 0xab, 0x58, 0x66, 0xf5, 0xb4, 0x85, 0x42, 0x8b, 0x50, 0x8e, 0x2e,
-                0x05, 0xbe, 0x0c, 0x98, 0x41, 0xa3, 0xa2, 0x91, 0x12, 0x80, 0x2c, 0x52, 0x15, 0xe2,
-                0x51, 0x37, 0xcf, 0xdd, 0x13, 0x8c, 0x99, 0x39, 0x0e, 0xfb, 0xce, 0xb7, 0x52, 0x4e,
-                0x84, 0x7c, 0x36, 0xb4, 0x3f, 0x3e, 0xde, 0x32, 0xf2, 0x3b, 0x39, 0x81, 0xf6, 0xd3,
-                0xc3, 0x2b, 0x17, 0xbb, 0xbe, 0x65, 0xf2, 0xfd, 0x01, 0xab, 0xdd, 0x99, 0x87, 0xf1,
-                0xb8, 0x88, 0xeb, 0xef, 0x41, 0xef, 0x45, 0x55, 0xc9, 0xfb, 0x0c, 0x8a, 0xee, 0x9b,
-                0x6d, 0xd0, 0x85, 0xb9, 0xfb, 0xc7, 0x4f, 0xe4, 0x6a, 0x1e, 0x36, 0x3d, 0x68, 0x32,
-                0xb5, 0x08, 0x20, 0x0e, 0x50, 0x0d, 0xa6, 0x95, 0x13, 0xb7, 0x9e, 0x81, 0xf7, 0x33,
-                0xb6, 0x6c, 0x3f, 0x24, 0x3a, 0x28, 0x5b, 0xf8, 0x6f, 0xfe, 0xef, 0x4f, 0xfd, 0x1c,
-                0xac, 0xa7, 0x83, 0x07, 0x26, 0x63, 0xbf, 0x9b, 0x48, 0x7f, 0xbc, 0x3e, 0x7f, 0x5a,
-                0xd2, 0xf7, 0xac, 0xbf, 0x2b, 0x6e, 0x00, 0x8e, 0x3e, 0x4d, 0x6f, 0x31, 0xe1, 0x14,
-                0x75, 0xe1, 0x96, 0x98, 0x9d, 0xb9, 0x62, 0x8a, 0x5d, 0x56, 0x39, 0x7c, 0x9a, 0x04,
-                0x2a, 0xab, 0x55, 0xe1, 0xec, 0xc4, 0x92, 0xfe, 0x94, 0x27, 0xd4, 0x90, 0xf2, 0x73,
-                0xb6, 0x01, 0xd6, 0x51, 0x05, 0x56, 0x82, 0xd3, 0x5b, 0x30, 0x75, 0xfa, 0xda, 0x85,
-                0x25, 0x84, 0x48, 0x14, 0x95, 0x7f, 0xfc, 0x9b, 0xc7, 0xfb, 0x39, 0x39, 0x73, 0x7b,
-                0x01, 0x50, 0x2e, 0x0b, 0x6f, 0x1f, 0x9b, 0x88, 0xf2, 0x71, 0x54, 0x80, 0xae, 0x42,
-                0x2e, 0x9b, 0xb7, 0xb7, 0x6e, 0x5d, 0x22, 0xde, 0x0d, 0x3d, 0x7a, 0xea, 0x58, 0x10,
-                0x01, 0xdc, 0xf4, 0x6a, 0x62, 0x2f, 0x08, 0x03, 0x10, 0xbe, 0x50, 0xdf, 0x07, 0x75,
-                0x21, 0x92, 0xd4, 0xe4, 0x1a, 0xc5, 0x18, 0xe4, 0x24, 0x1e, 0x06, 0x67, 0x76, 0xa8,
-                0xea, 0xec, 0xc7, 0x42, 0xfd, 0x2c, 0x1b, 0xf0, 0x6f, 0xc5, 0x8b, 0xd2, 0x8d, 0x1d,
-                0x6c, 0x60, 0x1f, 0x91, 0x5d, 0x75, 0x2e, 0x7c, 0xc3, 0xd9, 0x76, 0x3c, 0x8b, 0x9e,
-                0xec, 0x14, 0x2c, 0x84, 0x81, 0xf9, 0xc5, 0x23, 0x59, 0xbf, 0xbf, 0x51, 0x24, 0x36,
-                0x67, 0x84, 0xe1, 0x71, 0xd7, 0xa4, 0xaa, 0x01, 0x5e, 0x85, 0x56, 0x47, 0x4a, 0x6d,
-                0x0f, 0xee, 0x69, 0xb0, 0xd5, 0x3e, 0xe7, 0xf4, 0xed, 0xf5, 0xea, 0x59, 0xfa, 0x55,
-                0x97, 0xf4, 0x8d, 0xd6, 0xaa, 0x88, 0x51, 0x84, 0x29, 0xac, 0x8c, 0x18, 0xc4, 0x73,
-                0x8d, 0xb8, 0x01, 0x09, 0xa5, 0xe4, 0xbc, 0x81, 0xbb, 0x84, 0xb3, 0x7d, 0x9b, 0x2a,
-                0xd4, 0xb1, 0xd2, 0x6b, 0x36, 0x3d, 0x16, 0x60, 0x72, 0xf0, 0x8c, 0x56, 0x70, 0x62,
-                0x27, 0xa9, 0xf8, 0x32, 0x97, 0x03, 0x70, 0x12, 0xd1, 0xf6, 0xda, 0x24, 0xa8, 0x69,
-                0xeb, 0x32, 0x97, 0xbc, 0xbc, 0xcc, 0x8d, 0x7d, 0xed, 0x03, 0x0a, 0x3d, 0x60, 0xdf,
-                0x88, 0x82, 0xe0, 0x62, 0x9e, 0x36, 0x14, 0x3c, 0x09, 0xca, 0x05, 0x21, 0x43, 0xcb,
-                0x56, 0x62, 0x93, 0x8f, 0xa9, 0xf1, 0x15, 0xdd, 0xc0, 0x96, 0x65, 0x4c, 0x0b, 0x40,
-                0x59, 0x4c, 0xba, 0x19, 0xee, 0xd4, 0x99, 0x53, 0x2b, 0x70, 0x8a, 0xde, 0xbe, 0x47,
-                0x72, 0x6a, 0x83, 0xaf, 0x46, 0x3c, 0x80, 0xba, 0x2a, 0x1f, 0xe0, 0x71, 0xe1, 0x66,
-                0xc4, 0x4d, 0x70, 0xdd, 0xbb, 0xba, 0x67, 0x06, 0xa1, 0xdc, 0x43, 0x27, 0x26, 0xfe,
-                0x0f, 0xdb, 0xc6, 0x28, 0x21, 0xb5, 0x04, 0xea, 0x11, 0x66, 0xda, 0x48, 0xa8, 0x1b,
-                0x63, 0x5e, 0x37, 0x63, 0x33, 0xd9, 0xbe, 0xfe, 0xc4, 0x93, 0xa0, 0x7d, 0xf4, 0x7b,
-                0xba, 0x0a, 0x2e, 0x2f, 0x65, 0xe7,
+                0x3f, 0x4e, 0x9b, 0x18, 0x56, 0xe7, 0xbf, 0xba, 0x7a, 0xbb, 0xc9, 0x4a, 0x72, 0xb4,
+                0xab, 0xb1, 0xd8, 0x46, 0x26, 0x79, 0x30, 0x77, 0xe8, 0x37, 0xda, 0xf3, 0x3f, 0xff,
+                0xa2, 0x7c, 0x7a, 0x33, 0x97, 0x8a, 0x54, 0x32, 0x51, 0x0d, 0x99, 0x3c, 0x7d, 0x92,
+                0x24, 0xc0, 0x97, 0xac, 0xc5, 0x25, 0x88, 0x1c, 0x76, 0x08, 0x3c, 0x1b, 0x65, 0x1a,
+                0x9d, 0xe1, 0xb5, 0xc1, 0xa6, 0xe0, 0x48, 0x2f, 0xae, 0x8f, 0x98, 0x6a, 0xb5, 0x9f,
+                0xa7, 0xcd, 0x43, 0x98, 0x99, 0x6e, 0x2b, 0xc0, 0x3a, 0xdc, 0xa9, 0x90, 0x32, 0x3b,
+                0xaa, 0xbd, 0xda, 0xae, 0x40, 0xb0, 0x56, 0xb7, 0xac, 0x17, 0xf8, 0x20, 0xd1, 0x1c,
+                0x0d, 0xec, 0xba, 0x14, 0xf2, 0x57, 0xa6, 0xcf, 0x09, 0x18, 0x19, 0x8f, 0x38, 0x9c,
+                0xdb, 0x29, 0x55, 0x77, 0x25, 0x96, 0x92, 0x7c, 0xbf, 0x55, 0x88, 0x56, 0x13, 0x35,
+                0xe7, 0xd6, 0x2e, 0x6a, 0x8a, 0xf7, 0xbc, 0x33, 0xb9, 0x9a, 0x55, 0xaf, 0xa1, 0xb7,
+                0xef, 0x20, 0xeb, 0x4e, 0xd6, 0xde, 0x89, 0x69, 0xd2, 0x9f, 0x04, 0x21, 0xcd, 0x4d,
+                0x99, 0x06, 0x66, 0xfd, 0xcf, 0x1e, 0xbd, 0x09, 0x06, 0x57, 0x02, 0x13, 0x4d, 0x31,
+                0xc3, 0x29, 0x26, 0xa3, 0x8b, 0x6b, 0x6b, 0x48, 0xfd, 0xc9, 0xb3, 0xc7, 0x64, 0xc3,
+                0xcd, 0x95, 0xb9, 0x72, 0xe7, 0x68, 0xeb, 0xd8, 0xaa, 0xe9, 0x0d, 0x6a, 0x4a, 0x98,
+                0xb2, 0xd9, 0x2f, 0xd9, 0xdf, 0xa2, 0xa2, 0x99, 0xd0, 0x60, 0xe8, 0x5e, 0xf5, 0x68,
+                0x3f, 0x51, 0xd0, 0x51, 0x4a, 0x6e, 0xba, 0x72, 0x57, 0x3f, 0x7b, 0xae, 0x84, 0xa2,
+                0xfd, 0x92, 0xbe, 0x64, 0x24, 0x1c, 0x27, 0xa6, 0xe5, 0xce, 0xac, 0xbf, 0x37, 0xb2,
+                0xd9, 0xa9, 0x75, 0xdf, 0x7a, 0xee, 0xbb, 0xa1, 0x4d, 0x8c, 0x81, 0x15, 0x8e, 0xcf,
+                0x5a, 0x0a, 0x25, 0xe1, 0x2f, 0x98, 0x5d, 0x08, 0xfb, 0xb4, 0xa1, 0xc1, 0x3f, 0x76,
+                0x1f, 0x3f, 0xfe, 0xe8, 0xd5, 0x38, 0xe3, 0x93, 0xf3, 0x58, 0x0b, 0x73, 0x82, 0xcd,
+                0x0b, 0xf5, 0x17, 0xce, 0x78, 0x87, 0x1c, 0x19, 0xac, 0xf8, 0xca, 0x06, 0x5d, 0x7c,
+                0x83, 0x87, 0xce, 0xcd, 0x0d, 0x37, 0xae, 0x21, 0x7f, 0x44, 0x06, 0x94, 0x77, 0x2a,
+                0xbd, 0x4b, 0x36, 0x55, 0x56, 0x85, 0x4b, 0xaa, 0x8b, 0xcc, 0xa9, 0xc4, 0xfe, 0xf7,
+                0x18, 0x99, 0x12, 0xf9, 0x8a, 0x25, 0x27, 0x68, 0x92, 0x76, 0xa4, 0x00, 0x8c, 0x83,
+                0x8f, 0xe7, 0x4f, 0x7c, 0x2b, 0x75, 0x9f, 0xc2, 0xab, 0x7a, 0xfe, 0x37, 0x82, 0x80,
+                0x6e, 0x31, 0xb1, 0xc5, 0x30, 0xcc, 0x46, 0x20, 0x3b, 0xb3, 0xa5, 0x66, 0xca, 0xf4,
+                0xd1, 0x5b, 0x99, 0x40, 0xb4, 0x3f, 0x33, 0xa8, 0x6a, 0x65, 0xd4, 0x9d, 0xa8, 0xb6,
+                0x78, 0x7d, 0xe0, 0x96, 0x38, 0xb4, 0x81, 0xf3, 0xa8, 0x10, 0x8a, 0x96, 0x9e, 0xca,
+                0xdf, 0x90, 0x98, 0xbf, 0xf2, 0x14, 0x0c, 0x4b, 0x42, 0xe2, 0xb0, 0xfb, 0x10, 0xb9,
+                0x02, 0x89, 0xb0, 0xc6, 0xdb, 0x8b, 0xc0, 0x85, 0xe8, 0xaf, 0xe9, 0x5d, 0xd3, 0x6a,
+                0x45, 0x36, 0xea, 0xd7, 0xe9, 0x5c, 0x99, 0x66, 0x2c, 0xd9, 0x28, 0xc2, 0x2c, 0x3e,
+                0xbf, 0x39, 0x79, 0x15, 0x78, 0xbc, 0x66, 0xfe, 0xa3, 0x01, 0x4d, 0x22, 0x92, 0x94,
+                0x30, 0x83, 0xe7, 0x46, 0x81, 0x24, 0x52, 0xb0, 0x0b, 0xc2, 0xf3, 0xe4, 0x7c, 0x49,
+                0x47, 0x46, 0xce, 0xd5, 0x57, 0xb1, 0x3a, 0xe3, 0x03, 0x0d, 0x8a, 0x95, 0x78, 0x10,
+                0x2b, 0xba, 0xd2, 0xfc, 0x3b, 0x84, 0x5f, 0x31, 0xae, 0x16, 0xf8, 0xd8, 0x0b, 0x77,
+                0xf8, 0x43, 0x15, 0x84, 0xa3, 0x7e, 0x8f, 0x30, 0xb0, 0xb9, 0x5c, 0xc4, 0x55, 0x5a,
+                0xbc, 0x05, 0x3a, 0x0b, 0x4f, 0xf9, 0x13, 0xb0, 0x03, 0x69, 0xf1, 0x74, 0x7b, 0x1f,
+                0x1c, 0x0a, 0xc8, 0x75, 0x4f, 0x01, 0x7e, 0x99, 0x47, 0xca, 0x63, 0x25, 0x5b, 0x3c,
+                0x23, 0xf4, 0x56, 0xe2, 0x3f, 0x96, 0x76, 0x13, 0x99, 0x60, 0x1f, 0xd8, 0xda, 0xdb,
+                0x5e, 0x3f, 0x90, 0xab, 0x1b, 0x20, 0x13, 0x81, 0x80, 0xed, 0x69, 0x73, 0x22, 0x39,
+                0xc8, 0xc2, 0x15, 0xd9, 0xcc, 0x8a, 0xc8, 0x05, 0x9b, 0xde, 0x81, 0x63, 0x27, 0xd2,
+                0x20, 0xb9, 0xa8, 0xec, 0xba, 0x5d,
             ],
             ock: [
-                0xec, 0xa3, 0x70, 0x7a, 0x74, 0x5d, 0x5d, 0x58, 0x65, 0x86, 0xb2, 0x35, 0xf2, 0x92,
-                0xad, 0x20, 0x48, 0x93, 0x14, 0xc4, 0x58, 0x80, 0xd9, 0x83, 0x2b, 0x7f, 0x47, 0xee,
-                0xbb, 0xd4, 0x5c, 0xfe,
+                0xe6, 0xb7, 0x05, 0x50, 0xe1, 0xd7, 0xa2, 0xbe, 0x73, 0x04, 0x39, 0x64, 0x41, 0xec,
+                0x6a, 0xc0, 0x47, 0x45, 0x99, 0xf9, 0xea, 0xd7, 0x55, 0xc2, 0xcf, 0x27, 0x6b, 0x87,
+                0x50, 0xc5, 0xcf, 0x2d,
             ],
             op: [
                 0x3b, 0x3e, 0x88, 0x3e, 0x95, 0x8c, 0xd6, 0xe0, 0x75, 0x4d, 0x74, 0xca, 0xae, 0x1e,
                 0x5a, 0x43, 0x98, 0xab, 0xeb, 0x7d, 0x10, 0xee, 0x5f, 0x75, 0xa4, 0xab, 0x8e, 0xf7,
-                0x03, 0x8e, 0x3d, 0xb3, 0x0f, 0xba, 0x68, 0x76, 0xb3, 0x76, 0x5d, 0xff, 0x4f, 0x4c,
-                0x40, 0xaf, 0x89, 0x3e, 0x4b, 0xd1, 0x34, 0x3a, 0x53, 0x4c, 0xdf, 0x50, 0x20, 0x15,
-                0x6b, 0x5e, 0xd1, 0xf6, 0xbf, 0x62, 0xbe, 0x3c,
+                0x03, 0x8e, 0x3d, 0xb3, 0x85, 0x7b, 0xa2, 0x47, 0xd4, 0x68, 0xe1, 0x8d, 0xfe, 0x96,
+                0x73, 0xe9, 0x05, 0x99, 0x23, 0xc2, 0x2e, 0x9b, 0x70, 0x0d, 0x56, 0x3d, 0xf8, 0xa9,
+                0x89, 0xcc, 0x63, 0x00, 0x06, 0x15, 0xb2, 0x0d,
             ],
             c_out: [
-                0xd0, 0x65, 0x9a, 0x03, 0xc5, 0x3e, 0x15, 0xdc, 0x11, 0x01, 0xa6, 0x6e, 0xa8, 0x0d,
-                0xf4, 0x14, 0x4d, 0x5e, 0xe0, 0x1c, 0x3d, 0xbf, 0x20, 0x2c, 0xe6, 0x08, 0x7e, 0x96,
-                0xa8, 0x5a, 0xe1, 0x39, 0xdd, 0x46, 0xfc, 0x82, 0xa1, 0xc3, 0x7d, 0x06, 0x05, 0xf8,
-                0x49, 0x98, 0x53, 0x13, 0x16, 0xf1, 0xf0, 0xcb, 0xc0, 0x4e, 0xa2, 0x0a, 0xa4, 0x04,
-                0xb3, 0xd5, 0xb0, 0x42, 0x96, 0x01, 0x49, 0x81, 0x6d, 0x9b, 0x8f, 0x06, 0x2a, 0xfc,
-                0xc1, 0x93, 0x89, 0x43, 0x82, 0x7a, 0x1b, 0x43, 0xfc, 0xbd,
-            ],
+                0x02, 0xb1, 0x37, 0x3e, 0xb1, 0x89, 0x56, 0x32, 0x2b, 0x47, 0xa1, 0x70, 0x0d, 0xb7,
+                0x43, 0x31, 0x6e, 0xde, 0x46, 0x44, 0xd6, 0x59, 0x3c, 0xd7, 0x94, 0x22, 0xd7, 0x51,
+                0x3d, 0x1b, 0x80, 0xe6, 0x85, 0x05, 0xdf, 0xe9, 0xd6, 0x86, 0x2e, 0x79, 0x4e, 0x30,
+                0x28, 0x8b, 0xae, 0xa8, 0xb0, 0xbc, 0xb3, 0x8b, 0x35, 0x49, 0x77, 0xaa, 0xee, 0x57,
+                0x2e, 0xe8, 0x86, 0x8b, 0x2d, 0xa0, 0x7d, 0xa2, 0x99, 0x2c, 0x6d, 0x9f, 0xb8, 0xbd,
+                0x59, 0x0b, 0x8d, 0xa0, 0x28, 0x11, 0xb5, 0x09, 0xe8, 0xc6,
+            ],
+            note_type: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1142,34 +1147,34 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xda, 0x6b, 0x15, 0x14,
             ],
             rho: [
-                0xe5, 0xd0, 0x8c, 0x40, 0x26, 0x3e, 0x4a, 0x2a, 0x56, 0x96, 0xda, 0x21, 0x0d, 0x8e,
-                0x9a, 0x77, 0xf0, 0xaf, 0xc4, 0xc6, 0x8a, 0x6d, 0xda, 0x38, 0xe2, 0x85, 0xf4, 0xe3,
-                0xef, 0x13, 0xb8, 0x17,
+                0x9a, 0x09, 0xe4, 0x72, 0xe8, 0xe9, 0x96, 0xfc, 0xc3, 0x0e, 0xd5, 0x23, 0x72, 0x08,
+                0xdb, 0xb0, 0x01, 0x71, 0x32, 0x0e, 0x6b, 0xea, 0x43, 0x91, 0x86, 0x00, 0x9d, 0xad,
+                0x21, 0x38, 0xab, 0x29,
             ],
             cmx: [
-                0xad, 0xc2, 0x44, 0x3a, 0xf9, 0x57, 0x67, 0x47, 0xca, 0x4f, 0x10, 0x4b, 0x1f, 0x5a,
-                0x7a, 0xdc, 0x80, 0x5a, 0xc5, 0x5a, 0xcc, 0x56, 0x33, 0xa0, 0xb3, 0xc2, 0xdc, 0x7a,
-                0xad, 0xff, 0x21, 0x26,
+                0x18, 0xfc, 0xbd, 0x40, 0xac, 0xf1, 0xa7, 0xf4, 0xd6, 0x09, 0x87, 0x9a, 0x5f, 0x5e,
+                0x3b, 0x39, 0x70, 0x09, 0x4f, 0xf8, 0xbe, 0x84, 0x18, 0x60, 0x70, 0x16, 0xc6, 0xa6,
+                0x97, 0xf8, 0x9c, 0x20,
             ],
             esk: [
-                0x24, 0x75, 0x30, 0x5c, 0x35, 0xcf, 0x37, 0xeb, 0xd2, 0x77, 0x82, 0x35, 0x16, 0x58,
-                0x5a, 0xfa, 0x06, 0x05, 0x78, 0x52, 0x17, 0x1e, 0x0c, 0xe4, 0xb0, 0x52, 0xd5, 0xb4,
-                0x20, 0x41, 0xd8, 0x1c,
+                0x3b, 0xc1, 0x7a, 0x58, 0x0d, 0x53, 0x0f, 0x89, 0x30, 0xa3, 0x6b, 0x8d, 0x6f, 0xea,
+                0x67, 0x85, 0x7f, 0x7b, 0x85, 0x20, 0xfd, 0x2e, 0x0a, 0xb5, 0xd5, 0xcb, 0xab, 0x1a,
+                0xcc, 0xd5, 0x4e, 0x3a,
             ],
             ephemeral_key: [
-                0x00, 0x5d, 0x31, 0x5b, 0xd1, 0x80, 0xa2, 0x94, 0x0b, 0xd7, 0xfb, 0x34, 0xa7, 0x0e,
-                0x90, 0xe8, 0x32, 0x6c, 0xb1, 0x34, 0x30, 0x66, 0x05, 0x46, 0x53, 0xd2, 0x64, 0x4d,
-                0x20, 0x45, 0xe3, 0x0f,
+                0xcf, 0xe0, 0x3e, 0xb2, 0xd3, 0x36, 0x76, 0xb7, 0x73, 0x83, 0x7d, 0xa8, 0x39, 0x17,
+                0x2d, 0x33, 0x33, 0x31, 0x88, 0xc9, 0xdf, 0xef, 0x05, 0xc8, 0x32, 0xa2, 0x5c, 0x86,
+                0xd3, 0xbf, 0x0e, 0x8f,
             ],
             shared_secret: [
-                0x8e, 0x59, 0x0d, 0x06, 0x3f, 0x7e, 0xc3, 0x8e, 0xb2, 0x00, 0x84, 0x70, 0xf9, 0xbb,
-                0x42, 0x29, 0x04, 0xfc, 0x0b, 0xaf, 0x97, 0x80, 0xf8, 0xfd, 0x1f, 0x54, 0x22, 0xea,
-                0x30, 0x8c, 0x47, 0xba,
+                0xd2, 0xc2, 0x88, 0x9e, 0x03, 0x7e, 0xac, 0x60, 0x60, 0x58, 0x68, 0x2b, 0xaa, 0x38,
+                0x86, 0xa4, 0xc2, 0xdd, 0x44, 0xea, 0xdf, 0x8b, 0x2c, 0xe4, 0x39, 0x95, 0xde, 0xd7,
+                0x61, 0xfd, 0xaf, 0xb5,
             ],
             k_enc: [
-                0xeb, 0xb2, 0xff, 0x9b, 0x1f, 0x29, 0x0d, 0xa5, 0x63, 0x27, 0xa9, 0x67, 0x71, 0xb2,
-                0x5f, 0x71, 0x29, 0xff, 0x10, 0x2e, 0xe6, 0xd2, 0xb2, 0x0d, 0xa0, 0x9a, 0x06, 0x25,
-                0xf8, 0xbb, 0x26, 0x07,
+                0xfe, 0xe3, 0xe3, 0xb5, 0xfd, 0x6c, 0xd8, 0x54, 0x44, 0x2b, 0x2a, 0xc2, 0x97, 0x70,
+                0xfb, 0x0e, 0x39, 0x32, 0xf4, 0x71, 0x52, 0x43, 0x26, 0xda, 0x4a, 0x57, 0xc2, 0x56,
+                0x18, 0x06, 0x9e, 0x99,
             ],
             p_enc: [
                 0x02, 0x1c, 0xa7, 0xb6, 0x49, 0x39, 0x9e, 0x13, 0xe4, 0x39, 0x44, 0x62, 0x91, 0x20,
@@ -1215,69 +1220,70 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x34, 0x1e, 0x4e, 0x6f,
             ],
             c_enc: [
-                0x96, 0x3b, 0xe3, 0x6e, 0xdc, 0xa4, 0x8b, 0x7c, 0x4a, 0x1c, 0xd6, 0xa1, 0x37, 0x2e,
-                0x84, 0xc0, 0x54, 0x54, 0x83, 0x4c, 0x5e, 0xe1, 0x92, 0x5e, 0xed, 0xeb, 0x48, 0xda,
-                0x16, 0x77, 0x79, 0xe3, 0x99, 0x83, 0x58, 0xcb, 0x92, 0x7a, 0x0a, 0x0b, 0x36, 0x9c,
-                0x85, 0xee, 0xb3, 0x30, 0xf7, 0x00, 0x5c, 0x26, 0x9d, 0x0b, 0xe4, 0xf2, 0x38, 0x09,
-                0x57, 0xb1, 0x62, 0x97, 0x7c, 0xae, 0x7a, 0x7b, 0x1d, 0x0b, 0xe5, 0xd0, 0xb7, 0x03,
-                0xd3, 0x92, 0xac, 0xae, 0xd2, 0x4f, 0x52, 0x5b, 0x83, 0xcf, 0xdd, 0x7f, 0x35, 0xc1,
-                0xf1, 0x74, 0xbf, 0x06, 0x6b, 0x7a, 0xfd, 0xb7, 0x45, 0xed, 0xbe, 0xdc, 0x0b, 0x46,
-                0xa5, 0x91, 0x36, 0x21, 0x47, 0x61, 0x9d, 0x6b, 0xd3, 0xf3, 0xce, 0x6b, 0x45, 0x23,
-                0xf0, 0x64, 0x9a, 0x7c, 0x65, 0x32, 0x2d, 0x05, 0xfa, 0xe2, 0x22, 0x70, 0x1a, 0x8c,
-                0xd6, 0xca, 0xbf, 0x8d, 0xc3, 0x2f, 0x05, 0x5f, 0xeb, 0x14, 0x1e, 0x55, 0x6d, 0xdf,
-                0xb1, 0x98, 0x30, 0xb7, 0x20, 0x4c, 0x30, 0x98, 0x4e, 0xdd, 0xf4, 0x34, 0xec, 0xc5,
-                0xf0, 0xea, 0x82, 0x5c, 0xf8, 0xd9, 0xd5, 0x03, 0x8f, 0x28, 0xe2, 0x3e, 0xf3, 0x6b,
-                0xa9, 0x38, 0x52, 0xe5, 0x8e, 0x85, 0xf8, 0x90, 0xb1, 0x77, 0x5c, 0x6d, 0x4c, 0x13,
-                0x5b, 0xef, 0x0e, 0x2a, 0x19, 0x33, 0x02, 0xd9, 0x0a, 0x80, 0x4c, 0x85, 0x31, 0x25,
-                0xaa, 0x5b, 0x11, 0x6f, 0x8c, 0x58, 0x0e, 0xb6, 0x54, 0xfe, 0x35, 0xe6, 0x73, 0x79,
-                0x9e, 0x93, 0xcf, 0x58, 0xfe, 0x1e, 0x70, 0xcd, 0xe1, 0x19, 0xab, 0x58, 0x6c, 0x12,
-                0xc4, 0x95, 0x75, 0xe6, 0x1a, 0xc4, 0xb7, 0x71, 0xfa, 0x8e, 0xbf, 0x76, 0xca, 0x95,
-                0xd6, 0x51, 0xa4, 0xba, 0x87, 0x3b, 0x24, 0xcf, 0x97, 0xff, 0x75, 0x5b, 0xc7, 0x49,
-                0xf4, 0x09, 0x6d, 0x2d, 0xa1, 0x5c, 0xf8, 0x30, 0x36, 0xcc, 0x22, 0x0f, 0x0a, 0x68,
-                0x93, 0x43, 0x21, 0xc9, 0xae, 0x33, 0x4e, 0x2d, 0x99, 0xa9, 0x95, 0xe9, 0x29, 0x04,
-                0xc1, 0x45, 0x23, 0x33, 0x19, 0x00, 0xcb, 0xca, 0x20, 0x4a, 0xdc, 0xb6, 0x93, 0x9d,
-                0xc1, 0x71, 0x87, 0x53, 0x53, 0xa1, 0x1e, 0x12, 0xba, 0xcb, 0x2a, 0xab, 0x0f, 0x57,
-                0x17, 0x9f, 0x1b, 0x67, 0xea, 0xcc, 0x7e, 0x7b, 0x6c, 0x5c, 0xc8, 0xa3, 0x78, 0x64,
-                0x9b, 0x62, 0xb8, 0x52, 0xfa, 0x47, 0x6f, 0x93, 0x37, 0x88, 0x59, 0xd0, 0xd9, 0xa3,
-                0x03, 0x3d, 0xa1, 0x31, 0x28, 0x17, 0x57, 0xad, 0x98, 0x5c, 0x86, 0xfe, 0x03, 0x7a,
-                0x4e, 0xdd, 0x0a, 0x4a, 0x49, 0xee, 0x5c, 0x4f, 0x48, 0x15, 0xf0, 0x14, 0x73, 0xb9,
-                0x60, 0xa1, 0x8a, 0x3b, 0x7f, 0x75, 0x07, 0xee, 0x3d, 0x8b, 0x39, 0x5a, 0x76, 0x68,
-                0x40, 0x95, 0x5b, 0xaa, 0xdd, 0x0a, 0xbb, 0xf4, 0xf5, 0x91, 0x4e, 0x92, 0x10, 0xf5,
-                0x9e, 0x4c, 0xd1, 0x3c, 0x82, 0xe0, 0xac, 0xf8, 0x79, 0x51, 0x78, 0x02, 0x91, 0xd0,
-                0xa9, 0xa7, 0x0f, 0x6b, 0x4f, 0xf5, 0x0d, 0x81, 0x0d, 0x50, 0x90, 0x20, 0x45, 0x30,
-                0xad, 0x69, 0x44, 0xb1, 0x3d, 0x23, 0x83, 0xab, 0xca, 0x42, 0x0c, 0xb6, 0xd9, 0xfc,
-                0xd8, 0xfd, 0xcb, 0xe9, 0xb3, 0xb5, 0xf4, 0x2f, 0x0a, 0xf5, 0xdf, 0x36, 0x37, 0x8c,
-                0xe7, 0x3d, 0xc9, 0x06, 0x16, 0x7d, 0xd4, 0xb3, 0x80, 0x41, 0x8f, 0x17, 0xe4, 0x50,
-                0x61, 0x18, 0x57, 0x23, 0xda, 0xbb, 0x6f, 0xfd, 0xbb, 0xd5, 0xa4, 0x18, 0xc3, 0xc6,
-                0xfd, 0x33, 0x70, 0x34, 0x09, 0x94, 0x27, 0x7b, 0x88, 0x8e, 0xe4, 0x9b, 0x08, 0x91,
-                0xbb, 0xb9, 0x4b, 0x6b, 0x8b, 0x06, 0x5f, 0xd1, 0x92, 0x00, 0xdc, 0x3a, 0x68, 0x1c,
-                0xa5, 0xff, 0x2a, 0x98, 0x8f, 0xa6, 0x6d, 0x02, 0x9d, 0xdd, 0xf9, 0xb0, 0x3a, 0x5e,
-                0x6c, 0x6e, 0x99, 0xb6, 0x35, 0x41, 0x15, 0x6a, 0x09, 0x51, 0xd9, 0x08, 0x7d, 0xd8,
-                0x83, 0xd5, 0x13, 0x9e, 0xe6, 0x7a, 0x8c, 0xe5, 0xdd, 0x6e, 0xf1, 0x4c, 0x9a, 0x10,
-                0xdb, 0x81, 0x8b, 0x93, 0x69, 0x02, 0xc7, 0x99, 0x93, 0x90, 0xf9, 0x72, 0xba, 0xfa,
-                0x5a, 0x57, 0x2f, 0xc8, 0x73, 0x42, 0xe2, 0xc5, 0x1c, 0xeb, 0x80, 0x30, 0xe0, 0x6b,
-                0x72, 0x40, 0x95, 0xf9, 0x8d, 0x7b,
+                0xbe, 0x1d, 0xff, 0xd3, 0x37, 0x0c, 0x67, 0x56, 0x69, 0xcc, 0x9a, 0xe1, 0xd0, 0x30,
+                0x2d, 0x7f, 0x90, 0x6d, 0x25, 0x23, 0x09, 0x3c, 0x24, 0xf4, 0x25, 0x7a, 0x83, 0xbc,
+                0x4f, 0x36, 0x62, 0x3a, 0x08, 0x2c, 0xe6, 0xeb, 0x45, 0x21, 0x95, 0x71, 0x91, 0xd5,
+                0x7e, 0x14, 0x11, 0xed, 0xe7, 0x1d, 0x44, 0xb5, 0x6c, 0x57, 0xcb, 0x22, 0x81, 0x4a,
+                0x04, 0x69, 0x39, 0xd2, 0xff, 0xf9, 0x2b, 0x46, 0x62, 0x76, 0x2d, 0x4f, 0x21, 0xc0,
+                0x78, 0x42, 0x74, 0x72, 0xb9, 0x18, 0x10, 0x10, 0x55, 0x56, 0xf4, 0xde, 0x0a, 0x27,
+                0xe7, 0x70, 0x08, 0x47, 0x72, 0xcb, 0xfe, 0xbf, 0x87, 0xdb, 0x33, 0x14, 0xab, 0x70,
+                0xf2, 0x6d, 0x11, 0xea, 0x5d, 0xe2, 0x67, 0xc3, 0xa9, 0xa8, 0xf4, 0x6b, 0xad, 0x13,
+                0xc7, 0x36, 0x26, 0x10, 0xbd, 0xba, 0x81, 0x02, 0xd4, 0xb7, 0x26, 0xef, 0x26, 0xec,
+                0x79, 0x4a, 0x15, 0x66, 0x57, 0x1b, 0xfd, 0xc1, 0x02, 0x47, 0x7d, 0xa5, 0xb4, 0x9b,
+                0xbf, 0x9f, 0xe4, 0xb1, 0xa4, 0x4e, 0xd0, 0xb3, 0xbc, 0xed, 0x99, 0xba, 0x81, 0x9a,
+                0x4f, 0x30, 0x22, 0x65, 0x49, 0x44, 0x5b, 0xc6, 0x1c, 0xff, 0x5c, 0x33, 0x16, 0x33,
+                0x5f, 0x6b, 0xd4, 0xa9, 0xa4, 0x24, 0xc9, 0x4a, 0xe0, 0xb5, 0xcb, 0xe4, 0x8a, 0xfb,
+                0x2b, 0x94, 0xd0, 0xc7, 0xe4, 0x4e, 0x32, 0x30, 0x95, 0xa7, 0x2e, 0x42, 0x64, 0xe9,
+                0x1c, 0x48, 0x94, 0xb9, 0xe8, 0x45, 0xaf, 0x32, 0x35, 0x02, 0xda, 0xe8, 0xc1, 0x86,
+                0x78, 0xa4, 0xf7, 0x40, 0xe5, 0xa6, 0x3a, 0x4c, 0x70, 0x29, 0x92, 0xfa, 0xcd, 0xd3,
+                0x57, 0x35, 0xb1, 0xd1, 0x34, 0x8b, 0x91, 0x9c, 0x70, 0x0c, 0x42, 0xd3, 0x30, 0xd3,
+                0x86, 0xaf, 0xb8, 0x73, 0xfa, 0xba, 0xd8, 0xcb, 0x32, 0x18, 0x15, 0x1b, 0x40, 0x18,
+                0x01, 0xe3, 0x69, 0x34, 0x4f, 0xf2, 0x0a, 0xaa, 0x66, 0x73, 0x47, 0x4f, 0x4b, 0xfc,
+                0x98, 0xd0, 0x7e, 0x36, 0x7b, 0xc4, 0x2e, 0xf1, 0xa0, 0x4f, 0xa1, 0xbc, 0x12, 0x52,
+                0x18, 0x8d, 0xd9, 0xd3, 0xe0, 0x00, 0xe3, 0xf5, 0xe9, 0xdf, 0xc9, 0xe1, 0x3e, 0xe9,
+                0xdb, 0x55, 0x04, 0x0d, 0x17, 0x22, 0x7d, 0xa4, 0x4a, 0x3e, 0x08, 0xfd, 0x5e, 0xc8,
+                0x58, 0xc4, 0x9c, 0x2e, 0x6a, 0x71, 0x1f, 0x8e, 0x68, 0xd0, 0xa1, 0xdf, 0x88, 0xef,
+                0x09, 0x40, 0xf7, 0x2e, 0xd7, 0x3e, 0xf4, 0x9e, 0x8a, 0x45, 0xae, 0x2e, 0x5e, 0x1b,
+                0xf1, 0x37, 0xba, 0x58, 0xcf, 0xb9, 0x25, 0x79, 0xab, 0xb2, 0xa4, 0x93, 0x13, 0xa2,
+                0xff, 0x3d, 0xb6, 0x16, 0x93, 0xd2, 0xb7, 0x58, 0xaf, 0x20, 0x47, 0x2a, 0xc6, 0x40,
+                0x6b, 0xa3, 0x55, 0xb4, 0x8c, 0xee, 0x22, 0xe7, 0x0f, 0xb8, 0xf9, 0xd4, 0x8e, 0xa3,
+                0x93, 0x4b, 0x62, 0x24, 0xac, 0xe2, 0x69, 0xb9, 0xef, 0x54, 0x6d, 0xbf, 0xc5, 0x2a,
+                0xbe, 0xcf, 0xac, 0x59, 0x40, 0xf0, 0x40, 0xbd, 0x21, 0xe9, 0x0e, 0xfa, 0x82, 0x75,
+                0x56, 0x1a, 0x88, 0xbc, 0x18, 0xe2, 0x6b, 0x98, 0x8d, 0x11, 0x79, 0xb7, 0xa2, 0xc3,
+                0xaf, 0xd8, 0x6e, 0xf2, 0xa0, 0x90, 0x62, 0x52, 0x23, 0x23, 0x4b, 0x39, 0xc9, 0xe2,
+                0x06, 0x8d, 0x94, 0x5d, 0xd7, 0x76, 0x3b, 0x01, 0x0c, 0x28, 0xc8, 0x9b, 0x72, 0xe2,
+                0x55, 0x13, 0xb3, 0x9c, 0x3c, 0xe1, 0x17, 0x73, 0x42, 0x8a, 0xd3, 0x44, 0xe1, 0xd5,
+                0xd5, 0x1b, 0x92, 0x00, 0x14, 0xf9, 0x17, 0x06, 0xff, 0xae, 0x3d, 0x86, 0x36, 0x14,
+                0x77, 0xfd, 0x5d, 0xe0, 0x13, 0x42, 0x2c, 0x06, 0xa3, 0x32, 0xe3, 0x45, 0x79, 0x75,
+                0xcf, 0x9b, 0xe9, 0xf9, 0xab, 0x3a, 0x06, 0x87, 0x2e, 0xf0, 0x71, 0x7d, 0x39, 0x08,
+                0xbd, 0xeb, 0xf8, 0x41, 0x8c, 0xe5, 0x57, 0xd5, 0x2d, 0x51, 0xa2, 0x50, 0xc0, 0x8c,
+                0x5b, 0x79, 0x3a, 0xd4, 0xbc, 0x0f, 0x16, 0xc6, 0x27, 0x89, 0xfe, 0xa2, 0xca, 0xb3,
+                0x9c, 0xcc, 0xa4, 0x07, 0xee, 0x9e, 0x47, 0xf5, 0x6d, 0x20, 0xa7, 0x41, 0x91, 0x2c,
+                0x6b, 0xad, 0xdb, 0xd7, 0xfa, 0x7b, 0x97, 0xe5, 0x46, 0x33, 0x61, 0x28, 0x74, 0x5a,
+                0xe7, 0xd7, 0x30, 0xa5, 0x5a, 0x6a, 0xc7, 0xb8, 0xfc, 0xbd, 0x72, 0xce, 0x78, 0x95,
+                0x9c, 0x7a, 0x79, 0x75, 0x21, 0x2c,
             ],
             ock: [
-                0x5b, 0x5b, 0x20, 0xfc, 0x46, 0xba, 0x14, 0xbd, 0x18, 0x43, 0xb6, 0xc7, 0x7e, 0xc3,
-                0xf4, 0x55, 0xb7, 0x65, 0xb4, 0xd1, 0x2d, 0xb6, 0x52, 0xeb, 0x34, 0x20, 0x0c, 0x41,
-                0x48, 0x88, 0x1f, 0xfc,
+                0xeb, 0x3e, 0xd9, 0xfc, 0xb3, 0xaa, 0x91, 0xc4, 0xf5, 0xec, 0xfd, 0x43, 0xdb, 0xda,
+                0x40, 0x33, 0x06, 0x93, 0xc3, 0xa6, 0x56, 0x75, 0x45, 0xfd, 0x23, 0x6a, 0xf1, 0x90,
+                0x8e, 0x29, 0x42, 0xa3,
             ],
             op: [
                 0x3f, 0xeb, 0x34, 0x5a, 0xec, 0xd3, 0x42, 0x9a, 0x16, 0xe1, 0x0f, 0x3d, 0x13, 0x20,
                 0xbc, 0x99, 0x71, 0xb5, 0x9e, 0x63, 0x9d, 0x62, 0xb6, 0x96, 0x1a, 0xea, 0x78, 0x15,
-                0x67, 0xa8, 0x60, 0x9e, 0x24, 0x75, 0x30, 0x5c, 0x35, 0xcf, 0x37, 0xeb, 0xd2, 0x77,
-                0x82, 0x35, 0x16, 0x58, 0x5a, 0xfa, 0x06, 0x05, 0x78, 0x52, 0x17, 0x1e, 0x0c, 0xe4,
-                0xb0, 0x52, 0xd5, 0xb4, 0x20, 0x41, 0xd8, 0x1c,
+                0x67, 0xa8, 0x60, 0x9e, 0x3b, 0xc1, 0x7a, 0x58, 0x0d, 0x53, 0x0f, 0x89, 0x30, 0xa3,
+                0x6b, 0x8d, 0x6f, 0xea, 0x67, 0x85, 0x7f, 0x7b, 0x85, 0x20, 0xfd, 0x2e, 0x0a, 0xb5,
+                0xd5, 0xcb, 0xab, 0x1a, 0xcc, 0xd5, 0x4e, 0x3a,
             ],
             c_out: [
-                0xe0, 0x1b, 0x5c, 0x1e, 0x01, 0x90, 0x0f, 0xf7, 0x9b, 0xf7, 0x27, 0xf5, 0x37, 0xc4,
-                0xac, 0x36, 0xf8, 0x06, 0x7a, 0x0c, 0xc5, 0xc8, 0xe9, 0xc8, 0x20, 0x44, 0x28, 0x43,
-                0x69, 0x35, 0x30, 0x91, 0x8a, 0xea, 0x67, 0x2c, 0x4c, 0xd8, 0xfa, 0x3f, 0x6f, 0x2c,
-                0xb6, 0x8b, 0x87, 0x17, 0x22, 0xe7, 0x78, 0xf6, 0xe2, 0x5e, 0x78, 0xae, 0x00, 0xa8,
-                0x43, 0x28, 0xc4, 0xc2, 0xbf, 0x1c, 0x79, 0xb2, 0xc9, 0xd8, 0x69, 0x72, 0x60, 0xcd,
-                0x44, 0x7e, 0x2e, 0xff, 0x31, 0x5d, 0x74, 0xb5, 0xb1, 0xfd,
-            ],
+                0x60, 0xf3, 0xe8, 0x94, 0xe3, 0x86, 0x4e, 0xfb, 0x48, 0xcc, 0xae, 0x50, 0xe1, 0x0d,
+                0xa7, 0x73, 0xdc, 0xcf, 0x85, 0x62, 0x45, 0x5d, 0x1b, 0x73, 0x1a, 0xad, 0x44, 0xe1,
+                0x5e, 0x3e, 0x40, 0x18, 0x31, 0xce, 0x6f, 0x92, 0xf4, 0x53, 0x2d, 0x90, 0x83, 0x92,
+                0x59, 0xce, 0x9c, 0xb1, 0x44, 0x62, 0x1f, 0x12, 0x01, 0x77, 0x8f, 0x61, 0x5d, 0x09,
+                0x87, 0x01, 0x0c, 0x8d, 0x13, 0x5c, 0x32, 0xd5, 0x6e, 0xe2, 0x84, 0x68, 0x65, 0xa2,
+                0x61, 0xde, 0x14, 0x25, 0xd2, 0x3b, 0xcc, 0x51, 0xb8, 0xa0,
+            ],
+            note_type: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1351,34 +1357,34 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x88, 0xff, 0xee, 0x2f,
             ],
             rho: [
-                0xe9, 0x16, 0x93, 0xc3, 0x7d, 0x04, 0x37, 0x5e, 0x67, 0xc5, 0x71, 0x5a, 0x39, 0xc9,
-                0x79, 0x4a, 0x4e, 0xcd, 0x08, 0x38, 0xe2, 0x35, 0x1f, 0xd7, 0xcd, 0x93, 0xa1, 0x55,
-                0x7f, 0x01, 0x02, 0x3e,
+                0x54, 0x3e, 0xa7, 0x11, 0x56, 0xc9, 0xa6, 0xf8, 0x04, 0x1f, 0xa7, 0x7e, 0xc1, 0xc5,
+                0xaf, 0x90, 0x28, 0x8f, 0x27, 0x20, 0xf1, 0x3f, 0xf0, 0x93, 0xc6, 0x86, 0x26, 0x6b,
+                0x92, 0xd7, 0xa0, 0x24,
             ],
             cmx: [
-                0xcc, 0x29, 0x41, 0xe0, 0xf6, 0x38, 0x25, 0x7f, 0xb6, 0x51, 0x6a, 0x27, 0xc3, 0x0e,
-                0xaa, 0xe0, 0xb4, 0x6d, 0x2f, 0xf0, 0x6a, 0x73, 0x50, 0x70, 0x41, 0x74, 0x6c, 0xdc,
-                0x23, 0x07, 0x61, 0x25,
+                0x1d, 0x51, 0xea, 0x92, 0xfa, 0x43, 0x55, 0x0a, 0x0e, 0xdd, 0xea, 0x23, 0x6e, 0x17,
+                0xa0, 0x16, 0x93, 0xc2, 0x2d, 0x8d, 0xd8, 0x1c, 0x9c, 0x9e, 0xc8, 0x76, 0xa2, 0x4e,
+                0x67, 0xd4, 0x93, 0x0b,
             ],
             esk: [
-                0xec, 0x99, 0xeb, 0x6f, 0x67, 0x1d, 0x0a, 0x9e, 0x84, 0x5a, 0xbf, 0xb7, 0x8a, 0xec,
-                0xe9, 0x32, 0xeb, 0x13, 0xf5, 0xae, 0xd6, 0x4f, 0x20, 0xa7, 0x77, 0xc9, 0x46, 0xe9,
-                0xcd, 0x7a, 0x24, 0x23,
+                0x19, 0xe0, 0x26, 0x4b, 0x82, 0x88, 0xf7, 0x3e, 0xbf, 0x97, 0x14, 0xb0, 0xdf, 0x85,
+                0x8e, 0xf7, 0xab, 0x39, 0xec, 0x50, 0x2c, 0xd2, 0x98, 0xf2, 0xc4, 0x84, 0xa9, 0xf4,
+                0xc7, 0xda, 0x74, 0x36,
             ],
             ephemeral_key: [
-                0xad, 0xa7, 0x60, 0x27, 0xdc, 0xae, 0xb5, 0xf1, 0x58, 0xac, 0x6c, 0x5c, 0x6d, 0x7f,
-                0x05, 0x31, 0x8f, 0xec, 0x26, 0xd5, 0xc7, 0x94, 0xf2, 0xe9, 0x00, 0xcb, 0x96, 0x29,
-                0x92, 0x49, 0xe0, 0xb5,
+                0x8f, 0xbe, 0xb6, 0xb3, 0x03, 0x8e, 0x69, 0x49, 0x91, 0x6a, 0x2c, 0x06, 0x0e, 0xf9,
+                0xa4, 0xb1, 0xfe, 0xf1, 0x3a, 0xce, 0x2f, 0xee, 0x00, 0x25, 0xda, 0x32, 0xc3, 0x6d,
+                0x23, 0x1a, 0x61, 0x34,
             ],
             shared_secret: [
-                0xc2, 0x5c, 0xf1, 0xd6, 0x53, 0x2e, 0x06, 0xcb, 0x8b, 0x15, 0x22, 0x14, 0x76, 0x6e,
-                0xee, 0xd7, 0x5a, 0x17, 0x8c, 0x82, 0x2a, 0x11, 0x51, 0xf6, 0x9e, 0x92, 0xe9, 0xcf,
-                0xfa, 0x47, 0xcb, 0x19,
+                0x67, 0xd6, 0x8a, 0x5a, 0x05, 0x93, 0xfd, 0x16, 0x7d, 0x38, 0x08, 0x2e, 0x49, 0xd2,
+                0x30, 0x30, 0x86, 0xe5, 0x5a, 0x43, 0xc1, 0x24, 0xd5, 0xaa, 0xa8, 0x20, 0xab, 0x0c,
+                0x3f, 0x5c, 0xc5, 0x37,
             ],
             k_enc: [
-                0xd4, 0xef, 0x89, 0xc4, 0x64, 0xbe, 0x8f, 0x42, 0xf6, 0xb7, 0xf2, 0x6d, 0x89, 0x37,
-                0x8b, 0x73, 0xa3, 0x55, 0xa4, 0xfe, 0x24, 0x6c, 0x2e, 0xc8, 0xe8, 0x14, 0x6b, 0xef,
-                0x7d, 0xdd, 0x14, 0x19,
+                0x6b, 0x8d, 0x83, 0xf2, 0xf1, 0xfd, 0x1e, 0xad, 0x7d, 0x45, 0x42, 0xb3, 0x63, 0x09,
+                0x34, 0x07, 0xc5, 0x0a, 0x20, 0xed, 0x7f, 0x0e, 0x8c, 0xf2, 0xdb, 0x53, 0x6d, 0xb1,
+                0xbe, 0x25, 0xe9, 0x8d,
             ],
             p_enc: [
                 0x02, 0x56, 0x4f, 0xc3, 0x81, 0xfc, 0x4d, 0xc8, 0x11, 0x8d, 0xe4, 0x7c, 0x10, 0xb8,
@@ -1424,69 +1430,70 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x1a, 0x81, 0xa3, 0x59,
             ],
             c_enc: [
-                0xea, 0x86, 0x7e, 0x07, 0xac, 0xb7, 0xfa, 0x03, 0xe7, 0x36, 0xce, 0xdd, 0xed, 0x82,
-                0x3d, 0x19, 0x91, 0x30, 0xfb, 0x3f, 0xef, 0x62, 0xcc, 0x3e, 0xa9, 0xa0, 0xc9, 0x35,
-                0xdf, 0x05, 0xc5, 0xad, 0x5e, 0x67, 0xf7, 0x4f, 0xcb, 0xa6, 0x67, 0xe0, 0x81, 0x1c,
-                0xdc, 0x0c, 0xa9, 0xf3, 0xd7, 0x81, 0x76, 0x43, 0x75, 0x56, 0x47, 0xbe, 0x59, 0xdf,
-                0x09, 0x6e, 0x46, 0x5e, 0xc1, 0x11, 0x24, 0x36, 0x3c, 0x98, 0x1c, 0x55, 0xd5, 0x5f,
-                0x8d, 0x8a, 0xc8, 0xb6, 0x54, 0x0a, 0x98, 0xcf, 0xcc, 0x29, 0x4a, 0xa7, 0xcc, 0x62,
-                0x95, 0x50, 0x85, 0x3a, 0x25, 0xbf, 0x6b, 0x32, 0x35, 0x16, 0xe1, 0x58, 0x2b, 0x4e,
-                0x8b, 0x82, 0x95, 0xe2, 0x7f, 0x6b, 0x99, 0x94, 0x80, 0x2e, 0xfe, 0xf5, 0x43, 0x1f,
-                0x03, 0x7d, 0x22, 0x09, 0xa0, 0x88, 0x07, 0x34, 0x6f, 0xb3, 0x9c, 0xad, 0xd8, 0x93,
-                0xd6, 0x5f, 0x64, 0xc7, 0xfe, 0x92, 0xec, 0xbc, 0xdf, 0xe5, 0x55, 0x54, 0xca, 0xff,
-                0xb0, 0xcf, 0x41, 0xeb, 0x5c, 0x55, 0x72, 0xba, 0x44, 0x39, 0x90, 0x00, 0xe9, 0xfa,
-                0x9a, 0xaf, 0x6e, 0xb7, 0x6c, 0x2a, 0x8a, 0x5d, 0x7b, 0x6b, 0x52, 0xb9, 0xa9, 0xef,
-                0x6e, 0xc3, 0xed, 0xa6, 0x65, 0xfe, 0x8a, 0xa8, 0x07, 0x48, 0xb8, 0x1f, 0x7d, 0x55,
-                0x96, 0xf1, 0x94, 0x2f, 0xf7, 0x1d, 0x29, 0xc6, 0x78, 0xa3, 0xb6, 0xc6, 0x6b, 0xa7,
-                0x0f, 0x45, 0xb1, 0xfc, 0xf2, 0x22, 0x38, 0x84, 0x50, 0x68, 0xf3, 0x60, 0xb0, 0x99,
-                0xae, 0xe9, 0xf2, 0xf0, 0xef, 0x22, 0x33, 0x3f, 0xd6, 0x4f, 0xf1, 0x1e, 0x48, 0x15,
-                0x43, 0xa5, 0x2b, 0xb3, 0x3f, 0x52, 0x3d, 0xe2, 0xec, 0x92, 0x3a, 0xe9, 0x86, 0x58,
-                0x57, 0x71, 0x7b, 0x65, 0xd4, 0x4c, 0x3d, 0x9d, 0xb7, 0xb3, 0xec, 0xb2, 0xff, 0x02,
-                0x25, 0x29, 0x7d, 0xeb, 0x83, 0xdd, 0x1b, 0x9a, 0x39, 0x4d, 0x69, 0x7c, 0x09, 0xd7,
-                0xfe, 0xc6, 0x1e, 0xac, 0xee, 0x39, 0xa2, 0xf1, 0xce, 0xd9, 0xe6, 0xfd, 0xa5, 0xc0,
-                0xf3, 0x27, 0x71, 0xc6, 0xce, 0x3f, 0x17, 0xbe, 0x0e, 0xef, 0x81, 0x10, 0x99, 0xc1,
-                0x09, 0xe4, 0xfb, 0x6a, 0xec, 0x30, 0xdf, 0x04, 0x5b, 0x43, 0xda, 0x89, 0x30, 0x8b,
-                0xc8, 0x37, 0x68, 0x8b, 0xb0, 0xf4, 0xa2, 0xc6, 0x04, 0xa1, 0x54, 0xa8, 0x47, 0xc5,
-                0xd7, 0x87, 0x27, 0xf0, 0xe1, 0xab, 0x11, 0xe3, 0x40, 0xcf, 0xd4, 0xc7, 0xe8, 0xc6,
-                0xba, 0xff, 0xfe, 0xfc, 0x74, 0xef, 0x55, 0x3d, 0x4b, 0x29, 0x26, 0x9f, 0x38, 0xb4,
-                0xb7, 0xfe, 0x6e, 0x07, 0x3a, 0x70, 0xae, 0xf2, 0x0d, 0x6c, 0x23, 0x8b, 0x9f, 0xfd,
-                0x24, 0x1f, 0xf6, 0x99, 0x99, 0x92, 0x30, 0xf0, 0xb3, 0x9c, 0x96, 0x3e, 0xfa, 0x00,
-                0xef, 0x7f, 0x09, 0x2d, 0x76, 0x0c, 0x40, 0x9a, 0x2b, 0x6c, 0x26, 0xb4, 0x97, 0x82,
-                0x9b, 0x81, 0xcb, 0xa4, 0xc8, 0x3b, 0x11, 0x44, 0xc6, 0x5a, 0x2d, 0x31, 0x78, 0xbb,
-                0x28, 0xc1, 0xd8, 0xe3, 0x30, 0xd3, 0xf4, 0xaf, 0x90, 0x10, 0xad, 0x49, 0xa5, 0xdb,
-                0x70, 0xd6, 0x6a, 0xf5, 0x70, 0x19, 0x21, 0x49, 0x80, 0x5f, 0xe1, 0xca, 0x61, 0xc6,
-                0xd4, 0xec, 0xaf, 0xa7, 0x97, 0x51, 0x7f, 0x33, 0x06, 0xaf, 0x2a, 0x32, 0x27, 0x3b,
-                0xf3, 0xd6, 0x98, 0xaa, 0x55, 0xa5, 0x72, 0xb2, 0xdf, 0x80, 0x36, 0xd9, 0x7c, 0xf5,
-                0x8c, 0x12, 0x9f, 0x82, 0x85, 0xd0, 0xd7, 0xea, 0x04, 0xc1, 0x88, 0xa8, 0x39, 0x6e,
-                0x73, 0x8b, 0xd4, 0x48, 0x46, 0x5e, 0x7b, 0x9a, 0x64, 0xb7, 0x96, 0x7b, 0xcb, 0x25,
-                0xf8, 0xaa, 0x85, 0x9e, 0xa5, 0xca, 0x06, 0xc3, 0xdf, 0x39, 0x0f, 0xac, 0x8a, 0xc6,
-                0x06, 0x05, 0x03, 0x1a, 0x02, 0x09, 0xbb, 0x80, 0x24, 0x0d, 0x05, 0x45, 0xf4, 0x11,
-                0x77, 0xea, 0xb4, 0x40, 0x2e, 0x8a, 0x42, 0x3a, 0x40, 0xcc, 0xff, 0x58, 0x6b, 0x2e,
-                0xdd, 0x6a, 0xcf, 0xb8, 0xf1, 0xd8, 0x0d, 0x8c, 0x60, 0x5f, 0x49, 0x05, 0x2e, 0x7a,
-                0x30, 0x82, 0x6e, 0x1f, 0x03, 0x09, 0x9c, 0x71, 0x43, 0xad, 0x0b, 0x51, 0xfc, 0x63,
-                0x6f, 0x1d, 0x87, 0x05, 0x83, 0xd6, 0xed, 0xce, 0xcd, 0xe9, 0x42, 0x38, 0x9e, 0x6c,
-                0x01, 0x00, 0x66, 0x78, 0xda, 0xad,
+                0x77, 0xc6, 0xef, 0xc8, 0xb5, 0x42, 0xa7, 0x07, 0xc0, 0xa5, 0xcf, 0x5c, 0xe3, 0xf3,
+                0xb9, 0x6d, 0xe1, 0x91, 0x95, 0x7c, 0x9f, 0xa6, 0xe9, 0xbb, 0x4b, 0x8d, 0x89, 0x9e,
+                0x1f, 0x19, 0xe0, 0x20, 0xba, 0x7b, 0xb3, 0xfe, 0xf1, 0x67, 0x81, 0xc8, 0x8c, 0xc5,
+                0xd4, 0x4a, 0x5e, 0xf8, 0x17, 0x31, 0x47, 0xdc, 0x3d, 0x1b, 0x51, 0x6a, 0xf6, 0xdd,
+                0x77, 0xdd, 0xb6, 0xee, 0x67, 0xaa, 0xf5, 0x42, 0xce, 0xe2, 0xbe, 0xd3, 0xe4, 0xa0,
+                0x7e, 0xce, 0x42, 0x8f, 0x22, 0xa8, 0x01, 0xcf, 0x01, 0xba, 0xad, 0x18, 0x27, 0xfd,
+                0x42, 0x57, 0x46, 0xc5, 0x45, 0x00, 0x1c, 0x35, 0x6d, 0x0a, 0xbe, 0xaa, 0xa5, 0xa4,
+                0x22, 0xdf, 0xff, 0x0e, 0xe2, 0x18, 0xac, 0x37, 0xef, 0x83, 0x97, 0xc6, 0x2c, 0xa8,
+                0x6f, 0xab, 0xeb, 0xb6, 0x88, 0xb3, 0x8f, 0xb4, 0xa6, 0x54, 0x29, 0x11, 0xbe, 0x1c,
+                0x5e, 0x71, 0x77, 0x8b, 0x5e, 0xb5, 0x3a, 0xf1, 0xc4, 0xcb, 0x4d, 0xd9, 0x94, 0x72,
+                0x4f, 0x61, 0x0f, 0x38, 0x72, 0x4a, 0x73, 0xdf, 0x09, 0x2b, 0xea, 0xe8, 0xb8, 0x7f,
+                0x7f, 0x6a, 0x2b, 0xc0, 0x9d, 0xf2, 0xaa, 0x18, 0xc2, 0xf8, 0xee, 0xba, 0x63, 0xee,
+                0x0d, 0x31, 0x35, 0x3b, 0x6f, 0x28, 0x3e, 0xf5, 0x9a, 0xc1, 0x53, 0x60, 0x73, 0xda,
+                0x7a, 0x6d, 0x82, 0xbf, 0xdc, 0x09, 0x74, 0x02, 0x08, 0x0f, 0xa1, 0x03, 0xcb, 0x8b,
+                0x3e, 0xfb, 0x94, 0x1e, 0xe5, 0x01, 0xf6, 0x41, 0x2c, 0xfb, 0xc2, 0x50, 0xaf, 0xad,
+                0xbe, 0x54, 0x4a, 0xc5, 0x1f, 0xce, 0x41, 0x5a, 0x24, 0x93, 0xba, 0x83, 0x9e, 0x38,
+                0x18, 0xb0, 0xfe, 0x30, 0x18, 0xbf, 0xa4, 0x37, 0xf0, 0x6e, 0x31, 0x86, 0x14, 0x8a,
+                0xa4, 0x05, 0xba, 0xb8, 0x21, 0xa2, 0x6e, 0xa0, 0x7f, 0x93, 0xcf, 0xe7, 0x56, 0x8f,
+                0xe3, 0xef, 0x08, 0xfa, 0x0b, 0x80, 0xfc, 0xec, 0x5b, 0xd5, 0x91, 0x5f, 0x68, 0x8c,
+                0xf5, 0x99, 0x31, 0x5e, 0x79, 0xaa, 0xea, 0x34, 0xd5, 0x18, 0xd9, 0x55, 0xfe, 0xef,
+                0x30, 0x3f, 0x69, 0xb2, 0x87, 0xc6, 0xd0, 0x51, 0x6d, 0xa2, 0x39, 0xfb, 0xbd, 0xdb,
+                0xaf, 0x25, 0x56, 0xeb, 0xce, 0x77, 0xa3, 0xd5, 0x97, 0x23, 0x5c, 0x22, 0xd3, 0x8c,
+                0x5b, 0x5e, 0xeb, 0x98, 0xc7, 0xc0, 0x8d, 0xa8, 0xd3, 0x76, 0xbb, 0xa1, 0xb5, 0x07,
+                0x85, 0xbe, 0x82, 0xbf, 0xe0, 0x9a, 0xe7, 0x1c, 0xcc, 0xaf, 0x31, 0xa2, 0xf0, 0xcf,
+                0xa0, 0x76, 0xd1, 0xe4, 0xd1, 0xb5, 0x2f, 0xee, 0x45, 0xc8, 0xed, 0x23, 0xdf, 0x33,
+                0xa8, 0x1c, 0xb1, 0xa8, 0xac, 0xec, 0x9f, 0x53, 0x5d, 0xa4, 0x96, 0x70, 0xf9, 0x98,
+                0x6d, 0x5c, 0x92, 0xc8, 0x2b, 0x0a, 0xd2, 0x20, 0xf8, 0x5f, 0x3b, 0x38, 0x72, 0xeb,
+                0xe0, 0x53, 0xcd, 0xeb, 0x96, 0x1b, 0xd2, 0xd3, 0xab, 0x3b, 0xcd, 0x67, 0x6e, 0x6f,
+                0xd7, 0xcb, 0xe9, 0x79, 0x5e, 0x1f, 0x2d, 0x82, 0x87, 0x00, 0x7c, 0x91, 0x0e, 0x7b,
+                0x43, 0x01, 0x69, 0xe4, 0x51, 0xf0, 0xb2, 0xd7, 0x63, 0xe5, 0x43, 0x03, 0x3b, 0xc6,
+                0xc7, 0x38, 0x9f, 0xa1, 0x61, 0x5b, 0xa1, 0x9d, 0x1f, 0x27, 0x48, 0xb2, 0x17, 0xc9,
+                0x60, 0xfe, 0x05, 0x04, 0x07, 0xc8, 0xf4, 0x73, 0x35, 0x6b, 0xaa, 0x6e, 0x0c, 0x7d,
+                0x77, 0xfa, 0xc6, 0xc7, 0xdb, 0x45, 0x12, 0xaf, 0x57, 0x96, 0xb3, 0xbc, 0xf1, 0x23,
+                0xe0, 0x90, 0xb9, 0x80, 0xeb, 0xc2, 0xd6, 0x4b, 0x86, 0xdd, 0x24, 0xcb, 0x9a, 0x6d,
+                0xab, 0x1d, 0xb4, 0x13, 0x04, 0x75, 0x38, 0x90, 0x2e, 0x2e, 0x49, 0x0e, 0x4f, 0xc8,
+                0x78, 0xaa, 0x04, 0xdb, 0xef, 0x66, 0x99, 0x63, 0x9c, 0x3d, 0xab, 0x17, 0xc5, 0x14,
+                0x70, 0x48, 0xac, 0x6d, 0x48, 0x49, 0x0d, 0xc4, 0x88, 0x5e, 0xd9, 0x86, 0x70, 0x63,
+                0x35, 0xf4, 0x1b, 0xa4, 0x15, 0x59, 0x65, 0x9e, 0x1b, 0x53, 0xda, 0x76, 0x51, 0x4c,
+                0xc4, 0x0a, 0xdb, 0x66, 0xc3, 0x5c, 0xe5, 0x6f, 0x3a, 0xbe, 0x39, 0xe1, 0xae, 0xe5,
+                0x84, 0x9f, 0xff, 0xcc, 0x6e, 0x1f, 0x1b, 0xf8, 0x11, 0xce, 0xb6, 0x65, 0xa6, 0xfc,
+                0xf8, 0x80, 0x6b, 0xbb, 0xba, 0x4a, 0x5b, 0x87, 0x38, 0xa1, 0x17, 0xdc, 0xaf, 0xfb,
+                0x4f, 0xdf, 0x10, 0x08, 0x00, 0x6f,
             ],
             ock: [
-                0xf9, 0x59, 0x87, 0xcc, 0x0c, 0x73, 0x57, 0xc7, 0x20, 0x26, 0x27, 0xa5, 0xa5, 0x50,
-                0x09, 0xef, 0xd7, 0x17, 0x55, 0x3e, 0x9d, 0x34, 0xc1, 0x5f, 0xad, 0xf5, 0xc9, 0x46,
-                0xa9, 0xa0, 0x72, 0x17,
+                0xb4, 0xf8, 0x8a, 0x29, 0x2d, 0x09, 0xd9, 0x35, 0xb4, 0x77, 0x5a, 0x29, 0x30, 0xeb,
+                0x38, 0xce, 0xbd, 0x5a, 0xf6, 0xff, 0x3f, 0x39, 0xef, 0x5b, 0xb2, 0x4c, 0xd5, 0x72,
+                0x81, 0xf0, 0x8c, 0xfb,
             ],
             op: [
                 0xae, 0xee, 0xa5, 0x0c, 0x6b, 0xb0, 0x2e, 0x5e, 0x22, 0x4d, 0xc2, 0x95, 0x9c, 0x22,
                 0x9d, 0x0e, 0x3b, 0xb8, 0x79, 0xc4, 0xab, 0x00, 0xaa, 0x0a, 0xb2, 0x5a, 0x40, 0x10,
-                0x6b, 0x80, 0xbb, 0xb7, 0xec, 0x99, 0xeb, 0x6f, 0x67, 0x1d, 0x0a, 0x9e, 0x84, 0x5a,
-                0xbf, 0xb7, 0x8a, 0xec, 0xe9, 0x32, 0xeb, 0x13, 0xf5, 0xae, 0xd6, 0x4f, 0x20, 0xa7,
-                0x77, 0xc9, 0x46, 0xe9, 0xcd, 0x7a, 0x24, 0x23,
+                0x6b, 0x80, 0xbb, 0xb7, 0x19, 0xe0, 0x26, 0x4b, 0x82, 0x88, 0xf7, 0x3e, 0xbf, 0x97,
+                0x14, 0xb0, 0xdf, 0x85, 0x8e, 0xf7, 0xab, 0x39, 0xec, 0x50, 0x2c, 0xd2, 0x98, 0xf2,
+                0xc4, 0x84, 0xa9, 0xf4, 0xc7, 0xda, 0x74, 0x36,
             ],
             c_out: [
-                0x28, 0x9d, 0x00, 0xd4, 0x62, 0x78, 0x0b, 0xdb, 0xb6, 0xcd, 0x6c, 0xec, 0x93, 0x6b,
-                0xe6, 0x5e, 0x63, 0x0d, 0x4a, 0x3c, 0x2a, 0xf7, 0x6e, 0x10, 0x4b, 0x17, 0x4e, 0x3d,
-                0x5b, 0x71, 0x66, 0x39, 0xb0, 0x68, 0xb3, 0x85, 0x00, 0xd8, 0x04, 0x00, 0xee, 0x64,
-                0x2f, 0x8e, 0x08, 0xc8, 0xdb, 0x29, 0xff, 0xd5, 0xa9, 0xda, 0xde, 0x84, 0xa5, 0x49,
-                0x5d, 0x57, 0x7b, 0x2f, 0x56, 0xd3, 0x2b, 0x07, 0x96, 0xca, 0x23, 0xf0, 0x0f, 0x0f,
-                0x8e, 0xf9, 0x93, 0x07, 0x4f, 0x88, 0x0d, 0x6a, 0xeb, 0xcb,
-            ],
+                0x94, 0xe3, 0x7f, 0xd6, 0x62, 0x82, 0xc0, 0x2e, 0x90, 0xe7, 0x69, 0x91, 0x4c, 0xaf,
+                0x95, 0xa4, 0x95, 0xf4, 0x89, 0x7f, 0x55, 0xa5, 0xae, 0x95, 0xad, 0xe8, 0xbf, 0x67,
+                0x61, 0xe3, 0x1b, 0xa5, 0xd1, 0xcf, 0xeb, 0x30, 0x6f, 0x4e, 0x22, 0x01, 0x42, 0x51,
+                0xcb, 0xe3, 0xf8, 0x72, 0x4b, 0xe7, 0x69, 0x21, 0xe2, 0xad, 0xa4, 0x6e, 0x3b, 0x14,
+                0x5d, 0x1b, 0x04, 0x3e, 0xb1, 0x2a, 0x0e, 0xfa, 0xb5, 0x16, 0x09, 0x34, 0xbc, 0x75,
+                0x9e, 0x02, 0x01, 0xd8, 0x66, 0xad, 0xa7, 0x44, 0x35, 0x71,
+            ],
+            note_type: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1560,34 +1567,34 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xe2, 0x3c, 0x39, 0x11,
             ],
             rho: [
-                0x35, 0x6f, 0xc7, 0x2e, 0x1b, 0xf1, 0xe3, 0xa2, 0xa5, 0x9a, 0xa9, 0xe4, 0x75, 0x15,
-                0x5c, 0xf7, 0x43, 0xf8, 0xfd, 0xf0, 0xd1, 0x5b, 0x4c, 0xc4, 0x02, 0x60, 0xd0, 0xd0,
-                0x9a, 0xda, 0x04, 0x08,
+                0xbd, 0xda, 0xe8, 0xdf, 0xf1, 0x20, 0x5e, 0x04, 0x96, 0x8f, 0xae, 0x1f, 0xd9, 0xbe,
+                0x51, 0xd8, 0x25, 0xf5, 0xd8, 0x78, 0x1d, 0x93, 0x3d, 0x0f, 0x5b, 0xce, 0x9c, 0xa8,
+                0x3e, 0xe8, 0xed, 0x20,
             ],
             cmx: [
-                0xca, 0xa2, 0x8a, 0x69, 0x04, 0x54, 0x66, 0x37, 0xa7, 0xd4, 0xe5, 0xfb, 0xc2, 0x65,
-                0x4c, 0xbf, 0x24, 0x4d, 0x18, 0x77, 0x9d, 0x35, 0x62, 0x25, 0x6c, 0x14, 0xd5, 0xb1,
-                0x00, 0x5d, 0xc6, 0x0f,
+                0xbe, 0x43, 0xee, 0x84, 0x70, 0x70, 0x75, 0xac, 0x48, 0x08, 0xd0, 0x97, 0x54, 0x07,
+                0xc0, 0x27, 0x36, 0xd7, 0x66, 0x64, 0xf4, 0xe7, 0xae, 0xce, 0x01, 0xd9, 0xcc, 0x68,
+                0x32, 0x4a, 0xe9, 0x04,
             ],
             esk: [
-                0x01, 0xa3, 0x66, 0x1e, 0xa9, 0xaa, 0xb8, 0xf4, 0x32, 0x53, 0x42, 0x0e, 0xff, 0xd7,
-                0xa4, 0x83, 0xc2, 0x79, 0xd4, 0x18, 0x18, 0xbc, 0xb3, 0xee, 0x91, 0x90, 0x01, 0xf8,
-                0x66, 0xa8, 0xe9, 0x2c,
+                0xf9, 0xf7, 0xa0, 0x10, 0x5e, 0xa9, 0xf4, 0x45, 0xfb, 0x7a, 0x14, 0x49, 0x72, 0x62,
+                0xc6, 0xe4, 0xd7, 0x32, 0x89, 0x32, 0x7b, 0x8a, 0x2d, 0xf5, 0xe2, 0x63, 0xf3, 0xe3,
+                0x99, 0x07, 0xea, 0x0c,
             ],
             ephemeral_key: [
-                0x00, 0x62, 0x7e, 0x29, 0xc1, 0x83, 0x3e, 0x4e, 0x8f, 0xad, 0xe0, 0x82, 0x52, 0xf3,
-                0x83, 0x67, 0x78, 0xb9, 0x39, 0x4c, 0x1f, 0xfe, 0xab, 0x70, 0xbf, 0x35, 0x93, 0xd5,
-                0x9a, 0x81, 0xa0, 0xa5,
+                0xfa, 0x19, 0xa1, 0x52, 0x7b, 0x76, 0x04, 0x8f, 0xf3, 0x7f, 0xa4, 0xf8, 0x27, 0x89,
+                0xfe, 0x80, 0xb0, 0xcd, 0xd3, 0x5d, 0x5d, 0xa9, 0xc2, 0xec, 0x3f, 0xe3, 0x04, 0x38,
+                0x05, 0xc0, 0x61, 0x23,
             ],
             shared_secret: [
-                0xa9, 0x93, 0x34, 0x1f, 0x99, 0xeb, 0xa8, 0x2d, 0xb6, 0xec, 0x5e, 0x71, 0x3e, 0xe2,
-                0x9c, 0x01, 0xf4, 0xce, 0x2a, 0x8b, 0xb6, 0xb5, 0xeb, 0xb6, 0x0b, 0xa6, 0xeb, 0xa9,
-                0x6b, 0xa4, 0x17, 0x9b,
+                0x2d, 0xb5, 0xb8, 0x92, 0xb6, 0x1b, 0x9c, 0x55, 0x3b, 0x6c, 0x9b, 0x7a, 0xcc, 0x7d,
+                0x71, 0x05, 0xc1, 0xdd, 0x4c, 0x28, 0xc6, 0x7f, 0x97, 0x8b, 0x6d, 0x79, 0xc7, 0x1b,
+                0x98, 0xa0, 0xd0, 0x00,
             ],
             k_enc: [
-                0x35, 0x81, 0x19, 0x19, 0x3c, 0x9d, 0x2a, 0xb6, 0xd4, 0x95, 0xe0, 0x19, 0xf9, 0x7a,
-                0x1c, 0x41, 0x30, 0xae, 0xe6, 0x3d, 0xae, 0xc6, 0xbb, 0xa2, 0xf2, 0x74, 0x40, 0x0f,
-                0xd3, 0x4f, 0xad, 0x28,
+                0x16, 0xe3, 0xf9, 0x85, 0xc0, 0x7f, 0xef, 0xe5, 0x30, 0xd9, 0xe6, 0x94, 0x5e, 0xde,
+                0xc1, 0x90, 0x3b, 0xb1, 0xca, 0x8d, 0xa5, 0xa2, 0x5b, 0xe9, 0x59, 0x78, 0x63, 0x7a,
+                0x40, 0x8c, 0x2e, 0xfe,
             ],
             p_enc: [
                 0x02, 0xc6, 0xe8, 0xf0, 0xd5, 0x0a, 0xe8, 0x05, 0x87, 0x91, 0xdc, 0x0e, 0x46, 0x49,
@@ -1633,69 +1640,70 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x84, 0x37, 0x3f, 0x4f,
             ],
             c_enc: [
-                0x31, 0xac, 0xda, 0xa6, 0xc1, 0x76, 0xbb, 0x7a, 0x2c, 0x7d, 0x66, 0x09, 0xdc, 0x2c,
-                0x5e, 0x7b, 0x2e, 0xe7, 0x1d, 0xa9, 0x3c, 0x73, 0x87, 0x52, 0x74, 0xfa, 0x6c, 0x2a,
-                0xd6, 0x26, 0x13, 0xc7, 0x18, 0x9b, 0x35, 0x33, 0xec, 0xf0, 0x34, 0xd8, 0x76, 0xc7,
-                0x26, 0xf1, 0xed, 0x99, 0x43, 0xd4, 0x45, 0x07, 0x87, 0x52, 0x75, 0xa8, 0xe3, 0x71,
-                0x0a, 0x11, 0x8d, 0x91, 0x64, 0x72, 0x91, 0x28, 0x6c, 0xf8, 0x80, 0xa7, 0x82, 0xab,
-                0xea, 0xa8, 0xa6, 0xc3, 0x2f, 0xdf, 0x6f, 0x30, 0x4b, 0x0e, 0xe5, 0xbc, 0xb1, 0x4b,
-                0x82, 0x79, 0x2a, 0xa3, 0xaf, 0xd7, 0x24, 0x3f, 0x57, 0xb7, 0xdc, 0xa7, 0x93, 0x52,
-                0x19, 0xdf, 0x98, 0x2c, 0xe1, 0x28, 0xae, 0xa6, 0xf6, 0xbd, 0x18, 0xe1, 0x30, 0x7e,
-                0xba, 0x0e, 0x3d, 0xb0, 0x06, 0x14, 0xc2, 0x65, 0xc6, 0xf2, 0x8b, 0xfe, 0x58, 0xc1,
-                0x1d, 0x4a, 0xc9, 0x6d, 0x49, 0x02, 0x96, 0x7b, 0x54, 0xbc, 0x5d, 0xd1, 0x5c, 0x14,
-                0x3f, 0xf4, 0x2b, 0xbb, 0x62, 0xb9, 0x34, 0xb0, 0x9e, 0x79, 0xb6, 0x1e, 0xaf, 0xe7,
-                0x9a, 0xbc, 0x86, 0x94, 0x47, 0x5b, 0x6c, 0x8e, 0x19, 0x94, 0xba, 0x05, 0x5e, 0xa3,
-                0xc1, 0x82, 0x93, 0xb0, 0x3c, 0x42, 0x49, 0x50, 0x1d, 0xfd, 0xc0, 0x14, 0x60, 0xcf,
-                0x78, 0xcd, 0x97, 0x51, 0x30, 0xae, 0x34, 0x05, 0xba, 0x7d, 0xdc, 0x71, 0x30, 0xcb,
-                0xdb, 0xb9, 0x8c, 0x7a, 0xaf, 0x6b, 0x1d, 0x0b, 0x44, 0xa5, 0x16, 0x79, 0xaa, 0x63,
-                0x0a, 0x43, 0xae, 0x23, 0xb3, 0xd2, 0x2f, 0x73, 0x4c, 0xe1, 0xdb, 0xed, 0xea, 0x17,
-                0x5a, 0x00, 0x62, 0xb0, 0x6e, 0x23, 0xf4, 0xd0, 0x6d, 0x2a, 0xd0, 0x45, 0xae, 0x98,
-                0x2d, 0xb4, 0x34, 0x8f, 0x20, 0xc8, 0x9b, 0xf9, 0x67, 0x0e, 0x2f, 0xda, 0x47, 0x2e,
-                0x55, 0xce, 0x4c, 0x35, 0x82, 0xb7, 0x64, 0x43, 0xe0, 0xab, 0xbb, 0x77, 0x8a, 0xec,
-                0xa0, 0xf3, 0x9c, 0x55, 0xb6, 0xab, 0xbe, 0xd8, 0x1f, 0xde, 0x89, 0xad, 0x2c, 0x56,
-                0x7d, 0xfe, 0x27, 0x7b, 0xb2, 0x69, 0xac, 0x6a, 0xe0, 0xe1, 0x88, 0x39, 0x8d, 0xea,
-                0x24, 0xad, 0xcc, 0xe1, 0x82, 0xe7, 0xfd, 0xdc, 0x80, 0xeb, 0xd7, 0x69, 0xd0, 0xf0,
-                0x76, 0xf9, 0xaf, 0x2d, 0xd9, 0x83, 0x07, 0xa5, 0x27, 0xc6, 0x99, 0x42, 0xdf, 0xa3,
-                0xe7, 0xf4, 0x86, 0x76, 0x10, 0x1a, 0x47, 0xeb, 0x07, 0x80, 0xb6, 0x90, 0xb1, 0xaf,
-                0x10, 0xfc, 0xfb, 0x5e, 0xe2, 0xbd, 0x40, 0xd2, 0x7d, 0x10, 0x9b, 0xa1, 0x5a, 0xb0,
-                0xb1, 0xe9, 0x55, 0x4f, 0xdd, 0xfa, 0x81, 0x6b, 0x99, 0xcd, 0x8f, 0xdd, 0xe6, 0x81,
-                0xae, 0x6b, 0x6c, 0xbb, 0xfb, 0xf0, 0x2c, 0x36, 0x32, 0x68, 0xd0, 0xf3, 0xc6, 0xa7,
-                0x26, 0x1b, 0x6d, 0x00, 0x87, 0xbc, 0xad, 0xb6, 0xfb, 0x9b, 0xf3, 0x93, 0x04, 0xfc,
-                0x08, 0x41, 0x5d, 0x83, 0x6f, 0xe4, 0x09, 0xa4, 0x3f, 0xaf, 0x9e, 0x28, 0xfb, 0x48,
-                0x3f, 0x4a, 0x47, 0xaa, 0xd7, 0xe1, 0xf7, 0x97, 0x30, 0xb3, 0x21, 0x53, 0x60, 0x80,
-                0xdb, 0x35, 0x12, 0x48, 0xb2, 0x66, 0x9b, 0x6e, 0x74, 0x48, 0x90, 0x87, 0xae, 0x72,
-                0xba, 0x15, 0xd2, 0xae, 0xdd, 0x0c, 0x1e, 0x7e, 0xb1, 0x5a, 0x2f, 0x5a, 0x77, 0x31,
-                0xeb, 0x45, 0xa6, 0x17, 0x8a, 0x44, 0x87, 0x09, 0x31, 0xec, 0x8e, 0x34, 0x8c, 0x19,
-                0x2b, 0xc8, 0x87, 0xc8, 0x63, 0x60, 0x56, 0x67, 0x6f, 0x58, 0xd0, 0xc6, 0x34, 0xfc,
-                0x99, 0xea, 0x7b, 0x07, 0xfa, 0x1b, 0x62, 0x99, 0xae, 0x5d, 0xbf, 0xe0, 0x84, 0x45,
-                0xad, 0x99, 0x9f, 0x45, 0xdf, 0x00, 0xf1, 0xa4, 0x7a, 0xa5, 0xef, 0x6f, 0x88, 0xcd,
-                0xba, 0x80, 0xc8, 0x8f, 0x94, 0x01, 0xe6, 0xe9, 0x09, 0xca, 0x2c, 0x5d, 0xe2, 0xcf,
-                0x8f, 0x6a, 0x98, 0x44, 0xca, 0x32, 0xfe, 0x91, 0xf7, 0x13, 0xfe, 0x10, 0xa0, 0x69,
-                0x8a, 0x1b, 0x3b, 0xfd, 0xf4, 0x47, 0x43, 0x75, 0xb4, 0x79, 0x1d, 0xc8, 0x50, 0x50,
-                0xc9, 0x28, 0x90, 0x0e, 0x73, 0x1f, 0x7c, 0x4a, 0x12, 0x9d, 0x8e, 0x21, 0xfc, 0xf4,
-                0x17, 0x62, 0x7c, 0x47, 0xdd, 0xc9, 0xf5, 0x88, 0x40, 0x38, 0x41, 0x31, 0x7a, 0x9a,
-                0xc2, 0x6e, 0xef, 0x6c, 0xda, 0x23,
+                0x2d, 0x40, 0x4a, 0x68, 0x81, 0xa6, 0xee, 0x76, 0x0c, 0xb5, 0x3b, 0x9c, 0xc2, 0x71,
+                0x5c, 0xa7, 0x6a, 0x3a, 0x2f, 0xc9, 0x69, 0x3b, 0x1a, 0xbb, 0xcd, 0xc7, 0x5c, 0xb6,
+                0xd6, 0xc3, 0x6e, 0xcf, 0x84, 0xd6, 0x93, 0x67, 0x2c, 0x53, 0xce, 0xd8, 0x79, 0x8c,
+                0xc8, 0xf1, 0xe5, 0x3b, 0x8a, 0x9d, 0xe7, 0xbb, 0xb5, 0xe8, 0xc5, 0xa4, 0x6c, 0x3a,
+                0x74, 0x12, 0xdf, 0x11, 0xc5, 0xda, 0x16, 0xb4, 0xdd, 0x22, 0x90, 0x1a, 0x59, 0x2b,
+                0x0e, 0x93, 0x29, 0x77, 0xba, 0x06, 0x67, 0x3d, 0x6f, 0xd0, 0x38, 0xac, 0xba, 0xa9,
+                0xbf, 0x79, 0xc1, 0x5b, 0xa6, 0x2b, 0x6e, 0x30, 0x74, 0xef, 0x95, 0x3b, 0x81, 0x4c,
+                0xf1, 0xbd, 0xf0, 0x15, 0x77, 0xed, 0x3e, 0x3f, 0xae, 0xf4, 0x71, 0x55, 0xc9, 0x1c,
+                0x68, 0xee, 0x32, 0x88, 0x1b, 0x73, 0x74, 0x94, 0xb3, 0xb4, 0x76, 0x08, 0x3b, 0x3b,
+                0xd1, 0x77, 0x93, 0xc4, 0x98, 0x93, 0x1e, 0xaa, 0x92, 0xb1, 0x7c, 0x7d, 0x10, 0x47,
+                0x58, 0xfc, 0x8b, 0x34, 0x93, 0xd2, 0x47, 0x41, 0x7f, 0x5e, 0xc1, 0x97, 0x9a, 0x35,
+                0x28, 0x93, 0xe9, 0x95, 0x63, 0xb6, 0xc3, 0xab, 0x95, 0xcc, 0x5a, 0xfa, 0x37, 0x32,
+                0xef, 0xae, 0xce, 0x9e, 0x74, 0x32, 0xc8, 0x04, 0x15, 0xe2, 0x5f, 0x55, 0x56, 0x53,
+                0xc7, 0xda, 0x5d, 0xb0, 0xcc, 0x61, 0x08, 0x74, 0x21, 0x95, 0x9b, 0xb1, 0xdf, 0x80,
+                0x03, 0xb7, 0x3d, 0xa0, 0xbe, 0xf0, 0x60, 0xf3, 0xa8, 0x4c, 0x8b, 0xc2, 0x4c, 0xc7,
+                0x6d, 0x0d, 0x9e, 0x9c, 0x33, 0x76, 0x5c, 0x20, 0xf0, 0x7d, 0x80, 0xe2, 0x0f, 0xdf,
+                0x27, 0x81, 0x5d, 0xbd, 0x9d, 0x71, 0x7c, 0x09, 0x66, 0xf8, 0x0b, 0x94, 0xb9, 0x59,
+                0x15, 0x08, 0x1e, 0xa4, 0x55, 0x37, 0xa5, 0xa0, 0x74, 0xb9, 0xc9, 0x4b, 0x43, 0xdd,
+                0xf4, 0xa9, 0xcb, 0xad, 0xe9, 0x04, 0x51, 0x0e, 0xaa, 0x96, 0x9e, 0x66, 0x6c, 0x94,
+                0x34, 0xb9, 0xf6, 0x3e, 0xae, 0x62, 0xad, 0x58, 0x27, 0x99, 0x62, 0xe9, 0x41, 0x33,
+                0x05, 0x5c, 0xbc, 0xc4, 0xb1, 0x55, 0xc0, 0x0f, 0x1b, 0x83, 0xff, 0x41, 0x28, 0xa8,
+                0xab, 0xb4, 0xce, 0x68, 0xe9, 0xf1, 0xe3, 0x08, 0xe6, 0xf9, 0x7e, 0x51, 0x3a, 0xf5,
+                0x95, 0x47, 0x1a, 0x16, 0x77, 0xef, 0x78, 0xe9, 0x77, 0x0f, 0x43, 0xad, 0xde, 0x1a,
+                0x64, 0x58, 0x6d, 0xe6, 0xa5, 0x87, 0xc3, 0xd6, 0x93, 0xfe, 0xa8, 0xfc, 0xc6, 0xac,
+                0xc8, 0x94, 0x96, 0x1e, 0x2f, 0x47, 0xb2, 0x02, 0xe8, 0x6a, 0x57, 0x38, 0x79, 0xb5,
+                0xbf, 0xd7, 0x29, 0xda, 0x2f, 0xbe, 0xfc, 0x64, 0x5c, 0xfa, 0xb1, 0x88, 0x0d, 0x51,
+                0x76, 0x40, 0xdf, 0x5f, 0x53, 0xe5, 0x7c, 0x72, 0xd6, 0x5a, 0x63, 0x3a, 0xa5, 0x36,
+                0xb2, 0x98, 0x34, 0xbf, 0x28, 0x16, 0xb1, 0xf7, 0x16, 0xbf, 0x43, 0x6d, 0x6b, 0x2b,
+                0x6e, 0x47, 0x73, 0x28, 0xc9, 0x58, 0xa6, 0xb8, 0xcf, 0x73, 0xb9, 0x5d, 0x22, 0xf6,
+                0x99, 0x3b, 0x3f, 0xc5, 0x25, 0xdb, 0x62, 0x7f, 0x6f, 0x38, 0xd0, 0x77, 0x9a, 0x1d,
+                0x39, 0xaf, 0x05, 0xed, 0x74, 0xfd, 0xfe, 0xff, 0x98, 0x7a, 0x95, 0x88, 0xd8, 0x0b,
+                0x7e, 0x79, 0x69, 0x4a, 0xe4, 0x55, 0x29, 0x29, 0x88, 0x1c, 0x5b, 0xfe, 0x20, 0x49,
+                0x2f, 0xd6, 0xf3, 0x37, 0xca, 0x88, 0xdf, 0xb5, 0x01, 0xe5, 0x45, 0xd2, 0x36, 0x73,
+                0xac, 0xac, 0xbc, 0x3d, 0x33, 0x14, 0xa8, 0xbb, 0xf5, 0xec, 0x70, 0xb7, 0x05, 0xcc,
+                0x9d, 0x26, 0x57, 0xbd, 0xd5, 0xa7, 0x09, 0x15, 0xbe, 0xf6, 0xd0, 0xf0, 0x39, 0xd3,
+                0xeb, 0xa6, 0xbb, 0x71, 0x5b, 0xe5, 0x1e, 0xbf, 0x6e, 0xf6, 0x59, 0xea, 0x32, 0xff,
+                0x80, 0xc8, 0x2c, 0x04, 0x21, 0x67, 0x5f, 0xe3, 0x71, 0xef, 0x49, 0xf1, 0xb9, 0xe3,
+                0x8f, 0x43, 0x7b, 0x4a, 0x76, 0x55, 0xdc, 0x29, 0x16, 0xaa, 0x30, 0x86, 0xde, 0x6c,
+                0x62, 0xa8, 0x2b, 0x36, 0x1c, 0x05, 0x3f, 0xc6, 0x34, 0x54, 0xcc, 0xd0, 0x2c, 0x22,
+                0xd4, 0x1f, 0xf5, 0xbb, 0x83, 0x62, 0xde, 0xaa, 0x70, 0x82, 0x5a, 0xd2, 0xf9, 0x93,
+                0x63, 0x9f, 0xc4, 0x46, 0x06, 0x9d, 0x78, 0xa6, 0x1d, 0x33, 0x8d, 0xf5, 0x8f, 0x77,
+                0x63, 0xe3, 0x55, 0xe6, 0xa9, 0xff,
             ],
             ock: [
-                0x9c, 0x10, 0x3d, 0xd5, 0xd6, 0x38, 0x6c, 0xdd, 0x67, 0x69, 0x51, 0xe6, 0x56, 0x4b,
-                0x16, 0x6b, 0xc5, 0xc5, 0x72, 0x32, 0xcf, 0xc3, 0x1e, 0x0e, 0x69, 0xce, 0x84, 0xda,
-                0xe8, 0x32, 0x76, 0xbe,
+                0x8b, 0x0d, 0x29, 0x8e, 0xe8, 0xb4, 0x25, 0x34, 0xa4, 0x2f, 0xb9, 0x63, 0x5b, 0xa7,
+                0x58, 0xea, 0x9f, 0x91, 0x8b, 0x83, 0x16, 0xc0, 0xe8, 0x94, 0xa9, 0x08, 0x48, 0x89,
+                0x01, 0xd9, 0xfb, 0xa3,
             ],
             op: [
                 0x8e, 0x66, 0xb7, 0x92, 0xec, 0xb1, 0x56, 0xef, 0x68, 0x5e, 0xe8, 0xea, 0x35, 0xd3,
                 0x82, 0x75, 0x8b, 0xa4, 0x15, 0x97, 0xa3, 0x3a, 0x93, 0xba, 0xf3, 0x81, 0xd6, 0x3c,
-                0x17, 0x5b, 0xa9, 0x8b, 0x01, 0xa3, 0x66, 0x1e, 0xa9, 0xaa, 0xb8, 0xf4, 0x32, 0x53,
-                0x42, 0x0e, 0xff, 0xd7, 0xa4, 0x83, 0xc2, 0x79, 0xd4, 0x18, 0x18, 0xbc, 0xb3, 0xee,
-                0x91, 0x90, 0x01, 0xf8, 0x66, 0xa8, 0xe9, 0x2c,
+                0x17, 0x5b, 0xa9, 0x8b, 0xf9, 0xf7, 0xa0, 0x10, 0x5e, 0xa9, 0xf4, 0x45, 0xfb, 0x7a,
+                0x14, 0x49, 0x72, 0x62, 0xc6, 0xe4, 0xd7, 0x32, 0x89, 0x32, 0x7b, 0x8a, 0x2d, 0xf5,
+                0xe2, 0x63, 0xf3, 0xe3, 0x99, 0x07, 0xea, 0x0c,
             ],
             c_out: [
-                0xdf, 0x6b, 0xb6, 0x2e, 0x3b, 0x64, 0xf7, 0xe9, 0x37, 0xc1, 0xde, 0x38, 0xaa, 0xc5,
-                0xe6, 0xb1, 0x61, 0x35, 0xba, 0x2f, 0x9d, 0xbe, 0xed, 0xb0, 0x7a, 0x45, 0xb6, 0xf0,
-                0x9d, 0xf3, 0xeb, 0xec, 0xac, 0x04, 0x6c, 0x61, 0x92, 0xfb, 0xe8, 0x95, 0xd2, 0x31,
-                0x02, 0x77, 0xb3, 0xe0, 0x3a, 0x90, 0xfd, 0xc8, 0x53, 0x48, 0x4a, 0x01, 0x5c, 0x88,
-                0xd6, 0x63, 0x2e, 0x97, 0xba, 0x98, 0xad, 0xca, 0x9e, 0x49, 0xf5, 0x38, 0xc3, 0xa7,
-                0xcb, 0x6d, 0x77, 0x23, 0xbd, 0xcc, 0x9c, 0x03, 0xae, 0x88,
-            ],
+                0xf3, 0xbf, 0x90, 0x76, 0xf3, 0xdb, 0x66, 0x32, 0x6d, 0xa6, 0x0c, 0xc7, 0x94, 0x3c,
+                0x85, 0x4d, 0x8d, 0xe9, 0x9f, 0x57, 0x53, 0xf7, 0x0c, 0x32, 0xed, 0x01, 0xfb, 0x2e,
+                0x84, 0x9c, 0x9d, 0xc7, 0x3f, 0x80, 0xb5, 0xcb, 0xaa, 0xb4, 0x99, 0x2d, 0xd7, 0xe7,
+                0x38, 0xb9, 0x61, 0xfd, 0x75, 0x3f, 0x7c, 0x5b, 0x29, 0x24, 0xd1, 0xd9, 0x63, 0x06,
+                0x61, 0x33, 0x92, 0x59, 0x28, 0x3e, 0x3a, 0x95, 0x3c, 0x57, 0xdf, 0x3a, 0x48, 0xca,
+                0x82, 0x71, 0xfc, 0x5f, 0x26, 0x4d, 0x6f, 0x15, 0xb6, 0xb3,
+            ],
+            note_type: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1769,34 +1777,34 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x87, 0xe5, 0x05, 0xad,
             ],
             rho: [
-                0x32, 0x91, 0x87, 0x35, 0x66, 0x3f, 0x34, 0xad, 0xa0, 0x22, 0x8a, 0xea, 0x4a, 0xcc,
-                0x19, 0x2a, 0x12, 0x3f, 0xcf, 0xa0, 0x60, 0x46, 0x89, 0xf9, 0x1a, 0xcb, 0xe9, 0x38,
-                0x31, 0xe4, 0x8c, 0x0c,
+                0xc2, 0x79, 0xfa, 0x9d, 0x1c, 0x84, 0x11, 0x93, 0xd3, 0x32, 0xf8, 0xcc, 0xf4, 0xd0,
+                0xb1, 0xe4, 0x56, 0x01, 0xa8, 0xaf, 0x66, 0x76, 0xd7, 0x62, 0xfb, 0xa7, 0x31, 0x33,
+                0x45, 0x89, 0x35, 0x14,
             ],
             cmx: [
-                0xde, 0x7b, 0xf1, 0x55, 0x08, 0x29, 0x51, 0x96, 0x0a, 0x10, 0xbb, 0x8b, 0x75, 0x41,
-                0x02, 0x43, 0x0f, 0x89, 0xf5, 0x32, 0x67, 0x24, 0x04, 0x36, 0x81, 0xf5, 0x06, 0xf7,
-                0x48, 0xe2, 0x6f, 0x07,
+                0x6d, 0x29, 0x97, 0xd1, 0xce, 0x0a, 0x94, 0x9a, 0x63, 0x70, 0x0f, 0x46, 0x1b, 0x57,
+                0x12, 0xae, 0xeb, 0x43, 0xd4, 0x55, 0x04, 0xe3, 0x5b, 0xda, 0x16, 0x52, 0x97, 0x77,
+                0xc7, 0x4d, 0x19, 0x1b,
             ],
             esk: [
-                0x1d, 0xb6, 0x79, 0x07, 0x9a, 0xcd, 0xef, 0xe9, 0xfc, 0x1e, 0x59, 0xa1, 0x33, 0xf3,
-                0x7b, 0x6d, 0x1f, 0xfb, 0xed, 0x78, 0x8c, 0xce, 0x3b, 0x0c, 0xdd, 0x63, 0xe0, 0x62,
-                0x83, 0x05, 0x47, 0x08,
+                0x9d, 0xc4, 0xc8, 0xc0, 0x32, 0xd3, 0xbe, 0x66, 0xd2, 0x63, 0x6b, 0xa0, 0x02, 0x0c,
+                0x63, 0xf4, 0x26, 0x53, 0x29, 0xff, 0xac, 0x2a, 0xe6, 0x35, 0x57, 0x32, 0x63, 0xf4,
+                0x99, 0xbd, 0x4c, 0x13,
             ],
             ephemeral_key: [
-                0x18, 0x20, 0x84, 0x5b, 0x2d, 0x90, 0xe5, 0x45, 0x76, 0x0f, 0xca, 0x4d, 0xab, 0x30,
-                0xa6, 0x78, 0x3e, 0x03, 0x1c, 0x0e, 0x54, 0x28, 0xcc, 0x22, 0x6f, 0x3f, 0x40, 0x1d,
-                0xec, 0x20, 0x0b, 0x11,
+                0xe4, 0x76, 0x95, 0x86, 0x30, 0x4a, 0x6a, 0x9b, 0x3a, 0x2a, 0xef, 0x3a, 0xf5, 0x8b,
+                0x97, 0xda, 0xc2, 0xcc, 0x4a, 0xeb, 0x38, 0x9f, 0x68, 0xc1, 0x28, 0x87, 0x73, 0x1e,
+                0x0e, 0x12, 0xbc, 0x1e,
             ],
             shared_secret: [
-                0x79, 0x38, 0x77, 0xa1, 0xae, 0xda, 0xe9, 0xac, 0x6d, 0xa3, 0xd7, 0xe8, 0x02, 0xb5,
-                0xbc, 0x77, 0x3c, 0x0d, 0x93, 0x1c, 0x79, 0x6d, 0x17, 0x0c, 0x59, 0x7f, 0x22, 0xba,
-                0x6f, 0xcc, 0xa2, 0x06,
+                0xf6, 0xba, 0x4b, 0x1f, 0xbe, 0x01, 0xfa, 0x2f, 0x1d, 0xd4, 0x09, 0x3c, 0x5c, 0xc4,
+                0x85, 0xa9, 0xbf, 0xd9, 0xef, 0x0f, 0x57, 0x89, 0x49, 0xd6, 0xe1, 0x00, 0xb0, 0x05,
+                0x5c, 0xb8, 0xf3, 0x31,
             ],
             k_enc: [
-                0x28, 0x20, 0xb9, 0x38, 0xd6, 0xfc, 0xea, 0x99, 0xa7, 0x23, 0x37, 0x50, 0xa0, 0xf0,
-                0x9a, 0x32, 0x10, 0xad, 0x91, 0x73, 0x46, 0x16, 0x6a, 0xea, 0xdc, 0x89, 0xbb, 0x50,
-                0xf4, 0x54, 0x50, 0xa3,
+                0xd3, 0xc2, 0x20, 0x51, 0x00, 0x3e, 0x88, 0x2a, 0x5d, 0xdd, 0xfb, 0x48, 0x23, 0xd6,
+                0x77, 0x26, 0x96, 0xa7, 0xe9, 0x9f, 0x26, 0xb1, 0xa6, 0xac, 0xd2, 0x4b, 0xee, 0xd5,
+                0xf2, 0x2f, 0x9f, 0xf8,
             ],
             p_enc: [
                 0x02, 0x81, 0xf2, 0x75, 0x7c, 0x53, 0x2e, 0xd3, 0xb6, 0x2e, 0x89, 0x01, 0x22, 0x92,
@@ -1842,69 +1850,70 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x3e, 0xcc, 0xc6, 0x23,
             ],
             c_enc: [
-                0xd9, 0x6a, 0xe8, 0x2f, 0xba, 0xff, 0xb9, 0xe4, 0xbd, 0x36, 0x47, 0x57, 0x96, 0x33,
-                0xbc, 0x8a, 0x89, 0x66, 0xae, 0x4e, 0x18, 0x85, 0x99, 0xdc, 0x3c, 0xf0, 0x30, 0x41,
-                0xd2, 0x64, 0x4f, 0x60, 0x3c, 0xe5, 0x56, 0x2e, 0x7f, 0xa1, 0xd3, 0x83, 0x12, 0x79,
-                0xb6, 0x32, 0x60, 0x4d, 0x06, 0x5e, 0xd2, 0x46, 0xad, 0x2d, 0x4f, 0x73, 0xf3, 0xa4,
-                0x1b, 0x2a, 0x27, 0x99, 0xe5, 0xba, 0xf8, 0x6e, 0x7d, 0x9f, 0xcc, 0x64, 0xd5, 0x6b,
-                0xde, 0x56, 0xcb, 0xb0, 0x01, 0xeb, 0x7c, 0x7c, 0x0c, 0xf1, 0xe2, 0xae, 0xc3, 0xce,
-                0xb1, 0x49, 0x2d, 0xdf, 0x4e, 0x35, 0x20, 0x76, 0x1f, 0x70, 0xf6, 0xa9, 0x5c, 0x9e,
-                0xde, 0xed, 0x51, 0x43, 0x6d, 0xca, 0xcf, 0x71, 0x1e, 0xb5, 0x53, 0x24, 0xd3, 0xf0,
-                0x1d, 0xcc, 0xa0, 0x1b, 0xca, 0x15, 0xba, 0xf2, 0x8f, 0xed, 0x81, 0x4c, 0xc3, 0x3a,
-                0x43, 0x6b, 0xbc, 0x08, 0x60, 0x56, 0x78, 0x55, 0xa4, 0x9f, 0x5e, 0xfd, 0x49, 0xea,
-                0x78, 0x30, 0xc2, 0xf6, 0x00, 0x61, 0xd8, 0x13, 0xa8, 0x49, 0xb4, 0x40, 0xb1, 0x2e,
-                0x8f, 0x31, 0xe2, 0xdc, 0x0c, 0x39, 0x4c, 0xeb, 0x92, 0x4f, 0x0d, 0xc6, 0xd5, 0x7b,
-                0xcc, 0x39, 0x1d, 0x4a, 0x5f, 0x56, 0x9f, 0x34, 0x74, 0x6b, 0x9d, 0x92, 0x08, 0x82,
-                0x25, 0xb1, 0xaa, 0x3e, 0x90, 0x6f, 0x6d, 0xe4, 0xa7, 0x92, 0x2a, 0xc1, 0x16, 0xac,
-                0xb2, 0x78, 0xe8, 0xef, 0xbb, 0xf6, 0xf1, 0xe3, 0xe0, 0x8d, 0x66, 0xb3, 0x4d, 0x6e,
-                0xde, 0x34, 0xae, 0x78, 0x40, 0xa8, 0x80, 0x2b, 0x7c, 0x10, 0x0f, 0xa7, 0x98, 0x46,
-                0x4d, 0xb5, 0x29, 0x45, 0xdb, 0xbe, 0x35, 0xe7, 0x7a, 0x77, 0x21, 0xb2, 0xe0, 0xf8,
-                0xb9, 0xa1, 0x0f, 0x6b, 0xf9, 0xa2, 0x80, 0x8f, 0xa5, 0x85, 0xff, 0x21, 0xb0, 0xa3,
-                0xaf, 0xfd, 0x5f, 0x3c, 0xb2, 0x30, 0x63, 0x4e, 0x2e, 0x43, 0xff, 0xde, 0x6d, 0x09,
-                0x0a, 0xfc, 0xc6, 0x70, 0x4d, 0x7b, 0x3f, 0xc6, 0x15, 0x44, 0x85, 0x3b, 0xcd, 0xa7,
-                0xa1, 0x06, 0xd8, 0x5b, 0xd8, 0xd8, 0x6c, 0x6f, 0x8c, 0xe0, 0x34, 0x01, 0x6e, 0xd9,
-                0xa3, 0x69, 0x46, 0xf8, 0x52, 0x8b, 0x6f, 0x1e, 0x1a, 0x19, 0x82, 0xd6, 0x8d, 0x38,
-                0x86, 0xe5, 0xea, 0xe6, 0xc1, 0xe3, 0x88, 0xf3, 0xde, 0xad, 0x0d, 0x35, 0x3b, 0x6c,
-                0x0c, 0xbf, 0x57, 0xc2, 0xe4, 0x7d, 0x30, 0x72, 0x3e, 0xac, 0x95, 0x7b, 0x4a, 0xec,
-                0x82, 0xc8, 0xa1, 0x00, 0x9e, 0x3d, 0x71, 0x96, 0x92, 0xb2, 0xfc, 0xbd, 0xda, 0xae,
-                0x62, 0x5a, 0x89, 0x6a, 0x47, 0x29, 0x85, 0xb7, 0x9e, 0xb6, 0x2b, 0x1f, 0xe3, 0x3d,
-                0x6e, 0x27, 0xbc, 0x1f, 0x10, 0xe4, 0xfe, 0x5c, 0x06, 0xb2, 0x4c, 0x59, 0x7f, 0x72,
-                0x3c, 0x67, 0x13, 0x36, 0x13, 0xae, 0x8e, 0x15, 0x4d, 0x81, 0x69, 0x78, 0xb8, 0xfc,
-                0xa6, 0x50, 0xc0, 0x1d, 0x77, 0x1a, 0x62, 0x69, 0x2a, 0x84, 0x82, 0x94, 0x2e, 0x28,
-                0xfe, 0xf0, 0x45, 0x19, 0x9e, 0xd1, 0xa6, 0x64, 0x99, 0xeb, 0xa1, 0xee, 0xc1, 0x9a,
-                0xc8, 0x4a, 0x12, 0xe4, 0x10, 0x29, 0xd2, 0x2f, 0x21, 0x87, 0x6e, 0xd7, 0x4a, 0x76,
-                0xef, 0x39, 0xa0, 0x57, 0xce, 0x0a, 0x15, 0x8e, 0x68, 0x51, 0xec, 0x35, 0x6d, 0x97,
-                0x7b, 0x1a, 0xa6, 0x8d, 0xcf, 0x70, 0x88, 0xa9, 0xf0, 0xf9, 0xe4, 0x75, 0xa2, 0xbb,
-                0xc1, 0xc4, 0x49, 0x5b, 0x54, 0x6f, 0xff, 0xed, 0xaa, 0x66, 0xc4, 0xf9, 0x51, 0x74,
-                0xc6, 0x2f, 0x56, 0x5a, 0x3c, 0xc0, 0xac, 0xaf, 0x85, 0x4a, 0xde, 0xd4, 0xb4, 0x25,
-                0xa0, 0xc7, 0xdb, 0xcd, 0x37, 0x42, 0xa7, 0xe0, 0x59, 0x2e, 0x83, 0x73, 0x41, 0xf8,
-                0x95, 0x32, 0x90, 0x99, 0xe1, 0x70, 0xb6, 0xff, 0xb1, 0x05, 0xfd, 0xbc, 0x77, 0x29,
-                0x8e, 0x8c, 0x0f, 0x5e, 0xeb, 0x9e, 0x99, 0xc6, 0x58, 0x4b, 0xcf, 0xf1, 0x20, 0x20,
-                0x9d, 0x69, 0x22, 0xb5, 0x34, 0xbe, 0xc9, 0xfa, 0xc1, 0xd7, 0xd2, 0x74, 0xdb, 0xcb,
-                0x4a, 0x12, 0xea, 0x5a, 0x99, 0x21, 0x39, 0x2f, 0x00, 0x96, 0x60, 0x29, 0xff, 0x26,
-                0x0e, 0xd2, 0x4c, 0x32, 0x78, 0x58, 0xe0, 0x34, 0x64, 0x0a, 0x8c, 0xfb, 0x28, 0xad,
-                0x97, 0xe5, 0x3d, 0x80, 0xe1, 0xc9,
+                0x72, 0x29, 0xa0, 0xa5, 0x6a, 0x14, 0x4b, 0x04, 0x2c, 0x1e, 0xad, 0x91, 0x80, 0xac,
+                0x54, 0xda, 0xc6, 0xc5, 0x5c, 0xf4, 0xc2, 0x2f, 0xbe, 0x7c, 0xde, 0x99, 0x96, 0x0b,
+                0xc6, 0x20, 0xd4, 0xdd, 0x60, 0xe4, 0xbf, 0x18, 0xa0, 0xea, 0x7a, 0xd9, 0x09, 0x3b,
+                0xcd, 0x3f, 0xf6, 0xd1, 0x61, 0x1c, 0x56, 0x5f, 0x88, 0xe7, 0x35, 0xef, 0x4c, 0x51,
+                0x8c, 0x77, 0xd6, 0x22, 0x28, 0xe1, 0xe4, 0xa1, 0x35, 0xca, 0x6c, 0xb4, 0xed, 0x5a,
+                0xbb, 0xdf, 0x3e, 0x81, 0xd0, 0x96, 0x50, 0xa8, 0xfa, 0x9b, 0x5c, 0x3d, 0x05, 0xb6,
+                0xda, 0xcf, 0x3c, 0x3d, 0xb3, 0xb3, 0x63, 0xe4, 0x10, 0x57, 0x23, 0x70, 0x0c, 0x69,
+                0x13, 0x9f, 0x81, 0xec, 0xc4, 0x8d, 0x88, 0x3d, 0xa0, 0x39, 0xdd, 0xed, 0x5e, 0xf6,
+                0x04, 0x0a, 0xb2, 0x12, 0x0e, 0x53, 0x3b, 0x1f, 0xfd, 0x06, 0x74, 0xdb, 0x5b, 0x92,
+                0x6e, 0x58, 0x7f, 0x16, 0xe7, 0xe8, 0x96, 0x2b, 0x12, 0x48, 0x35, 0xbd, 0x56, 0xcf,
+                0xd8, 0xe7, 0x5b, 0xf6, 0xaa, 0x4d, 0xcd, 0x4d, 0x6f, 0x0b, 0x55, 0x61, 0x71, 0x9c,
+                0x80, 0xaa, 0x82, 0xb3, 0xbc, 0xea, 0x16, 0x7a, 0x31, 0xc6, 0x69, 0x87, 0x61, 0xe2,
+                0xd2, 0x6c, 0xb5, 0x6d, 0xd3, 0x04, 0x16, 0x72, 0x1c, 0x93, 0x37, 0x32, 0x92, 0x85,
+                0x33, 0x58, 0xfa, 0xfe, 0x74, 0x95, 0x55, 0x8d, 0xb9, 0x9e, 0x47, 0xa3, 0xa1, 0x6e,
+                0xd2, 0x2c, 0xdb, 0x9d, 0x7d, 0x16, 0xcf, 0xd9, 0xa7, 0xbb, 0x55, 0x9c, 0x72, 0x86,
+                0xed, 0x84, 0xf8, 0x89, 0x9c, 0xb0, 0x52, 0x2e, 0x8a, 0x49, 0x7f, 0x3e, 0x14, 0x45,
+                0x2b, 0xa8, 0xa9, 0x4a, 0x7f, 0x58, 0xe5, 0xde, 0x37, 0x1d, 0x76, 0xec, 0xc9, 0xef,
+                0xe2, 0x0a, 0xe7, 0x9b, 0xee, 0x12, 0xbc, 0xe4, 0xe4, 0xb6, 0xf2, 0x35, 0x35, 0xe5,
+                0xc3, 0xc4, 0x3a, 0x4c, 0xa2, 0x07, 0x6f, 0xd6, 0x73, 0xf0, 0x80, 0x6f, 0xa9, 0x85,
+                0xc5, 0x88, 0xd1, 0x14, 0xc0, 0x7d, 0x8c, 0xe3, 0xa2, 0x33, 0xe5, 0x4d, 0x77, 0x11,
+                0x6c, 0x8a, 0x2a, 0x56, 0xa6, 0x82, 0xe7, 0xa4, 0x85, 0xdf, 0x71, 0xb3, 0x02, 0xa0,
+                0x36, 0xdd, 0xab, 0x21, 0x4d, 0xee, 0x77, 0x62, 0x19, 0xcc, 0x24, 0x25, 0x94, 0xf7,
+                0x5b, 0x8e, 0xbd, 0x56, 0x6d, 0x74, 0xb1, 0x6c, 0x9e, 0xc0, 0x05, 0x8b, 0xca, 0x28,
+                0x81, 0xb7, 0x9b, 0x10, 0xe8, 0xa8, 0x01, 0x08, 0x20, 0x61, 0x8a, 0xc6, 0x52, 0x6c,
+                0xf9, 0x4b, 0x13, 0xd9, 0x75, 0x9f, 0x37, 0x33, 0x93, 0x34, 0xe8, 0xb2, 0xc6, 0xbd,
+                0xd1, 0xd0, 0xf5, 0xe2, 0x46, 0x3c, 0xff, 0x2b, 0x8d, 0xa6, 0xd2, 0xc6, 0x86, 0xaa,
+                0x98, 0x7c, 0xd1, 0xf0, 0x7e, 0x9a, 0xa2, 0x60, 0xdd, 0x04, 0x28, 0xa4, 0xff, 0x78,
+                0xaa, 0x8f, 0xda, 0x47, 0x7a, 0xb3, 0x8a, 0xcf, 0xcc, 0xb1, 0x90, 0x91, 0x77, 0xb5,
+                0x27, 0xe9, 0x38, 0xf1, 0xf9, 0xdc, 0xf3, 0x1f, 0x4f, 0x40, 0xa9, 0x62, 0x89, 0x51,
+                0xfc, 0x2a, 0x7a, 0xbc, 0x04, 0x1e, 0x8c, 0x93, 0x36, 0x08, 0xbb, 0x47, 0xb4, 0x50,
+                0xb2, 0x8f, 0xee, 0xe0, 0x41, 0x58, 0xa8, 0x17, 0x4b, 0xff, 0xe4, 0x97, 0x06, 0x02,
+                0x48, 0x86, 0x42, 0xc1, 0x9e, 0x61, 0xd4, 0x73, 0xf3, 0xde, 0x0c, 0xb0, 0xb6, 0x4a,
+                0x30, 0xd6, 0xf1, 0x46, 0x68, 0xd1, 0xb0, 0x17, 0x77, 0x56, 0x6f, 0xb5, 0xac, 0xc2,
+                0xe9, 0x2e, 0x64, 0xd9, 0x75, 0x7f, 0xba, 0x13, 0xc1, 0xee, 0x9c, 0xd0, 0x3a, 0xbe,
+                0x98, 0xbd, 0x7e, 0x8a, 0xd7, 0x04, 0x1c, 0x3f, 0xea, 0xe7, 0xc1, 0xa7, 0x24, 0x3a,
+                0xe3, 0x61, 0x0a, 0xac, 0x64, 0xfe, 0xc6, 0xc9, 0xfc, 0x94, 0x3d, 0x6a, 0xbc, 0xe9,
+                0x10, 0xad, 0xbe, 0x23, 0xb5, 0x46, 0xb4, 0xc2, 0x4a, 0xa9, 0xf2, 0xce, 0x5d, 0x97,
+                0x06, 0x2e, 0xe0, 0xd1, 0xcc, 0xc4, 0x8c, 0xfd, 0x1f, 0xdb, 0xa7, 0xfd, 0xac, 0x0b,
+                0x04, 0xd1, 0xb3, 0xdc, 0x7a, 0x70, 0x78, 0x1c, 0xdd, 0xa2, 0xa2, 0x70, 0x3d, 0xe0,
+                0x03, 0xcd, 0x01, 0x51, 0xec, 0x65, 0xbf, 0x7d, 0x1a, 0xc6, 0x3b, 0xb7, 0x35, 0xbc,
+                0x2b, 0xb6, 0x7a, 0xd2, 0xb0, 0x1e, 0xd6, 0xb9, 0xae, 0x2e, 0xbb, 0xd3, 0x7a, 0x8f,
+                0x8e, 0xc1, 0xa6, 0x53, 0xa8, 0x7e,
             ],
             ock: [
-                0x28, 0xcf, 0x3b, 0xea, 0xc3, 0xbd, 0xe2, 0xe9, 0x63, 0xaa, 0x60, 0x91, 0x3f, 0x10,
-                0x5d, 0x25, 0x67, 0xcd, 0xaf, 0xbb, 0x66, 0x09, 0x08, 0x5a, 0x84, 0x3f, 0x75, 0x68,
-                0xe4, 0x92, 0xd4, 0x4e,
+                0x1b, 0xa4, 0xac, 0xd7, 0x75, 0x10, 0xc4, 0xf0, 0xc7, 0x66, 0xad, 0xf7, 0xc7, 0xdf,
+                0x1d, 0x1c, 0x54, 0xd5, 0xbc, 0xe3, 0xd6, 0x0a, 0xf3, 0x5e, 0x8d, 0xd4, 0x8f, 0xdd,
+                0x04, 0xa7, 0x8c, 0x0b,
             ],
             op: [
                 0x55, 0xdb, 0x72, 0x90, 0x07, 0x3b, 0xa0, 0x06, 0x66, 0xe8, 0x7d, 0x25, 0x61, 0xb8,
                 0x88, 0x3c, 0x66, 0x2c, 0x56, 0x78, 0xff, 0x27, 0x30, 0x2a, 0x82, 0xe2, 0x0a, 0x72,
-                0x01, 0x70, 0x89, 0x1a, 0x1d, 0xb6, 0x79, 0x07, 0x9a, 0xcd, 0xef, 0xe9, 0xfc, 0x1e,
-                0x59, 0xa1, 0x33, 0xf3, 0x7b, 0x6d, 0x1f, 0xfb, 0xed, 0x78, 0x8c, 0xce, 0x3b, 0x0c,
-                0xdd, 0x63, 0xe0, 0x62, 0x83, 0x05, 0x47, 0x08,
+                0x01, 0x70, 0x89, 0x1a, 0x9d, 0xc4, 0xc8, 0xc0, 0x32, 0xd3, 0xbe, 0x66, 0xd2, 0x63,
+                0x6b, 0xa0, 0x02, 0x0c, 0x63, 0xf4, 0x26, 0x53, 0x29, 0xff, 0xac, 0x2a, 0xe6, 0x35,
+                0x57, 0x32, 0x63, 0xf4, 0x99, 0xbd, 0x4c, 0x13,
             ],
             c_out: [
-                0x0b, 0x2c, 0xc0, 0xa2, 0x2d, 0x06, 0xfc, 0x36, 0xa0, 0x8a, 0x7d, 0x82, 0x33, 0x8d,
-                0x4a, 0xd0, 0x95, 0xa3, 0x93, 0xa1, 0xc2, 0x4a, 0x78, 0x8d, 0x45, 0x24, 0x35, 0x94,
-                0x4a, 0xcc, 0xe6, 0x38, 0x1e, 0xcc, 0x69, 0x37, 0xf2, 0xc3, 0x8c, 0x89, 0xa5, 0xf5,
-                0x1a, 0xa6, 0x0c, 0xa6, 0x58, 0xfe, 0x71, 0x37, 0x1c, 0x2a, 0x83, 0xf4, 0x96, 0xca,
-                0x2e, 0x62, 0x49, 0x79, 0x2e, 0x09, 0xeb, 0x79, 0xea, 0x3a, 0x13, 0x80, 0x32, 0x18,
-                0xff, 0x20, 0x88, 0x9d, 0x8c, 0x59, 0xc8, 0x5e, 0x90, 0x99,
-            ],
+                0x43, 0x0d, 0xaa, 0x6b, 0x75, 0x63, 0x22, 0x80, 0xd5, 0xe6, 0xda, 0xcb, 0xd2, 0xa0,
+                0xff, 0xe2, 0xaf, 0x98, 0x60, 0xc8, 0x3a, 0x3d, 0x2a, 0x87, 0xf1, 0x79, 0x62, 0x88,
+                0xeb, 0xed, 0x64, 0xd0, 0xcd, 0xc4, 0x60, 0xe2, 0xc8, 0x61, 0xc4, 0xf9, 0x38, 0x7d,
+                0x92, 0x59, 0xfc, 0x60, 0x01, 0xac, 0xd0, 0xe7, 0x6f, 0x3b, 0x0f, 0xdb, 0x5d, 0xac,
+                0x97, 0x4c, 0x26, 0xb5, 0x1b, 0x85, 0x9f, 0xab, 0xe0, 0x2e, 0xab, 0xae, 0x96, 0x8a,
+                0xab, 0x2e, 0x5e, 0x61, 0xef, 0xc2, 0xd4, 0x46, 0x2c, 0x1e,
+            ],
+            note_type: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1978,34 +1987,34 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x71, 0x55, 0x00, 0xb5,
             ],
             rho: [
-                0x3b, 0x37, 0x96, 0x78, 0x0c, 0x0a, 0xec, 0x14, 0xed, 0x28, 0x74, 0xb5, 0x23, 0x06,
-                0xe1, 0xc3, 0xd5, 0xde, 0x45, 0x93, 0xc6, 0x69, 0xaf, 0x1c, 0xaf, 0x11, 0xbc, 0xb4,
-                0xd3, 0x5c, 0x60, 0x12,
+                0xea, 0x38, 0x44, 0x75, 0x9a, 0x9a, 0x1c, 0xc5, 0x28, 0xb2, 0x95, 0xce, 0x70, 0x13,
+                0x7a, 0x85, 0xf9, 0xf0, 0x8e, 0x41, 0xa5, 0xc7, 0xc1, 0xca, 0xc1, 0x55, 0xa6, 0x69,
+                0xa3, 0x18, 0x53, 0x3e,
             ],
             cmx: [
-                0x4d, 0xa9, 0xdf, 0xdc, 0x70, 0x8c, 0xe8, 0xa0, 0x77, 0xa0, 0x6e, 0xc0, 0x67, 0x79,
-                0x24, 0xcf, 0x37, 0x70, 0xed, 0xc2, 0x07, 0xfd, 0x5e, 0x7d, 0x69, 0x5f, 0x71, 0xb0,
-                0x15, 0xbb, 0x03, 0x05,
+                0x6a, 0xba, 0x28, 0x10, 0x5b, 0xc0, 0x72, 0xc5, 0x2a, 0xb8, 0xa3, 0x14, 0x79, 0x7f,
+                0xf8, 0x66, 0x66, 0xdf, 0xb7, 0xcd, 0x8a, 0x2a, 0xe1, 0x7c, 0x58, 0x5f, 0xb7, 0xb6,
+                0x51, 0x5b, 0x97, 0x1c,
             ],
             esk: [
-                0xae, 0xec, 0x0d, 0xb9, 0x0e, 0x55, 0x83, 0x3c, 0x8b, 0xaf, 0x52, 0x6d, 0x66, 0x54,
-                0xa1, 0x74, 0x5b, 0xa4, 0x4c, 0xad, 0x3c, 0xf9, 0xa6, 0x2c, 0xfb, 0xee, 0x5d, 0xe3,
-                0x99, 0xca, 0x31, 0x26,
+                0x03, 0xfb, 0x79, 0x43, 0x75, 0x27, 0x5d, 0x23, 0xd1, 0x58, 0xd5, 0x64, 0x6b, 0xc4,
+                0x63, 0xa8, 0xb7, 0x38, 0xbc, 0x79, 0x38, 0xf6, 0x0d, 0xfb, 0x15, 0x5b, 0xef, 0x4d,
+                0x46, 0x1e, 0xec, 0x29,
             ],
             ephemeral_key: [
-                0x2d, 0xa0, 0x59, 0x4c, 0xd8, 0x74, 0x91, 0x46, 0x52, 0x67, 0xe7, 0x2c, 0x61, 0x89,
-                0x07, 0x91, 0xfe, 0xb4, 0x25, 0xa2, 0xbb, 0xcd, 0xda, 0xcf, 0xe4, 0x5a, 0x66, 0x62,
-                0x2f, 0x49, 0xef, 0x35,
+                0x95, 0x9b, 0xea, 0x8e, 0x11, 0x96, 0x8b, 0x0f, 0x34, 0x3c, 0x04, 0xcd, 0x6d, 0x50,
+                0x16, 0xfc, 0xd4, 0x33, 0x90, 0x75, 0x36, 0xa2, 0x46, 0xba, 0x1c, 0x5d, 0x3e, 0x88,
+                0x97, 0xf3, 0x23, 0x1c,
             ],
             shared_secret: [
-                0xe0, 0xb1, 0x52, 0x67, 0xfd, 0x21, 0x08, 0xeb, 0xbd, 0xd4, 0x16, 0x3f, 0x83, 0xad,
-                0xef, 0xb6, 0x1c, 0x3e, 0xdf, 0x56, 0x6d, 0x94, 0x6f, 0xa1, 0xc1, 0x5e, 0x96, 0x46,
-                0x43, 0xb1, 0x9c, 0x8e,
+                0xe2, 0x69, 0x19, 0xb4, 0x0c, 0x70, 0xaf, 0x74, 0x1d, 0xf9, 0x04, 0x51, 0x72, 0x55,
+                0x03, 0x58, 0x89, 0xee, 0x5a, 0x44, 0x42, 0x6d, 0x6a, 0xb8, 0x5c, 0x07, 0x4b, 0x86,
+                0x2b, 0xa0, 0x63, 0x08,
             ],
             k_enc: [
-                0x28, 0x48, 0xae, 0x53, 0xaa, 0xce, 0xbe, 0x7c, 0xab, 0x58, 0x73, 0x1d, 0xc2, 0x21,
-                0x88, 0x1b, 0x60, 0x2c, 0xc5, 0xa5, 0x3b, 0xcc, 0x1f, 0x76, 0xc8, 0x20, 0xb0, 0xea,
-                0x13, 0x55, 0x68, 0x8e,
+                0x09, 0xda, 0xc6, 0x51, 0x1c, 0x38, 0x44, 0x58, 0x7f, 0x82, 0x9c, 0x2f, 0x1e, 0xa0,
+                0x37, 0xa8, 0x1a, 0x8d, 0x54, 0x85, 0xed, 0x04, 0xea, 0xf2, 0x75, 0x80, 0x05, 0xb3,
+                0x2a, 0x20, 0x47, 0x0b,
             ],
             p_enc: [
                 0x02, 0xdd, 0xb7, 0xc5, 0xbc, 0x4d, 0xe9, 0xdf, 0x52, 0x1b, 0xb0, 0x4b, 0xad, 0x95,
@@ -2051,69 +2060,2210 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xf5, 0xc6, 0x38, 0xbf,
             ],
             c_enc: [
-                0xf1, 0x42, 0xc4, 0xe5, 0x0e, 0xef, 0x2c, 0x64, 0x44, 0xcc, 0xd4, 0x0b, 0x8c, 0x99,
-                0xe5, 0x6a, 0x72, 0xec, 0x4e, 0x30, 0xcf, 0x73, 0x68, 0x75, 0xf0, 0xaa, 0x6b, 0x8e,
-                0x6d, 0x9c, 0xc3, 0x67, 0x73, 0x2d, 0xbc, 0x9a, 0xf0, 0xb3, 0x7d, 0x1f, 0xca, 0x6d,
-                0x5b, 0xdd, 0x1d, 0xc1, 0x23, 0x79, 0x29, 0x66, 0x99, 0x9d, 0x62, 0xea, 0xf8, 0xc5,
-                0xfe, 0x8d, 0x99, 0x91, 0x84, 0xf2, 0x8b, 0x99, 0xec, 0xef, 0xcc, 0x8f, 0x14, 0x8d,
-                0xbd, 0x52, 0x02, 0x6f, 0xdb, 0x48, 0xdf, 0xda, 0x7b, 0xad, 0xb6, 0xd1, 0xfc, 0xd2,
-                0x9a, 0xd2, 0x19, 0xea, 0xbf, 0xbb, 0x44, 0x3f, 0x5d, 0x0f, 0x98, 0xb6, 0x6a, 0x3a,
-                0x25, 0x73, 0x1b, 0x52, 0xd7, 0xf2, 0xdf, 0x70, 0x01, 0x4b, 0x4a, 0xc6, 0x99, 0x34,
-                0x32, 0xf8, 0x98, 0x1e, 0x9c, 0xbf, 0xe1, 0x69, 0x13, 0xf6, 0x8a, 0x93, 0x5d, 0x2d,
-                0xd0, 0x06, 0xd4, 0x28, 0xf1, 0x45, 0x53, 0xe7, 0x29, 0x86, 0xc7, 0x0f, 0xb4, 0x43,
-                0x18, 0xd2, 0x7c, 0x4d, 0x6f, 0x6f, 0xd3, 0x92, 0x3a, 0xb0, 0xf6, 0x28, 0x9a, 0x02,
-                0x48, 0x5e, 0x87, 0x17, 0xe5, 0x7d, 0xa0, 0x24, 0xeb, 0xe1, 0x6e, 0x9c, 0xf8, 0x35,
-                0xcf, 0x53, 0xd2, 0x19, 0x4f, 0xd4, 0x25, 0x50, 0x06, 0xb8, 0x1b, 0xfd, 0x51, 0xd1,
-                0xef, 0x5a, 0xe9, 0xf9, 0xef, 0x6a, 0xf6, 0x57, 0x41, 0x81, 0xe2, 0xe2, 0x26, 0x50,
-                0xcb, 0x91, 0x2a, 0x6b, 0x89, 0x88, 0xa0, 0x28, 0x86, 0x32, 0xbc, 0x73, 0x62, 0xbb,
-                0xe1, 0x87, 0x23, 0xd8, 0x27, 0xf7, 0x94, 0x58, 0x62, 0x26, 0x0d, 0xf7, 0x8e, 0x95,
-                0xd7, 0xd5, 0xe3, 0x31, 0x3f, 0x5a, 0xff, 0x72, 0xe2, 0x1c, 0xe2, 0xdf, 0x00, 0xee,
-                0x7e, 0x81, 0x5a, 0xba, 0x17, 0xcc, 0xde, 0x15, 0xc2, 0x7e, 0xee, 0x08, 0x5f, 0x52,
-                0xf3, 0x6c, 0x02, 0xec, 0xd6, 0x6c, 0xe1, 0x8b, 0x40, 0x15, 0xbe, 0xb6, 0x09, 0x23,
-                0x3f, 0x6e, 0xb2, 0x8e, 0x4a, 0xd5, 0xcd, 0xbe, 0x6f, 0xdc, 0xab, 0x68, 0xbf, 0xbb,
-                0x6f, 0xfd, 0x87, 0xd3, 0x86, 0xd8, 0x7e, 0xb1, 0xfe, 0x00, 0x34, 0x27, 0x0f, 0x41,
-                0x27, 0x1e, 0xa0, 0x1f, 0x9e, 0xae, 0xa9, 0xe8, 0x9f, 0x78, 0x35, 0x9e, 0x41, 0x73,
-                0x94, 0xbb, 0x9d, 0xf5, 0xb6, 0x1c, 0x36, 0xe3, 0x0b, 0xc1, 0xce, 0x4a, 0xb1, 0xbd,
-                0xd7, 0x9f, 0xa4, 0x08, 0x3e, 0x82, 0x8d, 0xd1, 0x04, 0xe4, 0x73, 0x80, 0xcd, 0x83,
-                0xcd, 0x65, 0x9d, 0xf4, 0x4d, 0xb9, 0x43, 0xdc, 0x07, 0xbc, 0xc8, 0x07, 0x05, 0x04,
-                0xa1, 0xc6, 0x55, 0x23, 0x02, 0xe7, 0x4b, 0xe4, 0xb9, 0xc4, 0x32, 0x75, 0xec, 0xc2,
-                0x88, 0xce, 0xda, 0x41, 0x59, 0xa9, 0xcc, 0x55, 0x7c, 0x18, 0x19, 0x5c, 0xec, 0x92,
-                0x62, 0x24, 0xd8, 0xd6, 0x9e, 0x98, 0xe1, 0x83, 0x5a, 0x2e, 0x29, 0x05, 0x63, 0xef,
-                0x20, 0xd0, 0x83, 0xd1, 0x4e, 0x93, 0xcc, 0x1f, 0x3f, 0x76, 0x3e, 0xf5, 0x58, 0x0e,
-                0x13, 0x5f, 0xae, 0x1b, 0xb8, 0x54, 0x4a, 0x0c, 0x5c, 0x6d, 0x88, 0x17, 0x41, 0xe4,
-                0x51, 0x34, 0x47, 0xac, 0xeb, 0x09, 0x33, 0xe6, 0xeb, 0xaf, 0x0c, 0xe3, 0x13, 0xc1,
-                0x8c, 0x9a, 0xf9, 0x5b, 0xa5, 0x61, 0x31, 0xf7, 0x8f, 0x42, 0x72, 0x41, 0x22, 0x65,
-                0xbc, 0xf4, 0xc5, 0xf6, 0x80, 0x89, 0x3c, 0xcd, 0xa5, 0x73, 0x7d, 0xa8, 0x23, 0xb7,
-                0x63, 0x6e, 0x98, 0xdb, 0xa5, 0x62, 0x44, 0xf2, 0xb9, 0x6a, 0x10, 0x90, 0xa6, 0x60,
-                0x38, 0x15, 0xc0, 0xef, 0x54, 0x97, 0x50, 0xf2, 0x47, 0x06, 0x19, 0x0b, 0x55, 0x76,
-                0x6e, 0x8a, 0x62, 0x09, 0xa1, 0xc2, 0x2f, 0x67, 0xe8, 0x77, 0x62, 0x66, 0xb6, 0xfa,
-                0xe4, 0x5b, 0xf7, 0x94, 0x90, 0x7f, 0x64, 0x71, 0x4f, 0xbe, 0x26, 0xc3, 0x0a, 0xc4,
-                0x04, 0x11, 0xf5, 0xe6, 0x4f, 0xc1, 0x66, 0xc8, 0x4f, 0x28, 0xb8, 0x23, 0xfd, 0xaa,
-                0x68, 0x32, 0xa3, 0x25, 0x63, 0x31, 0x7d, 0x25, 0x4c, 0x53, 0x16, 0x9b, 0x9f, 0xfb,
-                0x24, 0x53, 0xa1, 0x12, 0x2f, 0xa4, 0x4c, 0x7f, 0x17, 0xc1, 0x36, 0xb5, 0x7e, 0x20,
-                0xad, 0x17, 0x7a, 0x7e, 0xee, 0xbf, 0x9f, 0x56, 0xfb, 0x0b, 0x55, 0xcc, 0xcf, 0x68,
-                0x2b, 0x8a, 0x5b, 0xd8, 0xa7, 0x45,
+                0x7b, 0x59, 0x87, 0x78, 0xa7, 0x28, 0x4d, 0x52, 0xa7, 0x47, 0x77, 0x4c, 0x54, 0xbd,
+                0x92, 0x57, 0xb3, 0xf1, 0x7a, 0xf1, 0x3e, 0xcc, 0x72, 0xc0, 0xe3, 0xcd, 0x95, 0xeb,
+                0xfa, 0xfa, 0xa3, 0x7d, 0x16, 0x65, 0x15, 0x53, 0xdd, 0x27, 0xf0, 0x1c, 0x9c, 0xf2,
+                0x4b, 0x62, 0xd7, 0xdc, 0xfd, 0x52, 0xfa, 0x4b, 0x2b, 0x3b, 0x4a, 0x8c, 0xa9, 0xeb,
+                0xfc, 0xe7, 0xf4, 0xfc, 0xec, 0x27, 0xe6, 0x05, 0x8e, 0x44, 0x68, 0xc1, 0x50, 0x10,
+                0xd0, 0x17, 0xcb, 0x90, 0x1a, 0xbf, 0xb2, 0x2e, 0xad, 0x86, 0x99, 0x83, 0xf6, 0x9a,
+                0xed, 0xf2, 0xda, 0x7d, 0x6a, 0xaf, 0xd1, 0x30, 0x6e, 0xe7, 0x36, 0xf2, 0xdb, 0x33,
+                0xbc, 0xe4, 0xb0, 0x9f, 0xca, 0x74, 0x69, 0x2a, 0x52, 0x09, 0xa7, 0x39, 0x2b, 0x7e,
+                0xa9, 0x68, 0x5b, 0xe9, 0xec, 0x43, 0x1f, 0xfe, 0x50, 0xf7, 0x0f, 0x90, 0x22, 0x74,
+                0x05, 0x03, 0x45, 0x2a, 0xb5, 0x14, 0x92, 0xb1, 0xf7, 0x47, 0x7e, 0xda, 0x42, 0x7b,
+                0x42, 0x3a, 0x93, 0x1b, 0x26, 0x38, 0x6c, 0x56, 0xe4, 0x27, 0x86, 0x3d, 0x46, 0xb1,
+                0x99, 0xff, 0xa0, 0x8c, 0x52, 0x9f, 0xa5, 0x72, 0x1f, 0x68, 0xe9, 0x14, 0xf6, 0xea,
+                0x6a, 0x8a, 0xe6, 0xae, 0xcb, 0xf7, 0x37, 0x47, 0x1e, 0xbd, 0x83, 0xdb, 0xa9, 0xa7,
+                0xcd, 0x89, 0x75, 0x66, 0x20, 0x4e, 0x2b, 0xae, 0x63, 0xe3, 0x4e, 0x70, 0x32, 0x51,
+                0x02, 0x96, 0x92, 0x0d, 0x7e, 0x7a, 0x7c, 0xcf, 0x0f, 0xeb, 0xe7, 0xa8, 0x33, 0x69,
+                0x6a, 0x4b, 0x67, 0x41, 0x88, 0x5e, 0x9b, 0x94, 0x0c, 0x61, 0xdd, 0x8d, 0x44, 0x38,
+                0x54, 0x74, 0x15, 0x31, 0x0b, 0x15, 0xcf, 0x18, 0xdc, 0x19, 0x90, 0x07, 0x8c, 0x70,
+                0x8b, 0xea, 0xc3, 0x32, 0xa8, 0xe0, 0x81, 0x46, 0xa6, 0x95, 0x8e, 0xa6, 0xf4, 0x3f,
+                0xd0, 0xc2, 0xc8, 0xe9, 0x99, 0xaa, 0x4f, 0xdf, 0x1e, 0x77, 0xef, 0xde, 0x54, 0xfd,
+                0x65, 0xc6, 0x7a, 0x3f, 0x07, 0xda, 0xf5, 0xf6, 0x04, 0x49, 0x60, 0xa0, 0xb6, 0xdd,
+                0x84, 0x1f, 0xf8, 0xb8, 0xa5, 0x92, 0xc7, 0xb1, 0x09, 0x34, 0x2c, 0x73, 0x5c, 0x2a,
+                0x0e, 0x37, 0xb3, 0x0b, 0x8b, 0xaa, 0x5c, 0x77, 0x01, 0xeb, 0xc7, 0xa8, 0xf8, 0x20,
+                0xc0, 0x22, 0x7c, 0xa5, 0x00, 0x3f, 0x36, 0xee, 0x68, 0xf7, 0xb2, 0x89, 0x81, 0xc2,
+                0x73, 0x32, 0x03, 0x9d, 0xd6, 0xa4, 0x94, 0xf0, 0xcd, 0x02, 0xbd, 0xd2, 0x8f, 0x68,
+                0x3e, 0xca, 0x1b, 0x03, 0x2a, 0xfc, 0x09, 0xdd, 0x0c, 0xd8, 0x56, 0xcb, 0xc1, 0xa3,
+                0x5e, 0x74, 0xd4, 0x0c, 0x24, 0x53, 0xdf, 0xe2, 0x42, 0xc8, 0x6a, 0x7a, 0x60, 0xbc,
+                0xbd, 0xdb, 0x17, 0x96, 0x6c, 0x7d, 0xba, 0x76, 0x9e, 0xab, 0xd1, 0xc1, 0x67, 0xb7,
+                0xe8, 0x19, 0x78, 0xf9, 0x12, 0x8b, 0xac, 0x26, 0xa2, 0x8d, 0x77, 0x21, 0x30, 0x79,
+                0xcb, 0x56, 0xc0, 0x95, 0xa7, 0xc0, 0x60, 0xde, 0x0e, 0x77, 0x5c, 0xa8, 0xac, 0x8e,
+                0x6c, 0xa9, 0x4d, 0x19, 0xc6, 0x16, 0x2e, 0x44, 0xf7, 0xa8, 0xf0, 0x14, 0x9d, 0x31,
+                0xd3, 0x46, 0x3d, 0x01, 0xb6, 0x1a, 0x14, 0x63, 0xa9, 0xde, 0x3d, 0x8a, 0xb7, 0x40,
+                0x04, 0x0a, 0x76, 0xe0, 0x5b, 0x37, 0x64, 0x28, 0x86, 0x29, 0x87, 0x59, 0x5b, 0x87,
+                0xce, 0xa6, 0x94, 0xfe, 0x92, 0x0a, 0x06, 0x7e, 0x81, 0x6b, 0x4f, 0x29, 0xa3, 0xa2,
+                0x24, 0x50, 0x14, 0x0f, 0x13, 0x5d, 0x71, 0x9a, 0x97, 0x1b, 0x81, 0xfc, 0x19, 0x16,
+                0x98, 0x0a, 0x55, 0xdd, 0xf8, 0xd9, 0x87, 0x30, 0x57, 0x36, 0x35, 0xa0, 0x70, 0x85,
+                0xc4, 0xe7, 0x7c, 0x7e, 0x1c, 0xdb, 0xb6, 0x85, 0x42, 0x6e, 0xe4, 0x62, 0xcc, 0x30,
+                0x83, 0xa3, 0xf5, 0xa3, 0xb9, 0x17, 0xc0, 0x6f, 0x9a, 0x96, 0xf9, 0xf7, 0xbd, 0x81,
+                0xac, 0xa4, 0x9b, 0xef, 0x95, 0xb9, 0x28, 0x06, 0xc4, 0x2d, 0x09, 0x12, 0x01, 0x31,
+                0x42, 0xb2, 0x2a, 0x7b, 0xad, 0x72, 0x12, 0x11, 0x46, 0x91, 0xf1, 0xdc, 0x72, 0x64,
+                0xc6, 0x7e, 0x76, 0x34, 0xf5, 0xd7, 0x95, 0xc9, 0x75, 0x30, 0x62, 0xe3, 0x06, 0xc0,
+                0x6b, 0xc1, 0x03, 0xaa, 0x01, 0xc1, 0x0d, 0x1f, 0x5d, 0xd4, 0xcd, 0x59, 0xf6, 0x53,
+                0x2c, 0xb7, 0x23, 0xe3, 0xa0, 0x26,
             ],
             ock: [
-                0x06, 0x3c, 0x83, 0xa4, 0x95, 0x74, 0xe7, 0x80, 0x35, 0x89, 0xcc, 0x3d, 0x34, 0xb4,
-                0x38, 0x90, 0xf3, 0xd7, 0x63, 0x87, 0x35, 0xe7, 0xbd, 0x5e, 0xbd, 0xd1, 0xa5, 0xea,
-                0xb9, 0xd9, 0xc5, 0xd6,
+                0x4a, 0x25, 0x25, 0x4c, 0xcc, 0x44, 0x4e, 0xc6, 0x1c, 0x2b, 0xac, 0xeb, 0x2e, 0xe3,
+                0x97, 0x7a, 0x63, 0x32, 0x44, 0x9a, 0x3a, 0x53, 0xad, 0xd2, 0x31, 0xab, 0xf3, 0xd1,
+                0x8b, 0xb3, 0x29, 0x3d,
             ],
             op: [
                 0x65, 0x3d, 0x07, 0xc9, 0x07, 0x94, 0x6a, 0xc3, 0x02, 0x0e, 0xbd, 0xe1, 0xb4, 0xf6,
                 0x10, 0x21, 0x0c, 0x30, 0xc4, 0x50, 0xe4, 0x27, 0x12, 0x65, 0xa0, 0x5d, 0x6e, 0xce,
-                0x44, 0x6d, 0xf4, 0x39, 0xae, 0xec, 0x0d, 0xb9, 0x0e, 0x55, 0x83, 0x3c, 0x8b, 0xaf,
-                0x52, 0x6d, 0x66, 0x54, 0xa1, 0x74, 0x5b, 0xa4, 0x4c, 0xad, 0x3c, 0xf9, 0xa6, 0x2c,
-                0xfb, 0xee, 0x5d, 0xe3, 0x99, 0xca, 0x31, 0x26,
+                0x44, 0x6d, 0xf4, 0x39, 0x03, 0xfb, 0x79, 0x43, 0x75, 0x27, 0x5d, 0x23, 0xd1, 0x58,
+                0xd5, 0x64, 0x6b, 0xc4, 0x63, 0xa8, 0xb7, 0x38, 0xbc, 0x79, 0x38, 0xf6, 0x0d, 0xfb,
+                0x15, 0x5b, 0xef, 0x4d, 0x46, 0x1e, 0xec, 0x29,
+            ],
+            c_out: [
+                0x7b, 0xf4, 0x12, 0x7d, 0x22, 0xcc, 0x57, 0x35, 0x87, 0x51, 0x2f, 0xf8, 0x1e, 0x55,
+                0x3e, 0x3c, 0x98, 0x23, 0x5f, 0x51, 0xc7, 0x23, 0x7e, 0x9e, 0x76, 0x1a, 0x08, 0xf2,
+                0xe1, 0xe8, 0x0d, 0x04, 0x26, 0x98, 0xfc, 0x3b, 0x1d, 0x03, 0x18, 0xf1, 0xfd, 0xca,
+                0x8e, 0x41, 0xa3, 0x16, 0xd6, 0xaf, 0x3a, 0xc0, 0xc4, 0x0c, 0xe1, 0x99, 0x47, 0xa2,
+                0xba, 0xfe, 0x80, 0x4d, 0x46, 0x6e, 0xd0, 0x79, 0x82, 0x7f, 0xc1, 0x41, 0x91, 0xeb,
+                0xb5, 0x99, 0x17, 0x87, 0x49, 0xe9, 0xc4, 0x06, 0xaf, 0x26,
+            ],
+            note_type: None,
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xdc, 0x10, 0x95, 0x20, 0x57, 0xc4, 0xbe, 0xaa, 0xd8, 0xaf, 0x37, 0xce, 0x4e, 0xee,
+                0x9b, 0x10, 0xed, 0x84, 0xf4, 0x6b, 0xad, 0xd4, 0x8e, 0x0a, 0x22, 0x9b, 0xe8, 0x41,
+                0x54, 0xa9, 0xbf, 0x75, 0x6b, 0xe0, 0x2e, 0xcf, 0xa9, 0xad, 0x6d, 0x9c, 0x02, 0xc8,
+                0xf9, 0x54, 0xcb, 0x15, 0x71, 0x7b, 0x79, 0x46, 0x1f, 0x00, 0x4b, 0xf1, 0xbc, 0x5c,
+                0x7e, 0x3f, 0xda, 0x73, 0x53, 0x7c, 0x1a, 0x0a,
+            ],
+            ovk: [
+                0x97, 0x74, 0x85, 0xcd, 0xdf, 0xbe, 0xd5, 0x93, 0x2f, 0x50, 0x7b, 0x79, 0x94, 0x7a,
+                0xdb, 0x2f, 0xad, 0x37, 0x61, 0x5a, 0xa7, 0x17, 0xdb, 0x5f, 0x29, 0x80, 0x99, 0xf2,
+                0x0f, 0x26, 0x3b, 0x35,
+            ],
+            default_d: [
+                0xf6, 0xb0, 0x18, 0xdf, 0xa7, 0x26, 0x31, 0x5b, 0x44, 0xcf, 0x9e,
+            ],
+            default_pk_d: [
+                0x05, 0x82, 0x53, 0xd4, 0x85, 0x76, 0x44, 0x88, 0x5e, 0x26, 0xa9, 0x09, 0xc8, 0x38,
+                0x59, 0x25, 0x23, 0x5a, 0x75, 0x29, 0x85, 0x44, 0x6e, 0x11, 0x69, 0x5f, 0x36, 0xc2,
+                0xe6, 0x84, 0x45, 0xbb,
+            ],
+            v: 2111628168871420429,
+            rseed: [
+                0xcc, 0x57, 0x9a, 0x7a, 0x8f, 0xff, 0x7c, 0xa7, 0xcf, 0x14, 0x5d, 0xfc, 0x13, 0xea,
+                0xfc, 0x34, 0x15, 0x3b, 0x2c, 0x3e, 0x8a, 0xfb, 0xe5, 0x34, 0x44, 0xd0, 0xc7, 0x3b,
+                0x3b, 0xd5, 0xbc, 0x87,
+            ],
+            memo: [
+                0xff, 0x0b, 0x01, 0xcd, 0x45, 0x79, 0x11, 0xe3, 0x56, 0x31, 0x3f, 0xd1, 0xda, 0xfb,
+                0x4c, 0x81, 0x51, 0x63, 0x4a, 0x01, 0xaf, 0xf7, 0xcf, 0x11, 0x6d, 0x43, 0x3c, 0x3d,
+                0x2b, 0x3a, 0xdd, 0xa9, 0xce, 0xbe, 0x18, 0xf7, 0xd1, 0x72, 0x44, 0x3e, 0x5e, 0x7b,
+                0x5a, 0xc9, 0xab, 0xe8, 0xdb, 0x22, 0x56, 0xd7, 0xeb, 0xe2, 0xff, 0x28, 0x02, 0x09,
+                0x39, 0x50, 0x38, 0x70, 0x59, 0x7b, 0x9a, 0x95, 0x58, 0x92, 0xc7, 0x38, 0x96, 0x50,
+                0xa2, 0xd4, 0x2e, 0xc9, 0x2b, 0xe7, 0x23, 0xfe, 0xdf, 0x2f, 0x2e, 0xde, 0x5a, 0x47,
+                0x2a, 0xa1, 0xe7, 0x4f, 0x33, 0xad, 0x41, 0x90, 0x15, 0x44, 0xed, 0xbb, 0xe3, 0xac,
+                0x46, 0x4c, 0xf4, 0x39, 0x19, 0x60, 0x15, 0xf4, 0xf2, 0x2a, 0xc2, 0xb8, 0xfc, 0x01,
+                0x49, 0x6b, 0xea, 0xb4, 0xd4, 0x59, 0x07, 0xf4, 0x79, 0x81, 0x2a, 0x25, 0x94, 0x31,
+                0xa2, 0xcb, 0xc9, 0x3d, 0x4f, 0x3b, 0x84, 0xe4, 0xdd, 0x36, 0x60, 0x20, 0x27, 0x3a,
+                0x67, 0x52, 0xe5, 0x01, 0xaf, 0x6f, 0xf1, 0xb7, 0x8d, 0xdc, 0x81, 0x7e, 0x6e, 0xa3,
+                0x51, 0xd6, 0x00, 0x6b, 0xec, 0xf8, 0xd2, 0xff, 0xb0, 0x39, 0x90, 0xf6, 0x77, 0x74,
+                0xa8, 0x1e, 0x05, 0xb7, 0xf4, 0xbb, 0xad, 0x85, 0x77, 0xfa, 0x27, 0xc9, 0xde, 0x64,
+                0xe1, 0xb1, 0x1d, 0xcf, 0x38, 0x4f, 0x59, 0x56, 0x44, 0x37, 0x48, 0x75, 0x5a, 0x9f,
+                0xc6, 0xf2, 0xa0, 0x0b, 0x10, 0xc3, 0x65, 0x7e, 0xba, 0xc0, 0x3b, 0xfc, 0x0b, 0x58,
+                0x7b, 0xef, 0x2f, 0x45, 0xec, 0x8a, 0xcd, 0xaa, 0x51, 0xc1, 0x43, 0xb0, 0xcb, 0x25,
+                0xb9, 0x14, 0x2c, 0x61, 0xbd, 0x79, 0x0a, 0x80, 0xd7, 0xc2, 0x3f, 0x90, 0xcc, 0x03,
+                0x49, 0x5b, 0x51, 0xe4, 0xd2, 0x84, 0x3e, 0x55, 0x7f, 0x9e, 0x25, 0x45, 0x10, 0x8c,
+                0x6c, 0x6f, 0xae, 0x35, 0x9f, 0x64, 0x5c, 0x27, 0x68, 0x91, 0xc0, 0xdc, 0xab, 0x3f,
+                0xaf, 0x18, 0x77, 0x00, 0xc0, 0x82, 0xdc, 0x47, 0x77, 0x40, 0xfb, 0x3f, 0x2c, 0xd7,
+                0xbb, 0x59, 0xfb, 0x35, 0x85, 0x54, 0xe9, 0x4c, 0x7e, 0x67, 0x8c, 0xe0, 0x1a, 0xeb,
+                0xf9, 0x4e, 0x51, 0x5e, 0x49, 0x72, 0x29, 0x67, 0x99, 0x5a, 0xea, 0x85, 0x8d, 0x64,
+                0xe7, 0x78, 0x9f, 0xf3, 0x06, 0x36, 0x95, 0x77, 0x22, 0x81, 0x80, 0x32, 0x6a, 0x5b,
+                0x0a, 0xf4, 0x75, 0xe2, 0x7a, 0x54, 0xb2, 0x07, 0xb4, 0x1f, 0x92, 0xe3, 0x76, 0x17,
+                0x0e, 0x3f, 0xb0, 0x05, 0x02, 0x82, 0x61, 0xc9, 0x9c, 0x2d, 0xbd, 0x0e, 0xed, 0xee,
+                0x87, 0x1c, 0x1c, 0x0f, 0x48, 0xb8, 0xe9, 0xb8, 0xe4, 0xbe, 0x77, 0xd1, 0xb7, 0x37,
+                0xfe, 0x21, 0xf0, 0xfa, 0x5a, 0x18, 0xeb, 0xb5, 0x27, 0x55, 0xb5, 0xa6, 0xcf, 0x61,
+                0x30, 0xfb, 0x56, 0x94, 0x4c, 0xfa, 0xb8, 0x75, 0x27, 0xc2, 0x50, 0xd1, 0x13, 0xb2,
+                0x9b, 0xca, 0xc9, 0xaa, 0xa1, 0x0c, 0x2e, 0x7d, 0xe4, 0x15, 0xed, 0xb0, 0x80, 0x6c,
+                0x6d, 0xa0, 0x30, 0x20, 0xa1, 0x34, 0xca, 0x7e, 0xcd, 0xc8, 0xda, 0x1b, 0xd5, 0x7a,
+                0x37, 0xf5, 0x5a, 0x46, 0x94, 0x0b, 0x45, 0xb2, 0x41, 0xb1, 0xc1, 0x6e, 0xe1, 0x00,
+                0x92, 0x7d, 0x1b, 0xd8, 0x60, 0xd4, 0x45, 0xa9, 0xde, 0x50, 0xd4, 0xc3, 0x84, 0xd6,
+                0xe1, 0xd0, 0x01, 0x08, 0x02, 0x6c, 0x0e, 0xa5, 0xeb, 0xbf, 0x0b, 0x72, 0xfb, 0xf5,
+                0xc3, 0x70, 0xbc, 0xe1, 0x8d, 0x3a, 0xcb, 0xc4, 0x65, 0x99, 0x09, 0x9b, 0xaa, 0xe1,
+                0xd8, 0x02, 0xf7, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ],
+            cv_net: [
+                0x09, 0xee, 0x7e, 0xf6, 0x3a, 0xb1, 0xcf, 0x24, 0x2b, 0xaa, 0x76, 0xfc, 0xbf, 0xfb,
+                0xe5, 0x75, 0x5f, 0x13, 0x14, 0x2b, 0x38, 0xb1, 0xa0, 0x40, 0x4d, 0x7d, 0x5a, 0x3f,
+                0x4f, 0x22, 0x1e, 0x96,
+            ],
+            rho: [
+                0xf6, 0x5d, 0x22, 0x96, 0x09, 0x58, 0xd7, 0x28, 0x59, 0x60, 0x9c, 0x99, 0x46, 0xd8,
+                0xa9, 0x4a, 0x06, 0x04, 0xb8, 0x00, 0x6c, 0xc7, 0x94, 0xbc, 0xab, 0x57, 0x73, 0x49,
+                0xbc, 0xf8, 0x63, 0x37,
+            ],
+            cmx: [
+                0x85, 0xec, 0x16, 0xe8, 0x78, 0x77, 0x33, 0x37, 0x07, 0x9a, 0xec, 0xf3, 0x2c, 0x45,
+                0x5e, 0xbf, 0x16, 0x96, 0x8d, 0xa1, 0xd4, 0x34, 0x51, 0xb7, 0xa3, 0x06, 0x87, 0x6c,
+                0xa3, 0x08, 0xea, 0x3c,
+            ],
+            esk: [
+                0x05, 0x18, 0xdd, 0xc0, 0xc4, 0x7b, 0x7f, 0x77, 0xed, 0xcd, 0x39, 0x16, 0x0f, 0xe5,
+                0x67, 0x75, 0x1e, 0xb8, 0x4a, 0xa2, 0x1d, 0x33, 0xa6, 0x90, 0xe0, 0xd2, 0x9b, 0x35,
+                0x9a, 0xc4, 0xfa, 0x2c,
+            ],
+            ephemeral_key: [
+                0x10, 0x0d, 0xf0, 0x1d, 0x49, 0x86, 0x01, 0x21, 0x8a, 0x28, 0x6b, 0x8f, 0x4e, 0x54,
+                0xda, 0x9b, 0x3f, 0x14, 0x5c, 0x34, 0x70, 0xa9, 0xdb, 0xc4, 0x14, 0x48, 0x0a, 0xa8,
+                0xf2, 0xf4, 0x90, 0x9c,
+            ],
+            shared_secret: [
+                0x93, 0x68, 0xdd, 0x4f, 0x2a, 0xf6, 0x23, 0x34, 0xb8, 0x85, 0xb9, 0x6b, 0xc4, 0xc3,
+                0x8f, 0x10, 0x3a, 0xec, 0x25, 0x6b, 0xed, 0xc2, 0x8b, 0x5e, 0x2e, 0x10, 0x36, 0x4c,
+                0xdd, 0xf3, 0x84, 0xa4,
+            ],
+            k_enc: [
+                0x7a, 0xff, 0xfc, 0x6e, 0xae, 0x5d, 0x56, 0xb2, 0x7b, 0x86, 0xdb, 0x9e, 0xc8, 0xae,
+                0xc2, 0x70, 0xbb, 0x0a, 0xb7, 0x31, 0x23, 0xfd, 0x2a, 0x0b, 0x83, 0xf4, 0xef, 0x84,
+                0xc6, 0x98, 0xe1, 0x67,
+            ],
+            p_enc: [
+                0x03, 0xf6, 0xb0, 0x18, 0xdf, 0xa7, 0x26, 0x31, 0x5b, 0x44, 0xcf, 0x9e, 0x0d, 0x22,
+                0x4a, 0xb7, 0xa1, 0x02, 0x4e, 0x1d, 0xcc, 0x57, 0x9a, 0x7a, 0x8f, 0xff, 0x7c, 0xa7,
+                0xcf, 0x14, 0x5d, 0xfc, 0x13, 0xea, 0xfc, 0x34, 0x15, 0x3b, 0x2c, 0x3e, 0x8a, 0xfb,
+                0xe5, 0x34, 0x44, 0xd0, 0xc7, 0x3b, 0x3b, 0xd5, 0xbc, 0x87, 0xa9, 0x71, 0x5e, 0x65,
+                0xaf, 0x82, 0x67, 0x37, 0x3d, 0x34, 0x51, 0x67, 0x4f, 0xf0, 0x84, 0xef, 0xd9, 0x2c,
+                0xcf, 0x3b, 0xcc, 0x7a, 0xca, 0x14, 0x67, 0xb6, 0x32, 0x7e, 0x4f, 0x95, 0x22, 0xb2,
+                0xff, 0x0b, 0x01, 0xcd, 0x45, 0x79, 0x11, 0xe3, 0x56, 0x31, 0x3f, 0xd1, 0xda, 0xfb,
+                0x4c, 0x81, 0x51, 0x63, 0x4a, 0x01, 0xaf, 0xf7, 0xcf, 0x11, 0x6d, 0x43, 0x3c, 0x3d,
+                0x2b, 0x3a, 0xdd, 0xa9, 0xce, 0xbe, 0x18, 0xf7, 0xd1, 0x72, 0x44, 0x3e, 0x5e, 0x7b,
+                0x5a, 0xc9, 0xab, 0xe8, 0xdb, 0x22, 0x56, 0xd7, 0xeb, 0xe2, 0xff, 0x28, 0x02, 0x09,
+                0x39, 0x50, 0x38, 0x70, 0x59, 0x7b, 0x9a, 0x95, 0x58, 0x92, 0xc7, 0x38, 0x96, 0x50,
+                0xa2, 0xd4, 0x2e, 0xc9, 0x2b, 0xe7, 0x23, 0xfe, 0xdf, 0x2f, 0x2e, 0xde, 0x5a, 0x47,
+                0x2a, 0xa1, 0xe7, 0x4f, 0x33, 0xad, 0x41, 0x90, 0x15, 0x44, 0xed, 0xbb, 0xe3, 0xac,
+                0x46, 0x4c, 0xf4, 0x39, 0x19, 0x60, 0x15, 0xf4, 0xf2, 0x2a, 0xc2, 0xb8, 0xfc, 0x01,
+                0x49, 0x6b, 0xea, 0xb4, 0xd4, 0x59, 0x07, 0xf4, 0x79, 0x81, 0x2a, 0x25, 0x94, 0x31,
+                0xa2, 0xcb, 0xc9, 0x3d, 0x4f, 0x3b, 0x84, 0xe4, 0xdd, 0x36, 0x60, 0x20, 0x27, 0x3a,
+                0x67, 0x52, 0xe5, 0x01, 0xaf, 0x6f, 0xf1, 0xb7, 0x8d, 0xdc, 0x81, 0x7e, 0x6e, 0xa3,
+                0x51, 0xd6, 0x00, 0x6b, 0xec, 0xf8, 0xd2, 0xff, 0xb0, 0x39, 0x90, 0xf6, 0x77, 0x74,
+                0xa8, 0x1e, 0x05, 0xb7, 0xf4, 0xbb, 0xad, 0x85, 0x77, 0xfa, 0x27, 0xc9, 0xde, 0x64,
+                0xe1, 0xb1, 0x1d, 0xcf, 0x38, 0x4f, 0x59, 0x56, 0x44, 0x37, 0x48, 0x75, 0x5a, 0x9f,
+                0xc6, 0xf2, 0xa0, 0x0b, 0x10, 0xc3, 0x65, 0x7e, 0xba, 0xc0, 0x3b, 0xfc, 0x0b, 0x58,
+                0x7b, 0xef, 0x2f, 0x45, 0xec, 0x8a, 0xcd, 0xaa, 0x51, 0xc1, 0x43, 0xb0, 0xcb, 0x25,
+                0xb9, 0x14, 0x2c, 0x61, 0xbd, 0x79, 0x0a, 0x80, 0xd7, 0xc2, 0x3f, 0x90, 0xcc, 0x03,
+                0x49, 0x5b, 0x51, 0xe4, 0xd2, 0x84, 0x3e, 0x55, 0x7f, 0x9e, 0x25, 0x45, 0x10, 0x8c,
+                0x6c, 0x6f, 0xae, 0x35, 0x9f, 0x64, 0x5c, 0x27, 0x68, 0x91, 0xc0, 0xdc, 0xab, 0x3f,
+                0xaf, 0x18, 0x77, 0x00, 0xc0, 0x82, 0xdc, 0x47, 0x77, 0x40, 0xfb, 0x3f, 0x2c, 0xd7,
+                0xbb, 0x59, 0xfb, 0x35, 0x85, 0x54, 0xe9, 0x4c, 0x7e, 0x67, 0x8c, 0xe0, 0x1a, 0xeb,
+                0xf9, 0x4e, 0x51, 0x5e, 0x49, 0x72, 0x29, 0x67, 0x99, 0x5a, 0xea, 0x85, 0x8d, 0x64,
+                0xe7, 0x78, 0x9f, 0xf3, 0x06, 0x36, 0x95, 0x77, 0x22, 0x81, 0x80, 0x32, 0x6a, 0x5b,
+                0x0a, 0xf4, 0x75, 0xe2, 0x7a, 0x54, 0xb2, 0x07, 0xb4, 0x1f, 0x92, 0xe3, 0x76, 0x17,
+                0x0e, 0x3f, 0xb0, 0x05, 0x02, 0x82, 0x61, 0xc9, 0x9c, 0x2d, 0xbd, 0x0e, 0xed, 0xee,
+                0x87, 0x1c, 0x1c, 0x0f, 0x48, 0xb8, 0xe9, 0xb8, 0xe4, 0xbe, 0x77, 0xd1, 0xb7, 0x37,
+                0xfe, 0x21, 0xf0, 0xfa, 0x5a, 0x18, 0xeb, 0xb5, 0x27, 0x55, 0xb5, 0xa6, 0xcf, 0x61,
+                0x30, 0xfb, 0x56, 0x94, 0x4c, 0xfa, 0xb8, 0x75, 0x27, 0xc2, 0x50, 0xd1, 0x13, 0xb2,
+                0x9b, 0xca, 0xc9, 0xaa, 0xa1, 0x0c, 0x2e, 0x7d, 0xe4, 0x15, 0xed, 0xb0, 0x80, 0x6c,
+                0x6d, 0xa0, 0x30, 0x20, 0xa1, 0x34, 0xca, 0x7e, 0xcd, 0xc8, 0xda, 0x1b, 0xd5, 0x7a,
+                0x37, 0xf5, 0x5a, 0x46, 0x94, 0x0b, 0x45, 0xb2, 0x41, 0xb1, 0xc1, 0x6e, 0xe1, 0x00,
+                0x92, 0x7d, 0x1b, 0xd8, 0x60, 0xd4, 0x45, 0xa9, 0xde, 0x50, 0xd4, 0xc3, 0x84, 0xd6,
+                0xe1, 0xd0, 0x01, 0x08, 0x02, 0x6c, 0x0e, 0xa5, 0xeb, 0xbf, 0x0b, 0x72, 0xfb, 0xf5,
+                0xc3, 0x70, 0xbc, 0xe1, 0x8d, 0x3a, 0xcb, 0xc4, 0x65, 0x99, 0x09, 0x9b, 0xaa, 0xe1,
+                0xd8, 0x02, 0xf7, 0x73,
+            ],
+            c_enc: [
+                0x45, 0x6b, 0x2b, 0xb8, 0x03, 0xc7, 0xdf, 0xf7, 0xac, 0x82, 0xe6, 0x42, 0xf4, 0xd8,
+                0x46, 0x1e, 0x0b, 0x7a, 0x3b, 0x3c, 0x95, 0xa4, 0xcb, 0xf1, 0xc0, 0x6f, 0xeb, 0x93,
+                0xa1, 0x8b, 0xeb, 0xa2, 0x9f, 0x2b, 0x8f, 0x12, 0x1a, 0x61, 0x5c, 0xa5, 0x3f, 0xc2,
+                0xa7, 0x60, 0x63, 0xb8, 0x0d, 0xaa, 0x71, 0x01, 0x8b, 0x66, 0x3b, 0x7c, 0x46, 0x6d,
+                0xb2, 0x63, 0xf9, 0x04, 0x27, 0xd0, 0x11, 0x7f, 0x0b, 0x89, 0x90, 0x6e, 0x98, 0x41,
+                0x7f, 0x3e, 0xe8, 0x5a, 0xcc, 0xed, 0xb1, 0x41, 0xfb, 0x10, 0x26, 0xa3, 0xb3, 0xf7,
+                0xa4, 0xfd, 0x10, 0x24, 0xf9, 0xc8, 0x08, 0x9a, 0x2e, 0xbe, 0x1a, 0x27, 0x82, 0xf8,
+                0xb0, 0xbf, 0x5c, 0x40, 0xb6, 0xd5, 0x2f, 0xfe, 0x38, 0x37, 0xf4, 0xe4, 0x42, 0x52,
+                0x13, 0x41, 0xc2, 0x4d, 0x3e, 0x89, 0x55, 0x95, 0x08, 0x86, 0x27, 0x85, 0xea, 0x63,
+                0x56, 0xb4, 0xe4, 0x66, 0xc3, 0x25, 0x9c, 0xeb, 0x0d, 0x28, 0x2e, 0x07, 0xbb, 0x35,
+                0xdc, 0xf2, 0xd9, 0xa8, 0x62, 0xc7, 0x47, 0x58, 0xd3, 0x83, 0xaa, 0xa2, 0x82, 0xfa,
+                0xc4, 0xfa, 0xcf, 0xe5, 0x39, 0xe4, 0xe1, 0xbb, 0xd5, 0x46, 0x8a, 0xcf, 0x25, 0xec,
+                0x2b, 0x4b, 0xa5, 0x11, 0x9d, 0xea, 0xed, 0x01, 0x1d, 0x4f, 0x30, 0xb0, 0xc5, 0x82,
+                0x01, 0xfe, 0xe1, 0xc6, 0xe4, 0xf6, 0xb5, 0x2e, 0x41, 0xad, 0xfa, 0x5d, 0x6f, 0xda,
+                0x94, 0xa5, 0x23, 0x20, 0xe8, 0x3b, 0x80, 0xc6, 0xfc, 0xee, 0xb8, 0x97, 0x89, 0xd8,
+                0x79, 0x94, 0xb7, 0xa0, 0x16, 0xec, 0x64, 0xe4, 0x70, 0x78, 0x07, 0xf8, 0xf2, 0xd2,
+                0x30, 0x63, 0x10, 0x74, 0x10, 0x9f, 0xc5, 0x9d, 0xe3, 0xe4, 0x37, 0x10, 0xca, 0xe8,
+                0x9c, 0xb1, 0x89, 0xa0, 0xa4, 0x64, 0x8b, 0x37, 0x54, 0x5d, 0x25, 0x49, 0x47, 0x95,
+                0xa8, 0xdf, 0x3f, 0xfc, 0x7a, 0x3a, 0x21, 0xe3, 0xb9, 0x1c, 0x95, 0x96, 0xe0, 0xd5,
+                0x10, 0x5d, 0xf8, 0xad, 0xa9, 0xcf, 0xe9, 0x31, 0x10, 0xb1, 0x9f, 0xf2, 0xaf, 0x83,
+                0x03, 0xb5, 0xd2, 0x79, 0x3f, 0xff, 0xd0, 0x4d, 0x8e, 0x02, 0xf7, 0xb9, 0x30, 0x14,
+                0x80, 0xdf, 0xd9, 0x35, 0x50, 0x2d, 0x98, 0xe2, 0xf3, 0xc3, 0xe9, 0xe9, 0x5e, 0x64,
+                0xe4, 0x96, 0xeb, 0x7d, 0x15, 0xcf, 0x2c, 0x70, 0x11, 0x94, 0xe6, 0x25, 0xde, 0x52,
+                0x1a, 0x02, 0x55, 0x20, 0xdf, 0x67, 0xac, 0x2b, 0xa4, 0x3b, 0x9c, 0x4a, 0x6d, 0x77,
+                0xb8, 0x6a, 0x40, 0x18, 0x2d, 0x70, 0x31, 0x8b, 0x8f, 0xa3, 0x48, 0xb1, 0x86, 0x47,
+                0xd8, 0x4e, 0x0e, 0xe5, 0xf0, 0x56, 0x07, 0xa2, 0xb8, 0xf2, 0x69, 0xe1, 0x86, 0xc7,
+                0x94, 0x28, 0xbe, 0xa6, 0x7c, 0xbf, 0x71, 0xda, 0xcc, 0x98, 0xe9, 0xcc, 0x72, 0x5e,
+                0x50, 0x53, 0xa4, 0x40, 0xca, 0xa6, 0xca, 0xd2, 0x41, 0xa5, 0x06, 0x28, 0x18, 0x3a,
+                0xe9, 0xef, 0x9f, 0x0c, 0xbd, 0xfe, 0xf7, 0x0a, 0x42, 0xe5, 0xb7, 0x97, 0xbc, 0x99,
+                0xd9, 0x22, 0xfc, 0xc2, 0x81, 0x37, 0x84, 0xea, 0xe4, 0x48, 0x60, 0x18, 0x0e, 0xf8,
+                0xe8, 0x1f, 0x7b, 0x94, 0xf2, 0xad, 0x62, 0x12, 0x8b, 0xb6, 0x1f, 0x10, 0xd5, 0x0c,
+                0x9c, 0xad, 0x9d, 0x80, 0x48, 0xd9, 0x78, 0x01, 0x8a, 0x1f, 0x3b, 0xc9, 0x24, 0x28,
+                0xf8, 0x9d, 0x7d, 0xdc, 0xe5, 0x45, 0x4b, 0xc4, 0x49, 0x1f, 0xb4, 0xc2, 0xcb, 0x66,
+                0x88, 0x35, 0xb2, 0x2f, 0xcc, 0x4d, 0xf2, 0x08, 0xf2, 0x16, 0x64, 0xf7, 0x12, 0x94,
+                0xc5, 0xce, 0xd3, 0x3c, 0x8e, 0x11, 0xd4, 0x25, 0xd1, 0x39, 0x85, 0x23, 0xc2, 0x79,
+                0x88, 0x3a, 0x38, 0x2f, 0x70, 0xfe, 0xfe, 0xc8, 0x25, 0xc5, 0xe3, 0x50, 0x85, 0xaf,
+                0x82, 0xd0, 0xa0, 0xa9, 0xbf, 0x45, 0x11, 0x65, 0x0a, 0x2b, 0xfb, 0xf0, 0xb2, 0x18,
+                0x82, 0x10, 0x5e, 0xc6, 0xe5, 0x99, 0x74, 0xd8, 0xd6, 0xce, 0x73, 0x07, 0x8f, 0xb4,
+                0xb5, 0x63, 0x4e, 0x85, 0xd7, 0xe2, 0x0a, 0x97, 0xff, 0xb6, 0x5d, 0x4f, 0x5e, 0xaf,
+                0x42, 0x63, 0x9b, 0x09, 0xf5, 0xed, 0xa5, 0x9a, 0xb1, 0x04, 0x97, 0x69, 0x95, 0x41,
+                0xd1, 0xc8, 0x22, 0x8e, 0xb5, 0xdf, 0x47, 0xa6, 0x67, 0xc4, 0x6d, 0x4c, 0xff, 0xeb,
+                0xfe, 0x3f, 0xbb, 0x0a, 0x4e, 0x48,
+            ],
+            ock: [
+                0x17, 0xeb, 0xb4, 0x82, 0xdf, 0x8d, 0x13, 0xc2, 0x0d, 0x9b, 0x4a, 0x03, 0x9f, 0x40,
+                0x5a, 0x93, 0x69, 0x8a, 0xc2, 0x24, 0xf3, 0xea, 0x03, 0xfb, 0x55, 0x8d, 0x5b, 0x53,
+                0x11, 0x46, 0xfb, 0xea,
+            ],
+            op: [
+                0x05, 0x82, 0x53, 0xd4, 0x85, 0x76, 0x44, 0x88, 0x5e, 0x26, 0xa9, 0x09, 0xc8, 0x38,
+                0x59, 0x25, 0x23, 0x5a, 0x75, 0x29, 0x85, 0x44, 0x6e, 0x11, 0x69, 0x5f, 0x36, 0xc2,
+                0xe6, 0x84, 0x45, 0xbb, 0x05, 0x18, 0xdd, 0xc0, 0xc4, 0x7b, 0x7f, 0x77, 0xed, 0xcd,
+                0x39, 0x16, 0x0f, 0xe5, 0x67, 0x75, 0x1e, 0xb8, 0x4a, 0xa2, 0x1d, 0x33, 0xa6, 0x90,
+                0xe0, 0xd2, 0x9b, 0x35, 0x9a, 0xc4, 0xfa, 0x2c,
+            ],
+            c_out: [
+                0x2d, 0x76, 0x57, 0x79, 0x67, 0x44, 0x5f, 0xb9, 0x17, 0xee, 0x72, 0xd3, 0x2d, 0x4b,
+                0x75, 0x3b, 0x25, 0x10, 0xd8, 0x05, 0x5d, 0xec, 0x8b, 0xf1, 0x22, 0x0a, 0x75, 0xf0,
+                0x65, 0xbd, 0x47, 0xe2, 0xcc, 0xb6, 0x03, 0x98, 0x84, 0x50, 0x23, 0x1b, 0xd3, 0x1c,
+                0x15, 0x6f, 0xf2, 0xa7, 0x2a, 0xfd, 0x4a, 0x96, 0x0b, 0x6f, 0x6a, 0x78, 0x84, 0x65,
+                0x13, 0x51, 0xe2, 0x4b, 0x47, 0x02, 0x87, 0xd5, 0x83, 0xba, 0x69, 0x71, 0x18, 0xec,
+                0x07, 0xf6, 0x59, 0x2c, 0x4c, 0xd7, 0xcd, 0x6a, 0xc7, 0x7e,
+            ],
+            note_type: Some([
+                0xa9, 0x71, 0x5e, 0x65, 0xaf, 0x82, 0x67, 0x37, 0x3d, 0x34, 0x51, 0x67, 0x4f, 0xf0,
+                0x84, 0xef, 0xd9, 0x2c, 0xcf, 0x3b, 0xcc, 0x7a, 0xca, 0x14, 0x67, 0xb6, 0x32, 0x7e,
+                0x4f, 0x95, 0x22, 0xb2,
+            ]),
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xb6, 0x6c, 0x73, 0x33, 0x75, 0xda, 0xc6, 0xff, 0xcc, 0x98, 0xf5, 0x0f, 0x3a, 0xf0,
+                0xb0, 0x76, 0x05, 0x53, 0xfe, 0x98, 0xed, 0x61, 0xff, 0xa4, 0x93, 0xea, 0xe6, 0x8d,
+                0xf0, 0xb3, 0x33, 0x4e, 0xe8, 0xd4, 0x39, 0x37, 0xb7, 0xdb, 0x8e, 0xbb, 0xfe, 0xbd,
+                0x54, 0x8a, 0x28, 0x02, 0x51, 0xea, 0x87, 0xaa, 0x5d, 0x8c, 0xa5, 0x36, 0x86, 0x1b,
+                0x38, 0x4f, 0x20, 0x86, 0x9f, 0x8f, 0xe8, 0x01,
+            ],
+            ovk: [
+                0xe9, 0x4c, 0x15, 0x24, 0x5f, 0x1a, 0x95, 0x88, 0x40, 0xba, 0x3f, 0x38, 0x0a, 0x4d,
+                0x20, 0xf1, 0x18, 0x4e, 0x77, 0x82, 0x7d, 0xe3, 0xff, 0x8f, 0x3d, 0x73, 0x45, 0x9a,
+                0xfe, 0x24, 0x1f, 0x72,
+            ],
+            default_d: [
+                0x7c, 0x51, 0xbe, 0xc6, 0xee, 0x28, 0x46, 0xfd, 0x85, 0x12, 0x64,
+            ],
+            default_pk_d: [
+                0x7a, 0xfc, 0xa0, 0x5d, 0x04, 0x2c, 0x84, 0x3e, 0xec, 0xdc, 0x37, 0x24, 0x10, 0x52,
+                0xc4, 0x6f, 0x93, 0xd4, 0xaf, 0xd5, 0xc9, 0xb0, 0x4d, 0x2b, 0x26, 0x4e, 0x81, 0x0f,
+                0x25, 0xc8, 0xd6, 0xae,
+            ],
+            v: 16065731808124965111,
+            rseed: [
+                0x26, 0xf2, 0x84, 0x38, 0xe5, 0x78, 0x2f, 0x45, 0xac, 0x1d, 0x07, 0xf6, 0xf6, 0xf5,
+                0xed, 0x73, 0x74, 0x1d, 0x57, 0x85, 0x83, 0x7a, 0x6b, 0x84, 0x4b, 0x47, 0x47, 0x75,
+                0x71, 0x8c, 0x29, 0xdd,
+            ],
+            memo: [
+                0xff, 0x99, 0x08, 0x4e, 0x9f, 0x88, 0xef, 0x15, 0x3a, 0x83, 0x29, 0xf5, 0x32, 0xa6,
+                0x90, 0x17, 0xdc, 0x3a, 0x97, 0xed, 0x75, 0x43, 0x67, 0x72, 0x30, 0x98, 0xe5, 0x76,
+                0x58, 0x40, 0xb0, 0x22, 0x89, 0x72, 0x44, 0x74, 0x5f, 0xbb, 0xbb, 0x30, 0xa7, 0xcb,
+                0x54, 0xfa, 0x05, 0x11, 0x16, 0x6e, 0x95, 0x44, 0x12, 0x20, 0x00, 0x61, 0x0b, 0xd2,
+                0xaa, 0xcb, 0xd8, 0x23, 0x25, 0xa5, 0x9b, 0x95, 0x15, 0x4e, 0xcd, 0x82, 0xc8, 0x8d,
+                0x23, 0xab, 0xd1, 0xe2, 0x07, 0x70, 0xff, 0xb8, 0xaa, 0xbf, 0x83, 0xfc, 0x07, 0x34,
+                0x96, 0x4c, 0xcd, 0x41, 0x1d, 0x1c, 0x93, 0x57, 0x14, 0xe2, 0x4a, 0xab, 0x56, 0x6f,
+                0x4f, 0x08, 0x42, 0x40, 0x14, 0xc4, 0xec, 0xa9, 0x1b, 0x59, 0x0f, 0x08, 0x2b, 0x47,
+                0x3f, 0x36, 0x1c, 0x87, 0x41, 0x5d, 0x37, 0xbd, 0x20, 0xd7, 0x0f, 0xd0, 0xb5, 0x2b,
+                0x6d, 0xdf, 0x18, 0x65, 0xf7, 0x66, 0x70, 0x2e, 0x32, 0xb0, 0x5b, 0x3c, 0xf1, 0x63,
+                0x0e, 0xe8, 0x59, 0x7a, 0xae, 0x19, 0x63, 0x3f, 0x35, 0x16, 0xa8, 0x55, 0x5a, 0xc5,
+                0xbe, 0x32, 0xc6, 0x75, 0xbe, 0x18, 0x17, 0xef, 0xbf, 0xfd, 0x93, 0x69, 0x04, 0x1a,
+                0x08, 0x9c, 0x28, 0x3f, 0x19, 0x64, 0x99, 0x68, 0xc2, 0x49, 0x8c, 0xde, 0x56, 0xf5,
+                0x00, 0x43, 0x4f, 0x28, 0x0d, 0x77, 0xa9, 0xc6, 0x2e, 0x43, 0xcb, 0xd3, 0xf1, 0x36,
+                0xa4, 0xc6, 0xa0, 0x0a, 0x43, 0xe6, 0xed, 0x53, 0x0c, 0xb2, 0xe8, 0xae, 0x83, 0x88,
+                0x60, 0xad, 0xc8, 0x8a, 0xac, 0xc7, 0xbd, 0x6a, 0x00, 0xae, 0x0c, 0x19, 0xff, 0x45,
+                0x33, 0xa4, 0x85, 0xef, 0xde, 0x08, 0x2b, 0x5f, 0x4d, 0x1f, 0x7a, 0x8e, 0xbe, 0x7e,
+                0xd8, 0x2b, 0x7b, 0x05, 0xa8, 0xcf, 0xe1, 0xe3, 0x73, 0x45, 0x9f, 0x1b, 0xdc, 0xbf,
+                0x95, 0x25, 0x74, 0x7e, 0x8c, 0x95, 0x08, 0xa5, 0x55, 0xfa, 0xcb, 0x79, 0x87, 0x40,
+                0xe0, 0xbd, 0xf9, 0x94, 0xd9, 0x73, 0x9b, 0xbe, 0x55, 0x38, 0xa0, 0xae, 0x0f, 0x07,
+                0x6c, 0x58, 0x2c, 0x0f, 0x5b, 0xa8, 0x78, 0xb9, 0x9b, 0x82, 0x49, 0xdb, 0x1d, 0x7e,
+                0x95, 0x05, 0x6c, 0x98, 0xaf, 0x08, 0x3d, 0x98, 0xcb, 0x0e, 0xd9, 0xe3, 0xf7, 0x43,
+                0x6e, 0x1c, 0x76, 0x43, 0x76, 0x6f, 0x96, 0x6b, 0x83, 0xe9, 0x99, 0x20, 0x6e, 0xbd,
+                0x13, 0x93, 0xb9, 0xb2, 0xa7, 0xf4, 0x14, 0x48, 0x0f, 0xa0, 0x17, 0x48, 0x00, 0x69,
+                0xf8, 0x5c, 0x77, 0x49, 0xc4, 0x35, 0xae, 0x2f, 0xba, 0x2d, 0xdc, 0x10, 0x38, 0xd5,
+                0x47, 0xd8, 0x48, 0x54, 0x81, 0x7e, 0xf3, 0x96, 0x35, 0xc2, 0x98, 0x27, 0xaa, 0xd8,
+                0x67, 0x26, 0xc9, 0xad, 0xe3, 0xb2, 0x65, 0xb9, 0x08, 0x6c, 0x8b, 0x5b, 0x75, 0xef,
+                0x56, 0xfe, 0x4b, 0xd8, 0xb4, 0xd6, 0x28, 0x93, 0x89, 0x5b, 0x3f, 0xd2, 0x73, 0x4f,
+                0xda, 0xc4, 0x64, 0x15, 0x6d, 0x7e, 0x5e, 0xbc, 0x7e, 0xcf, 0x1d, 0x83, 0xb8, 0x6f,
+                0x65, 0x96, 0x37, 0xe3, 0xb1, 0x42, 0xc1, 0x64, 0x96, 0x3b, 0x8c, 0xdc, 0xf4, 0xba,
+                0x4f, 0x40, 0x35, 0xdf, 0xfc, 0x5a, 0x78, 0x94, 0x58, 0x84, 0x77, 0x81, 0x91, 0x8a,
+                0xc7, 0x2f, 0xc1, 0x8b, 0xbb, 0xf5, 0x11, 0x00, 0x32, 0xe6, 0x6d, 0x75, 0xb3, 0x17,
+                0x1e, 0xf4, 0xb5, 0x13, 0x29, 0x01, 0x64, 0xa7, 0x7b, 0x42, 0xb0, 0xa4, 0xcf, 0xb8,
+                0x96, 0x39, 0xab, 0x23, 0x84, 0x5e, 0x1a, 0xa2, 0xa4, 0x52, 0xf3, 0x73, 0x1c, 0x8c,
+                0xb6, 0x50, 0x82, 0xa6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ],
+            cv_net: [
+                0x54, 0xb6, 0x99, 0x64, 0x13, 0x6b, 0x63, 0xd1, 0x7d, 0x62, 0x44, 0x1a, 0x69, 0x37,
+                0x13, 0x9d, 0x2c, 0xe1, 0x4b, 0xb5, 0x5c, 0x42, 0x07, 0xfe, 0x74, 0xd7, 0x70, 0x83,
+                0x53, 0x51, 0x5b, 0xa8,
+            ],
+            rho: [
+                0x27, 0x3c, 0x68, 0xd1, 0x9c, 0xda, 0xa8, 0x62, 0x8b, 0xac, 0x37, 0xa2, 0xd4, 0x2c,
+                0x51, 0x1c, 0x9b, 0xab, 0x65, 0xb6, 0xd8, 0xd5, 0xc5, 0xbd, 0x1e, 0x32, 0x77, 0x1a,
+                0xb6, 0xf6, 0x4c, 0x26,
+            ],
+            cmx: [
+                0x40, 0x8f, 0x59, 0x4f, 0xdd, 0xc5, 0x0c, 0x67, 0xf5, 0x47, 0xe1, 0xeb, 0x3e, 0xa2,
+                0x99, 0xa3, 0x1f, 0x69, 0xf5, 0x7f, 0xc9, 0x92, 0x03, 0x01, 0x42, 0x90, 0x35, 0xa6,
+                0xc2, 0x49, 0x79, 0x1a,
+            ],
+            esk: [
+                0xcb, 0xfc, 0x51, 0x10, 0xff, 0x2f, 0xe9, 0xc5, 0xd5, 0x9e, 0xef, 0x08, 0xbd, 0xf6,
+                0xf8, 0x57, 0xe7, 0x1a, 0xab, 0x45, 0x0e, 0x6c, 0xd6, 0x13, 0xf5, 0x3b, 0x57, 0xc3,
+                0x45, 0xa9, 0x87, 0x2f,
+            ],
+            ephemeral_key: [
+                0xa5, 0xc8, 0x0a, 0x29, 0xf2, 0xec, 0xdd, 0xd7, 0x01, 0x96, 0xef, 0x45, 0x9e, 0xd5,
+                0x03, 0xc4, 0xb3, 0xc2, 0x22, 0x8d, 0x10, 0xcc, 0xbc, 0xad, 0x9a, 0x28, 0x23, 0x30,
+                0x07, 0x7b, 0xca, 0x0c,
+            ],
+            shared_secret: [
+                0x37, 0x14, 0x15, 0xfc, 0x1e, 0x98, 0x42, 0xa1, 0x26, 0xa3, 0x7a, 0xa7, 0x7b, 0x8f,
+                0x0f, 0x1a, 0xb6, 0x48, 0xa3, 0xf7, 0x43, 0x57, 0x34, 0x89, 0x6f, 0x07, 0x59, 0x52,
+                0xe7, 0xd1, 0x60, 0x17,
+            ],
+            k_enc: [
+                0xd7, 0x36, 0xf0, 0x3c, 0x81, 0x2d, 0x9b, 0xf9, 0x54, 0xff, 0xd2, 0x41, 0x84, 0x07,
+                0xf3, 0x36, 0xa5, 0xf9, 0x69, 0x8b, 0x62, 0x85, 0x23, 0x2f, 0x5c, 0x85, 0xf0, 0xd1,
+                0x1d, 0x5e, 0x9d, 0x0a,
+            ],
+            p_enc: [
+                0x03, 0x7c, 0x51, 0xbe, 0xc6, 0xee, 0x28, 0x46, 0xfd, 0x85, 0x12, 0x64, 0xf7, 0x90,
+                0xfb, 0xa7, 0xf5, 0xf1, 0xf4, 0xde, 0x26, 0xf2, 0x84, 0x38, 0xe5, 0x78, 0x2f, 0x45,
+                0xac, 0x1d, 0x07, 0xf6, 0xf6, 0xf5, 0xed, 0x73, 0x74, 0x1d, 0x57, 0x85, 0x83, 0x7a,
+                0x6b, 0x84, 0x4b, 0x47, 0x47, 0x75, 0x71, 0x8c, 0x29, 0xdd, 0xdf, 0xfd, 0x79, 0xa9,
+                0xde, 0xd0, 0x5e, 0x88, 0x89, 0x58, 0x19, 0x9e, 0xea, 0x45, 0x01, 0xe2, 0x99, 0x0a,
+                0x53, 0xa5, 0xcd, 0x2a, 0x46, 0xa4, 0x01, 0x57, 0x65, 0x88, 0xfd, 0x7d, 0x05, 0x8a,
+                0xff, 0x99, 0x08, 0x4e, 0x9f, 0x88, 0xef, 0x15, 0x3a, 0x83, 0x29, 0xf5, 0x32, 0xa6,
+                0x90, 0x17, 0xdc, 0x3a, 0x97, 0xed, 0x75, 0x43, 0x67, 0x72, 0x30, 0x98, 0xe5, 0x76,
+                0x58, 0x40, 0xb0, 0x22, 0x89, 0x72, 0x44, 0x74, 0x5f, 0xbb, 0xbb, 0x30, 0xa7, 0xcb,
+                0x54, 0xfa, 0x05, 0x11, 0x16, 0x6e, 0x95, 0x44, 0x12, 0x20, 0x00, 0x61, 0x0b, 0xd2,
+                0xaa, 0xcb, 0xd8, 0x23, 0x25, 0xa5, 0x9b, 0x95, 0x15, 0x4e, 0xcd, 0x82, 0xc8, 0x8d,
+                0x23, 0xab, 0xd1, 0xe2, 0x07, 0x70, 0xff, 0xb8, 0xaa, 0xbf, 0x83, 0xfc, 0x07, 0x34,
+                0x96, 0x4c, 0xcd, 0x41, 0x1d, 0x1c, 0x93, 0x57, 0x14, 0xe2, 0x4a, 0xab, 0x56, 0x6f,
+                0x4f, 0x08, 0x42, 0x40, 0x14, 0xc4, 0xec, 0xa9, 0x1b, 0x59, 0x0f, 0x08, 0x2b, 0x47,
+                0x3f, 0x36, 0x1c, 0x87, 0x41, 0x5d, 0x37, 0xbd, 0x20, 0xd7, 0x0f, 0xd0, 0xb5, 0x2b,
+                0x6d, 0xdf, 0x18, 0x65, 0xf7, 0x66, 0x70, 0x2e, 0x32, 0xb0, 0x5b, 0x3c, 0xf1, 0x63,
+                0x0e, 0xe8, 0x59, 0x7a, 0xae, 0x19, 0x63, 0x3f, 0x35, 0x16, 0xa8, 0x55, 0x5a, 0xc5,
+                0xbe, 0x32, 0xc6, 0x75, 0xbe, 0x18, 0x17, 0xef, 0xbf, 0xfd, 0x93, 0x69, 0x04, 0x1a,
+                0x08, 0x9c, 0x28, 0x3f, 0x19, 0x64, 0x99, 0x68, 0xc2, 0x49, 0x8c, 0xde, 0x56, 0xf5,
+                0x00, 0x43, 0x4f, 0x28, 0x0d, 0x77, 0xa9, 0xc6, 0x2e, 0x43, 0xcb, 0xd3, 0xf1, 0x36,
+                0xa4, 0xc6, 0xa0, 0x0a, 0x43, 0xe6, 0xed, 0x53, 0x0c, 0xb2, 0xe8, 0xae, 0x83, 0x88,
+                0x60, 0xad, 0xc8, 0x8a, 0xac, 0xc7, 0xbd, 0x6a, 0x00, 0xae, 0x0c, 0x19, 0xff, 0x45,
+                0x33, 0xa4, 0x85, 0xef, 0xde, 0x08, 0x2b, 0x5f, 0x4d, 0x1f, 0x7a, 0x8e, 0xbe, 0x7e,
+                0xd8, 0x2b, 0x7b, 0x05, 0xa8, 0xcf, 0xe1, 0xe3, 0x73, 0x45, 0x9f, 0x1b, 0xdc, 0xbf,
+                0x95, 0x25, 0x74, 0x7e, 0x8c, 0x95, 0x08, 0xa5, 0x55, 0xfa, 0xcb, 0x79, 0x87, 0x40,
+                0xe0, 0xbd, 0xf9, 0x94, 0xd9, 0x73, 0x9b, 0xbe, 0x55, 0x38, 0xa0, 0xae, 0x0f, 0x07,
+                0x6c, 0x58, 0x2c, 0x0f, 0x5b, 0xa8, 0x78, 0xb9, 0x9b, 0x82, 0x49, 0xdb, 0x1d, 0x7e,
+                0x95, 0x05, 0x6c, 0x98, 0xaf, 0x08, 0x3d, 0x98, 0xcb, 0x0e, 0xd9, 0xe3, 0xf7, 0x43,
+                0x6e, 0x1c, 0x76, 0x43, 0x76, 0x6f, 0x96, 0x6b, 0x83, 0xe9, 0x99, 0x20, 0x6e, 0xbd,
+                0x13, 0x93, 0xb9, 0xb2, 0xa7, 0xf4, 0x14, 0x48, 0x0f, 0xa0, 0x17, 0x48, 0x00, 0x69,
+                0xf8, 0x5c, 0x77, 0x49, 0xc4, 0x35, 0xae, 0x2f, 0xba, 0x2d, 0xdc, 0x10, 0x38, 0xd5,
+                0x47, 0xd8, 0x48, 0x54, 0x81, 0x7e, 0xf3, 0x96, 0x35, 0xc2, 0x98, 0x27, 0xaa, 0xd8,
+                0x67, 0x26, 0xc9, 0xad, 0xe3, 0xb2, 0x65, 0xb9, 0x08, 0x6c, 0x8b, 0x5b, 0x75, 0xef,
+                0x56, 0xfe, 0x4b, 0xd8, 0xb4, 0xd6, 0x28, 0x93, 0x89, 0x5b, 0x3f, 0xd2, 0x73, 0x4f,
+                0xda, 0xc4, 0x64, 0x15, 0x6d, 0x7e, 0x5e, 0xbc, 0x7e, 0xcf, 0x1d, 0x83, 0xb8, 0x6f,
+                0x65, 0x96, 0x37, 0xe3, 0xb1, 0x42, 0xc1, 0x64, 0x96, 0x3b, 0x8c, 0xdc, 0xf4, 0xba,
+                0x4f, 0x40, 0x35, 0xdf, 0xfc, 0x5a, 0x78, 0x94, 0x58, 0x84, 0x77, 0x81, 0x91, 0x8a,
+                0xc7, 0x2f, 0xc1, 0x8b, 0xbb, 0xf5, 0x11, 0x00, 0x32, 0xe6, 0x6d, 0x75, 0xb3, 0x17,
+                0x1e, 0xf4, 0xb5, 0x13, 0x29, 0x01, 0x64, 0xa7, 0x7b, 0x42, 0xb0, 0xa4, 0xcf, 0xb8,
+                0x96, 0x39, 0xab, 0x23, 0x84, 0x5e, 0x1a, 0xa2, 0xa4, 0x52, 0xf3, 0x73, 0x1c, 0x8c,
+                0xb6, 0x50, 0x82, 0xa6,
+            ],
+            c_enc: [
+                0xfc, 0x90, 0xcb, 0xe1, 0xcd, 0x9f, 0x59, 0x9a, 0x1a, 0x24, 0xc7, 0xa3, 0xea, 0xf6,
+                0x07, 0xd9, 0x13, 0xbf, 0x48, 0xbd, 0xc1, 0xa4, 0x6d, 0xf7, 0xb1, 0x74, 0x7f, 0x12,
+                0x60, 0x64, 0x49, 0x4b, 0xf5, 0x39, 0x61, 0xe9, 0xa5, 0xa2, 0xb9, 0x69, 0x80, 0x57,
+                0x63, 0x44, 0x2e, 0x2c, 0x38, 0x8d, 0x21, 0x2d, 0x74, 0x84, 0x6e, 0x57, 0x27, 0x87,
+                0x2d, 0x06, 0x3f, 0xc9, 0x94, 0xa4, 0x4f, 0x9e, 0xb6, 0x55, 0x25, 0xd6, 0x8f, 0x98,
+                0x24, 0xa6, 0x03, 0x75, 0xfe, 0x43, 0xc0, 0x5f, 0x08, 0xfe, 0x45, 0x42, 0xa7, 0xe4,
+                0x0c, 0x03, 0x8d, 0xe7, 0x10, 0x85, 0x01, 0x17, 0x95, 0x1b, 0x9a, 0x32, 0x1e, 0xea,
+                0x4f, 0x8c, 0x91, 0xc0, 0x1d, 0x39, 0xdb, 0xb5, 0xd4, 0x12, 0x40, 0xf8, 0xb1, 0xb1,
+                0xdb, 0xb3, 0x3f, 0x45, 0x87, 0x87, 0xdb, 0x8c, 0xda, 0x06, 0x9b, 0x64, 0x5a, 0x76,
+                0x38, 0xc2, 0xec, 0xca, 0xd3, 0xd9, 0xa7, 0x39, 0xd6, 0x4c, 0x9a, 0xd5, 0xd5, 0xb3,
+                0xa0, 0x24, 0x55, 0xa4, 0xec, 0xd6, 0x96, 0x7c, 0xf3, 0xb3, 0x3b, 0xf0, 0x4e, 0xf6,
+                0xdd, 0x88, 0x10, 0xe1, 0x0c, 0x25, 0x86, 0xf7, 0x89, 0x32, 0x44, 0xea, 0x72, 0x80,
+                0xd1, 0x34, 0xcf, 0x37, 0xb3, 0xdc, 0x0c, 0x32, 0x82, 0x3b, 0x1a, 0x29, 0xc5, 0x0c,
+                0xa6, 0x48, 0x31, 0xd8, 0x4e, 0xbd, 0xf5, 0xe0, 0x1c, 0x14, 0xca, 0x36, 0x05, 0xbe,
+                0x02, 0xf1, 0x5f, 0x31, 0x57, 0x90, 0xf7, 0x4e, 0x20, 0x57, 0x7f, 0x92, 0x39, 0x51,
+                0x2f, 0xbd, 0xdd, 0x67, 0x63, 0x77, 0xae, 0x50, 0xc3, 0xfe, 0x71, 0xc9, 0x30, 0xa8,
+                0x29, 0x57, 0xd1, 0x54, 0x70, 0xeb, 0x1b, 0x55, 0xb2, 0x0c, 0xe5, 0x02, 0x35, 0x64,
+                0xfe, 0xa7, 0xe1, 0x81, 0xbe, 0x04, 0xa9, 0x33, 0xa7, 0xa3, 0xa1, 0x11, 0x89, 0x4d,
+                0xec, 0xf7, 0x2a, 0x56, 0x54, 0xcb, 0x4e, 0xac, 0x32, 0xe1, 0xd5, 0x96, 0xad, 0x99,
+                0x1a, 0x2f, 0x4c, 0x62, 0xe8, 0xe2, 0x82, 0x57, 0x13, 0x7b, 0xcb, 0xa5, 0x03, 0xdc,
+                0x91, 0xed, 0x9e, 0x90, 0xb3, 0x08, 0xcd, 0xa5, 0xcc, 0xcc, 0xc9, 0xd1, 0x4e, 0xa6,
+                0xd0, 0x3b, 0x3d, 0xec, 0xa1, 0x57, 0xd5, 0x30, 0xde, 0x63, 0x1e, 0x1e, 0x45, 0x8f,
+                0x6a, 0x60, 0x8e, 0x1f, 0x9d, 0x57, 0x9b, 0x6e, 0xe6, 0x00, 0x5c, 0xd0, 0xa8, 0xc3,
+                0xe2, 0xdf, 0x89, 0x46, 0x8a, 0xcf, 0xb4, 0x36, 0xcb, 0x59, 0x84, 0x56, 0xf0, 0x38,
+                0x95, 0x5d, 0xc6, 0xb4, 0x07, 0xec, 0x33, 0x00, 0xa5, 0xcf, 0xcd, 0xc8, 0x45, 0x47,
+                0xe3, 0xef, 0xe9, 0xfc, 0xa1, 0x7e, 0xd2, 0xc2, 0x74, 0xf0, 0x03, 0x0b, 0x63, 0xcc,
+                0x42, 0xe2, 0x38, 0x94, 0xa5, 0xf2, 0x53, 0x66, 0xcb, 0xc3, 0xbf, 0xcb, 0x77, 0x2d,
+                0x04, 0x17, 0xf6, 0x24, 0x4b, 0x2f, 0xd8, 0x17, 0xc4, 0xc6, 0x79, 0x06, 0xc3, 0x38,
+                0x4d, 0x69, 0xd7, 0x93, 0xef, 0xca, 0x6e, 0x5d, 0x6a, 0xf2, 0x5e, 0x4e, 0xbc, 0x0f,
+                0x53, 0x56, 0xeb, 0x74, 0x28, 0x85, 0x19, 0xe8, 0xf4, 0x49, 0x38, 0xeb, 0xf9, 0xb2,
+                0x5b, 0xe5, 0x85, 0xe1, 0x35, 0x1f, 0x62, 0x59, 0x6c, 0x31, 0x79, 0xca, 0xe4, 0x5e,
+                0x75, 0x49, 0xd7, 0xfb, 0xb5, 0x91, 0x3b, 0xe9, 0xc3, 0xba, 0xa5, 0x7c, 0xab, 0x7c,
+                0xd4, 0xb5, 0x67, 0x12, 0x8d, 0x1b, 0xa5, 0x20, 0x31, 0xd7, 0xd5, 0xa5, 0xbd, 0x69,
+                0xde, 0x61, 0x4a, 0xbb, 0x8c, 0xa3, 0x8a, 0x94, 0x51, 0xcd, 0x1b, 0xad, 0xd9, 0x71,
+                0xb3, 0xf1, 0xb0, 0xb5, 0x0c, 0x7f, 0x21, 0xbf, 0xc4, 0x23, 0x04, 0xa4, 0xa5, 0x3e,
+                0x0d, 0x55, 0x92, 0x0d, 0xa0, 0x53, 0x27, 0x14, 0x79, 0x13, 0x45, 0xfb, 0x07, 0x4c,
+                0x66, 0xc4, 0xb7, 0xc9, 0x89, 0x28, 0x30, 0xf9, 0x62, 0x09, 0xb8, 0x1c, 0x26, 0xd1,
+                0x74, 0xf8, 0xa9, 0x33, 0xc3, 0x77, 0x9d, 0x97, 0x88, 0x55, 0x3f, 0x6e, 0xeb, 0x21,
+                0xf7, 0xdb, 0x57, 0x78, 0xf4, 0xf8, 0x17, 0x4c, 0xb4, 0x6f, 0x71, 0xfd, 0xdc, 0x4b,
+                0xe4, 0xd8, 0x70, 0x3e, 0xbf, 0xbc, 0xd2, 0xa7, 0x72, 0x89, 0xee, 0xfa, 0x72, 0x76,
+                0x56, 0x74, 0xdb, 0xf0, 0xe0, 0x65, 0xff, 0xcb, 0xf6, 0xbb, 0xa0, 0x18, 0x09, 0x1e,
+                0x49, 0xaa, 0x90, 0xe6, 0x02, 0xc8,
+            ],
+            ock: [
+                0x59, 0xf9, 0xcc, 0x26, 0x38, 0x4c, 0x6f, 0x73, 0xce, 0xa9, 0xb9, 0xe0, 0x94, 0x40,
+                0xf8, 0xf0, 0x4c, 0x40, 0x25, 0xb5, 0x59, 0x04, 0x42, 0x3c, 0x35, 0x39, 0xc6, 0x6c,
+                0x75, 0x11, 0x31, 0x23,
+            ],
+            op: [
+                0x7a, 0xfc, 0xa0, 0x5d, 0x04, 0x2c, 0x84, 0x3e, 0xec, 0xdc, 0x37, 0x24, 0x10, 0x52,
+                0xc4, 0x6f, 0x93, 0xd4, 0xaf, 0xd5, 0xc9, 0xb0, 0x4d, 0x2b, 0x26, 0x4e, 0x81, 0x0f,
+                0x25, 0xc8, 0xd6, 0xae, 0xcb, 0xfc, 0x51, 0x10, 0xff, 0x2f, 0xe9, 0xc5, 0xd5, 0x9e,
+                0xef, 0x08, 0xbd, 0xf6, 0xf8, 0x57, 0xe7, 0x1a, 0xab, 0x45, 0x0e, 0x6c, 0xd6, 0x13,
+                0xf5, 0x3b, 0x57, 0xc3, 0x45, 0xa9, 0x87, 0x2f,
+            ],
+            c_out: [
+                0x21, 0xe3, 0xf8, 0x97, 0xe1, 0xb1, 0x36, 0xe1, 0x74, 0xd7, 0xae, 0x88, 0xd7, 0x85,
+                0xa0, 0x61, 0xe6, 0x71, 0xef, 0xf1, 0x81, 0x98, 0x0a, 0x6f, 0xf5, 0x19, 0xb3, 0xbb,
+                0x6b, 0xbd, 0xaf, 0xea, 0x9d, 0xf9, 0x92, 0xbc, 0xaa, 0xc0, 0x2b, 0xdb, 0xcd, 0x4d,
+                0xb1, 0xc1, 0xd3, 0xf3, 0x2d, 0xef, 0xcd, 0xf7, 0xf4, 0xad, 0x54, 0x1b, 0x6b, 0xee,
+                0xe8, 0x27, 0xdd, 0x43, 0x89, 0xb8, 0x57, 0xd1, 0x6d, 0xb8, 0x24, 0xe7, 0x72, 0xba,
+                0x5a, 0xb5, 0xe2, 0x8d, 0xd6, 0xe9, 0x80, 0x82, 0x6b, 0xed,
+            ],
+            note_type: Some([
+                0xdf, 0xfd, 0x79, 0xa9, 0xde, 0xd0, 0x5e, 0x88, 0x89, 0x58, 0x19, 0x9e, 0xea, 0x45,
+                0x01, 0xe2, 0x99, 0x0a, 0x53, 0xa5, 0xcd, 0x2a, 0x46, 0xa4, 0x01, 0x57, 0x65, 0x88,
+                0xfd, 0x7d, 0x05, 0x8a,
+            ]),
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x8c, 0x45, 0x43, 0xe1, 0x1f, 0x9f, 0x30, 0x7e, 0xc9, 0x04, 0x31, 0x61, 0x29, 0x46,
+                0xfb, 0x01, 0x81, 0xb3, 0x6e, 0x1b, 0x52, 0xdb, 0x43, 0x1e, 0x6d, 0xf9, 0x38, 0x8c,
+                0xac, 0xd3, 0x08, 0xe8, 0x99, 0xd9, 0x3f, 0x70, 0xad, 0x2a, 0xea, 0xec, 0x99, 0x5e,
+                0xcc, 0xe1, 0x80, 0x1c, 0x61, 0x56, 0xe2, 0x3e, 0xc4, 0x1b, 0x1a, 0xe1, 0xcd, 0x2f,
+                0xd6, 0xe3, 0x9b, 0x69, 0x98, 0x2f, 0x46, 0x33,
+            ],
+            ovk: [
+                0x01, 0x76, 0xae, 0x33, 0x93, 0x25, 0xd5, 0xa5, 0x88, 0xda, 0x57, 0x96, 0xfa, 0xae,
+                0x5b, 0xab, 0x7c, 0x82, 0x97, 0x7c, 0x0f, 0xf7, 0x97, 0x09, 0x3e, 0x2c, 0x1f, 0x3a,
+                0xe8, 0x55, 0xf6, 0x5a,
+            ],
+            default_d: [
+                0x4e, 0x42, 0x6d, 0xf1, 0xad, 0x32, 0x48, 0x94, 0xbc, 0xa2, 0xc1,
+            ],
+            default_pk_d: [
+                0x84, 0xda, 0x49, 0x6b, 0x16, 0x0a, 0x81, 0x72, 0xc4, 0x8d, 0x76, 0xb4, 0xfb, 0x08,
+                0xbc, 0xab, 0xf4, 0x0f, 0xf1, 0xe4, 0x2c, 0x48, 0x66, 0x77, 0x57, 0x4f, 0x9e, 0xf8,
+                0x36, 0x34, 0xb0, 0x23,
+            ],
+            v: 3775288302605163507,
+            rseed: [
+                0x49, 0x56, 0xbb, 0xb1, 0x95, 0xa4, 0xfa, 0x66, 0xdc, 0x9c, 0xd5, 0x42, 0xc7, 0x6b,
+                0x91, 0x50, 0xc8, 0x4b, 0xf8, 0x90, 0x78, 0x99, 0x42, 0xf5, 0x5c, 0x20, 0x0b, 0x77,
+                0x3e, 0xcd, 0xd7, 0x99,
+            ],
+            memo: [
+                0xff, 0x2c, 0xff, 0x3e, 0xca, 0x24, 0xde, 0x3e, 0x09, 0x84, 0xe1, 0x0e, 0x68, 0xae,
+                0x38, 0x75, 0x34, 0xb9, 0x6c, 0xde, 0x37, 0x92, 0xf1, 0x35, 0xbf, 0x5f, 0x68, 0x78,
+                0x7d, 0x37, 0x0c, 0xa8, 0xc4, 0xc4, 0x07, 0x4d, 0xc5, 0xd6, 0x01, 0xae, 0x90, 0x49,
+                0x54, 0x37, 0xc3, 0xc2, 0xd4, 0x8a, 0x3d, 0x96, 0x66, 0x83, 0xac, 0x05, 0x16, 0x0b,
+                0x7a, 0x84, 0xea, 0xa7, 0xaa, 0xb7, 0x40, 0x09, 0xe5, 0x7a, 0x85, 0xf7, 0xbf, 0x68,
+                0xa2, 0xe4, 0x82, 0x00, 0x0f, 0x82, 0x9c, 0x54, 0x50, 0x73, 0xa1, 0x5d, 0x5c, 0xd0,
+                0xfc, 0xc5, 0x74, 0x39, 0xa4, 0x35, 0x0e, 0xaf, 0x09, 0x8d, 0xfb, 0x82, 0xa0, 0x85,
+                0xea, 0x8a, 0x4a, 0xf6, 0xfa, 0x83, 0x81, 0xf0, 0x65, 0x88, 0x19, 0xea, 0xb4, 0x83,
+                0xf6, 0x5b, 0x32, 0x5d, 0x5a, 0xed, 0xa1, 0x52, 0x32, 0xcf, 0xad, 0xec, 0x75, 0xab,
+                0x18, 0x66, 0xe4, 0xc0, 0x15, 0x5a, 0x9c, 0x74, 0xa7, 0xa5, 0x7c, 0xcf, 0x34, 0xc4,
+                0x83, 0xac, 0x7d, 0xa1, 0x58, 0x8a, 0x1b, 0x6b, 0x99, 0x41, 0xf1, 0x10, 0x40, 0xf9,
+                0x4c, 0xf7, 0x8f, 0xad, 0x89, 0xbf, 0x11, 0xfe, 0xd6, 0x9a, 0xa0, 0xd8, 0x31, 0x05,
+                0xad, 0xac, 0xdd, 0x4e, 0x5f, 0x04, 0xa6, 0x24, 0x24, 0x02, 0x3c, 0x9b, 0x9e, 0x33,
+                0xc4, 0xfb, 0x7f, 0x12, 0xbd, 0xf2, 0x1f, 0x07, 0xf2, 0x65, 0xc5, 0x37, 0xd5, 0x1c,
+                0x65, 0x51, 0xf4, 0x61, 0x7b, 0x91, 0x5d, 0x21, 0x99, 0x18, 0x39, 0xc3, 0xd0, 0xd3,
+                0x63, 0x93, 0xd6, 0x46, 0xe0, 0xa8, 0xa4, 0x15, 0x09, 0x21, 0x7d, 0x0e, 0x7d, 0x2c,
+                0xa1, 0xa0, 0xa0, 0xd6, 0x77, 0xa3, 0xea, 0xca, 0x23, 0xed, 0xeb, 0x07, 0xb7, 0x4e,
+                0x65, 0x2a, 0x0b, 0xc5, 0x0c, 0x6c, 0x08, 0x3a, 0x55, 0xd6, 0xc7, 0x30, 0x6e, 0x74,
+                0x08, 0x6f, 0x47, 0x68, 0x93, 0x3a, 0xa2, 0x48, 0x73, 0x68, 0x18, 0x67, 0xa7, 0x89,
+                0x3d, 0x77, 0xcb, 0x7f, 0x29, 0xb8, 0xc8, 0x47, 0xc5, 0x83, 0xf2, 0xd0, 0x71, 0xa6,
+                0x86, 0x61, 0x6e, 0x20, 0x67, 0x19, 0xf7, 0x61, 0xae, 0x39, 0xc1, 0x10, 0x44, 0x2e,
+                0x06, 0x16, 0x3d, 0x2b, 0x84, 0x59, 0x03, 0x60, 0x69, 0x5d, 0x4e, 0x19, 0x84, 0x9e,
+                0x63, 0x4f, 0x24, 0xd9, 0xad, 0x39, 0x6c, 0x19, 0xff, 0x83, 0xce, 0x74, 0xf4, 0x6e,
+                0x64, 0x5f, 0x93, 0x2e, 0x14, 0x1a, 0x41, 0x19, 0x59, 0x36, 0xc8, 0x5d, 0x51, 0x44,
+                0x14, 0xf1, 0x12, 0xe6, 0x0b, 0x1a, 0x25, 0x37, 0xc3, 0x8d, 0x6d, 0xc6, 0xc4, 0x63,
+                0x83, 0x05, 0xc9, 0xbd, 0x6c, 0x62, 0xe3, 0x66, 0xbc, 0x63, 0x12, 0x3e, 0x3e, 0x6d,
+                0xd3, 0x6e, 0xed, 0xd3, 0x13, 0x6f, 0xce, 0x8d, 0xee, 0xca, 0x2a, 0xa0, 0x9a, 0x32,
+                0x98, 0xa3, 0x9d, 0x83, 0x85, 0x9e, 0xfc, 0x9b, 0x2b, 0x69, 0xcf, 0x9a, 0x7d, 0xee,
+                0x08, 0xa9, 0x8e, 0x4b, 0xe5, 0x58, 0xac, 0x79, 0x12, 0xfd, 0xcb, 0x42, 0x20, 0x90,
+                0x75, 0x42, 0x02, 0x60, 0xf7, 0xca, 0xd0, 0xf2, 0xc0, 0x1f, 0x2a, 0xfe, 0x33, 0x07,
+                0x3f, 0x26, 0x24, 0x9d, 0x94, 0x4f, 0x7a, 0x50, 0xdd, 0x84, 0x83, 0x9b, 0xc3, 0xea,
+                0x7f, 0xde, 0xe4, 0xed, 0x71, 0x44, 0x9c, 0xf0, 0x75, 0x33, 0xd2, 0x6e, 0x1e, 0x27,
+                0xa3, 0xef, 0xb0, 0x32, 0xc3, 0xa3, 0xb3, 0x4b, 0xd3, 0x09, 0x26, 0x22, 0xd2, 0x06,
+                0x2a, 0xe5, 0x36, 0xef, 0x51, 0x49, 0xc4, 0x9b, 0x5b, 0xc9, 0x47, 0x5e, 0xaf, 0xab,
+                0x6e, 0x67, 0x57, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ],
+            cv_net: [
+                0x10, 0xb2, 0x33, 0xd2, 0x49, 0x94, 0x68, 0xe0, 0xb0, 0xdf, 0x47, 0x3d, 0x5a, 0x21,
+                0xb9, 0x3f, 0x7d, 0x2b, 0x5d, 0x5f, 0x09, 0x95, 0xa9, 0x55, 0xd0, 0x86, 0x8a, 0x27,
+                0x45, 0x3f, 0x96, 0x82,
+            ],
+            rho: [
+                0xea, 0x1d, 0x9d, 0x26, 0x5e, 0xf4, 0x8a, 0x18, 0x97, 0x89, 0x70, 0xb1, 0x76, 0x7b,
+                0xe0, 0xe8, 0x14, 0x11, 0x94, 0x7e, 0x9e, 0x69, 0xb7, 0x19, 0xfa, 0xb7, 0x41, 0x72,
+                0x1d, 0x40, 0x9b, 0x33,
+            ],
+            cmx: [
+                0x9e, 0x3d, 0x61, 0x35, 0x6b, 0x0d, 0x88, 0x95, 0x9e, 0x3f, 0x0f, 0xcc, 0x4a, 0x93,
+                0x2e, 0x93, 0x2e, 0xac, 0xbc, 0x80, 0x1d, 0x48, 0xc0, 0x19, 0x5b, 0x9c, 0x8b, 0xd1,
+                0x05, 0x5a, 0x8e, 0x2e,
+            ],
+            esk: [
+                0x1b, 0x52, 0x63, 0x2d, 0x2a, 0x8d, 0x58, 0xd1, 0x63, 0x57, 0xa9, 0x19, 0xa2, 0x06,
+                0x31, 0xe2, 0x91, 0x14, 0xc8, 0x60, 0x07, 0xa2, 0xb1, 0x8b, 0x25, 0xec, 0xff, 0x47,
+                0x72, 0x16, 0x8c, 0x05,
+            ],
+            ephemeral_key: [
+                0xc1, 0xce, 0x25, 0xfb, 0x89, 0xe5, 0xca, 0x89, 0x97, 0xf9, 0xb4, 0xbb, 0x0e, 0x1e,
+                0xfb, 0xcc, 0x1a, 0x8c, 0xbf, 0x44, 0xec, 0xfd, 0x33, 0x2c, 0x6c, 0x5c, 0x17, 0x3b,
+                0xb1, 0x1f, 0xb5, 0x87,
+            ],
+            shared_secret: [
+                0x2e, 0xe5, 0x69, 0xce, 0xb3, 0xfd, 0xb8, 0x67, 0xa5, 0xd8, 0x4c, 0x92, 0x68, 0x24,
+                0xef, 0x54, 0x9f, 0x2d, 0xd2, 0x8f, 0x8b, 0x04, 0x8d, 0x67, 0xd0, 0x28, 0x81, 0x7d,
+                0xbf, 0xf5, 0xd2, 0xb1,
+            ],
+            k_enc: [
+                0x41, 0x4d, 0x80, 0x67, 0xc9, 0xfe, 0xbd, 0x5e, 0xbc, 0xd9, 0xae, 0x8c, 0x05, 0x99,
+                0x4e, 0x3b, 0x06, 0x85, 0xc8, 0x86, 0x6f, 0x88, 0x95, 0x94, 0xc3, 0x74, 0xb3, 0x75,
+                0xac, 0x2c, 0x6d, 0x24,
+            ],
+            p_enc: [
+                0x03, 0x4e, 0x42, 0x6d, 0xf1, 0xad, 0x32, 0x48, 0x94, 0xbc, 0xa2, 0xc1, 0xf3, 0xdb,
+                0x77, 0x79, 0xb5, 0x84, 0x64, 0x34, 0x49, 0x56, 0xbb, 0xb1, 0x95, 0xa4, 0xfa, 0x66,
+                0xdc, 0x9c, 0xd5, 0x42, 0xc7, 0x6b, 0x91, 0x50, 0xc8, 0x4b, 0xf8, 0x90, 0x78, 0x99,
+                0x42, 0xf5, 0x5c, 0x20, 0x0b, 0x77, 0x3e, 0xcd, 0xd7, 0x99, 0xa6, 0x33, 0x05, 0x44,
+                0xe5, 0x46, 0x39, 0xb5, 0x41, 0x87, 0x01, 0xff, 0x4c, 0xc4, 0x5a, 0x31, 0xf6, 0x2e,
+                0xdd, 0x84, 0x3d, 0xbb, 0xdc, 0x5a, 0xa7, 0x27, 0xab, 0x79, 0xb4, 0x42, 0x68, 0x3c,
+                0xff, 0x2c, 0xff, 0x3e, 0xca, 0x24, 0xde, 0x3e, 0x09, 0x84, 0xe1, 0x0e, 0x68, 0xae,
+                0x38, 0x75, 0x34, 0xb9, 0x6c, 0xde, 0x37, 0x92, 0xf1, 0x35, 0xbf, 0x5f, 0x68, 0x78,
+                0x7d, 0x37, 0x0c, 0xa8, 0xc4, 0xc4, 0x07, 0x4d, 0xc5, 0xd6, 0x01, 0xae, 0x90, 0x49,
+                0x54, 0x37, 0xc3, 0xc2, 0xd4, 0x8a, 0x3d, 0x96, 0x66, 0x83, 0xac, 0x05, 0x16, 0x0b,
+                0x7a, 0x84, 0xea, 0xa7, 0xaa, 0xb7, 0x40, 0x09, 0xe5, 0x7a, 0x85, 0xf7, 0xbf, 0x68,
+                0xa2, 0xe4, 0x82, 0x00, 0x0f, 0x82, 0x9c, 0x54, 0x50, 0x73, 0xa1, 0x5d, 0x5c, 0xd0,
+                0xfc, 0xc5, 0x74, 0x39, 0xa4, 0x35, 0x0e, 0xaf, 0x09, 0x8d, 0xfb, 0x82, 0xa0, 0x85,
+                0xea, 0x8a, 0x4a, 0xf6, 0xfa, 0x83, 0x81, 0xf0, 0x65, 0x88, 0x19, 0xea, 0xb4, 0x83,
+                0xf6, 0x5b, 0x32, 0x5d, 0x5a, 0xed, 0xa1, 0x52, 0x32, 0xcf, 0xad, 0xec, 0x75, 0xab,
+                0x18, 0x66, 0xe4, 0xc0, 0x15, 0x5a, 0x9c, 0x74, 0xa7, 0xa5, 0x7c, 0xcf, 0x34, 0xc4,
+                0x83, 0xac, 0x7d, 0xa1, 0x58, 0x8a, 0x1b, 0x6b, 0x99, 0x41, 0xf1, 0x10, 0x40, 0xf9,
+                0x4c, 0xf7, 0x8f, 0xad, 0x89, 0xbf, 0x11, 0xfe, 0xd6, 0x9a, 0xa0, 0xd8, 0x31, 0x05,
+                0xad, 0xac, 0xdd, 0x4e, 0x5f, 0x04, 0xa6, 0x24, 0x24, 0x02, 0x3c, 0x9b, 0x9e, 0x33,
+                0xc4, 0xfb, 0x7f, 0x12, 0xbd, 0xf2, 0x1f, 0x07, 0xf2, 0x65, 0xc5, 0x37, 0xd5, 0x1c,
+                0x65, 0x51, 0xf4, 0x61, 0x7b, 0x91, 0x5d, 0x21, 0x99, 0x18, 0x39, 0xc3, 0xd0, 0xd3,
+                0x63, 0x93, 0xd6, 0x46, 0xe0, 0xa8, 0xa4, 0x15, 0x09, 0x21, 0x7d, 0x0e, 0x7d, 0x2c,
+                0xa1, 0xa0, 0xa0, 0xd6, 0x77, 0xa3, 0xea, 0xca, 0x23, 0xed, 0xeb, 0x07, 0xb7, 0x4e,
+                0x65, 0x2a, 0x0b, 0xc5, 0x0c, 0x6c, 0x08, 0x3a, 0x55, 0xd6, 0xc7, 0x30, 0x6e, 0x74,
+                0x08, 0x6f, 0x47, 0x68, 0x93, 0x3a, 0xa2, 0x48, 0x73, 0x68, 0x18, 0x67, 0xa7, 0x89,
+                0x3d, 0x77, 0xcb, 0x7f, 0x29, 0xb8, 0xc8, 0x47, 0xc5, 0x83, 0xf2, 0xd0, 0x71, 0xa6,
+                0x86, 0x61, 0x6e, 0x20, 0x67, 0x19, 0xf7, 0x61, 0xae, 0x39, 0xc1, 0x10, 0x44, 0x2e,
+                0x06, 0x16, 0x3d, 0x2b, 0x84, 0x59, 0x03, 0x60, 0x69, 0x5d, 0x4e, 0x19, 0x84, 0x9e,
+                0x63, 0x4f, 0x24, 0xd9, 0xad, 0x39, 0x6c, 0x19, 0xff, 0x83, 0xce, 0x74, 0xf4, 0x6e,
+                0x64, 0x5f, 0x93, 0x2e, 0x14, 0x1a, 0x41, 0x19, 0x59, 0x36, 0xc8, 0x5d, 0x51, 0x44,
+                0x14, 0xf1, 0x12, 0xe6, 0x0b, 0x1a, 0x25, 0x37, 0xc3, 0x8d, 0x6d, 0xc6, 0xc4, 0x63,
+                0x83, 0x05, 0xc9, 0xbd, 0x6c, 0x62, 0xe3, 0x66, 0xbc, 0x63, 0x12, 0x3e, 0x3e, 0x6d,
+                0xd3, 0x6e, 0xed, 0xd3, 0x13, 0x6f, 0xce, 0x8d, 0xee, 0xca, 0x2a, 0xa0, 0x9a, 0x32,
+                0x98, 0xa3, 0x9d, 0x83, 0x85, 0x9e, 0xfc, 0x9b, 0x2b, 0x69, 0xcf, 0x9a, 0x7d, 0xee,
+                0x08, 0xa9, 0x8e, 0x4b, 0xe5, 0x58, 0xac, 0x79, 0x12, 0xfd, 0xcb, 0x42, 0x20, 0x90,
+                0x75, 0x42, 0x02, 0x60, 0xf7, 0xca, 0xd0, 0xf2, 0xc0, 0x1f, 0x2a, 0xfe, 0x33, 0x07,
+                0x3f, 0x26, 0x24, 0x9d, 0x94, 0x4f, 0x7a, 0x50, 0xdd, 0x84, 0x83, 0x9b, 0xc3, 0xea,
+                0x7f, 0xde, 0xe4, 0xed, 0x71, 0x44, 0x9c, 0xf0, 0x75, 0x33, 0xd2, 0x6e, 0x1e, 0x27,
+                0xa3, 0xef, 0xb0, 0x32, 0xc3, 0xa3, 0xb3, 0x4b, 0xd3, 0x09, 0x26, 0x22, 0xd2, 0x06,
+                0x2a, 0xe5, 0x36, 0xef, 0x51, 0x49, 0xc4, 0x9b, 0x5b, 0xc9, 0x47, 0x5e, 0xaf, 0xab,
+                0x6e, 0x67, 0x57, 0x61,
+            ],
+            c_enc: [
+                0xbc, 0x8a, 0x16, 0xfd, 0x57, 0xbc, 0x03, 0x60, 0x59, 0xe5, 0x4d, 0xc2, 0xbc, 0xfa,
+                0xad, 0x9c, 0xc1, 0xfa, 0xe8, 0xcb, 0x2b, 0xe2, 0xa0, 0xc8, 0x5e, 0x81, 0x6c, 0x67,
+                0xfd, 0xcd, 0x0b, 0x93, 0xe6, 0xa1, 0xed, 0xc8, 0x3b, 0xfa, 0xc4, 0x1e, 0xb4, 0x19,
+                0x1c, 0x56, 0x4b, 0xac, 0x58, 0x01, 0x62, 0x92, 0x2d, 0x88, 0x25, 0x30, 0x28, 0xeb,
+                0x88, 0xed, 0x46, 0xbf, 0x24, 0x2d, 0x82, 0x28, 0x6c, 0xb0, 0xa5, 0x66, 0xce, 0x01,
+                0x18, 0x09, 0x4c, 0x90, 0x8f, 0xc2, 0x68, 0xb3, 0x2b, 0xcb, 0xdc, 0x4c, 0x22, 0x82,
+                0xc5, 0x24, 0x2a, 0x65, 0x15, 0x48, 0x8b, 0x83, 0x3d, 0x29, 0x8e, 0x49, 0xda, 0x33,
+                0x3a, 0xdd, 0x96, 0xc9, 0x9b, 0x98, 0xac, 0x06, 0x7f, 0x21, 0x41, 0x28, 0x9a, 0xcd,
+                0x89, 0x49, 0x64, 0xfc, 0xf8, 0x94, 0xc9, 0x26, 0xf1, 0x81, 0xb1, 0x19, 0x85, 0x68,
+                0xb1, 0xdd, 0x6f, 0x5e, 0xd1, 0x22, 0xdc, 0x70, 0x44, 0xad, 0x96, 0x76, 0xa7, 0xc5,
+                0xae, 0x8e, 0xa9, 0x0f, 0x64, 0xbc, 0x59, 0x09, 0x36, 0xe0, 0xdf, 0x53, 0x1c, 0x1b,
+                0x94, 0xb7, 0x35, 0xcd, 0x7b, 0x18, 0x73, 0xc8, 0x51, 0x6f, 0xea, 0x83, 0x64, 0x91,
+                0x40, 0xbc, 0xbb, 0x9b, 0x42, 0xea, 0x6c, 0xb7, 0xaf, 0x67, 0xdc, 0x2d, 0xdb, 0xb4,
+                0x7a, 0xb2, 0x25, 0xe7, 0x98, 0x29, 0xcd, 0xaf, 0x77, 0x04, 0xfb, 0x56, 0x5b, 0x43,
+                0x91, 0x76, 0xf3, 0x35, 0xe4, 0x2b, 0x64, 0xc1, 0x6d, 0xdf, 0xe0, 0x88, 0x45, 0x38,
+                0xbf, 0x43, 0x33, 0xe3, 0x2c, 0xa1, 0xe6, 0x27, 0x41, 0xc3, 0xe7, 0x4c, 0x8f, 0xaa,
+                0xde, 0x0d, 0x89, 0xfa, 0x10, 0x30, 0xcd, 0x8e, 0xfd, 0x20, 0x22, 0x3e, 0x41, 0xc3,
+                0xfc, 0xca, 0xaa, 0xe7, 0x76, 0xe6, 0x8e, 0xe8, 0x40, 0x56, 0x6f, 0x4d, 0x13, 0xc1,
+                0xc9, 0xd5, 0xcb, 0xbe, 0xcf, 0xa7, 0x49, 0x9d, 0x43, 0x12, 0x7c, 0xe8, 0xfd, 0x83,
+                0xdb, 0x6e, 0x89, 0x67, 0x90, 0x32, 0x25, 0x24, 0x87, 0x21, 0x40, 0x0d, 0x5e, 0x3e,
+                0xc0, 0xc1, 0x8e, 0x10, 0xf5, 0xe6, 0x6e, 0x10, 0x17, 0x0c, 0xb3, 0x74, 0x48, 0x22,
+                0x4a, 0xde, 0x39, 0x9f, 0x1d, 0x74, 0xa2, 0x16, 0x7d, 0x9f, 0xdb, 0xfe, 0x36, 0xe1,
+                0x28, 0xe4, 0x8c, 0x01, 0x62, 0x61, 0x16, 0xc1, 0xa2, 0xdf, 0x3c, 0xb0, 0x23, 0xd8,
+                0x0a, 0xed, 0x9b, 0xfc, 0x02, 0x71, 0xb8, 0x1f, 0xf9, 0x79, 0x81, 0x01, 0x6f, 0xff,
+                0x19, 0x61, 0x08, 0x88, 0x8b, 0xcb, 0xca, 0x84, 0x5b, 0x5d, 0x97, 0x1b, 0xd5, 0x4f,
+                0x49, 0x7d, 0x3f, 0x3a, 0x09, 0x29, 0x9e, 0x56, 0x50, 0xd3, 0x26, 0xd8, 0x9b, 0x9a,
+                0x5e, 0xff, 0x3e, 0xbd, 0x27, 0x39, 0x34, 0xc4, 0x9f, 0x81, 0x46, 0x7e, 0xb8, 0x4f,
+                0x56, 0x98, 0x90, 0xcf, 0x89, 0x05, 0xb7, 0x4c, 0xd3, 0xed, 0xa6, 0x3c, 0x53, 0x88,
+                0xd5, 0x51, 0x5e, 0x3f, 0xd8, 0x1c, 0x70, 0xc1, 0x5e, 0x2a, 0x98, 0x2d, 0x59, 0x0e,
+                0x87, 0xb8, 0x64, 0x45, 0x4b, 0xcd, 0xf5, 0xf8, 0x4d, 0x9f, 0x11, 0xcb, 0x9c, 0xf2,
+                0xb5, 0xde, 0x3c, 0x5e, 0x0e, 0x2a, 0x6c, 0x48, 0x16, 0x61, 0x64, 0x96, 0x6f, 0xb9,
+                0x0d, 0xac, 0xf8, 0x67, 0x4f, 0x9f, 0x1a, 0x34, 0xd2, 0xcd, 0xc7, 0xc9, 0x48, 0xab,
+                0x99, 0xc3, 0x58, 0xa1, 0x95, 0x47, 0x0a, 0xdd, 0x06, 0x5e, 0xaf, 0x79, 0x24, 0xfa,
+                0xed, 0x63, 0x27, 0xa6, 0x10, 0xf5, 0x2e, 0xd5, 0xd3, 0xa8, 0x7e, 0x11, 0xb5, 0x97,
+                0x4f, 0xa0, 0x60, 0x45, 0xa4, 0x08, 0x95, 0xcd, 0xad, 0x60, 0x1c, 0xae, 0x01, 0xed,
+                0xda, 0x17, 0x52, 0x81, 0x62, 0xd7, 0x21, 0x24, 0xf2, 0x05, 0x6b, 0x9a, 0xb8, 0xc0,
+                0xc0, 0xf5, 0xc6, 0xdd, 0xaa, 0x0f, 0x5e, 0x33, 0xfb, 0x04, 0x23, 0x0b, 0x61, 0x1b,
+                0xff, 0xd8, 0xbd, 0xdc, 0x63, 0x4c, 0x79, 0x60, 0xa3, 0xd4, 0xe6, 0x8f, 0x21, 0xe7,
+                0x83, 0x04, 0xe4, 0xc4, 0xd2, 0xdc, 0xd6, 0xa1, 0x9c, 0xfc, 0x04, 0x57, 0x97, 0x09,
+                0xf0, 0x33, 0xf1, 0x95, 0x78, 0xae, 0x7f, 0x0b, 0xc6, 0x46, 0x32, 0xa6, 0xd7, 0xda,
+                0x40, 0xdc, 0x0c, 0x38, 0x3b, 0xca, 0xa8, 0x68, 0x6a, 0xc8, 0x49, 0x3b, 0x2c, 0xb8,
+                0xf1, 0xd7, 0xd3, 0x95, 0x8a, 0x54,
+            ],
+            ock: [
+                0xdb, 0x1e, 0xf1, 0x9a, 0xf6, 0xdd, 0x1b, 0x7b, 0xf0, 0x64, 0x89, 0xe7, 0xdb, 0x86,
+                0xca, 0xae, 0x27, 0xf6, 0x70, 0x1e, 0x09, 0x16, 0x8c, 0x6e, 0x0d, 0x2b, 0x89, 0x78,
+                0xdf, 0x14, 0xe0, 0x96,
+            ],
+            op: [
+                0x84, 0xda, 0x49, 0x6b, 0x16, 0x0a, 0x81, 0x72, 0xc4, 0x8d, 0x76, 0xb4, 0xfb, 0x08,
+                0xbc, 0xab, 0xf4, 0x0f, 0xf1, 0xe4, 0x2c, 0x48, 0x66, 0x77, 0x57, 0x4f, 0x9e, 0xf8,
+                0x36, 0x34, 0xb0, 0x23, 0x1b, 0x52, 0x63, 0x2d, 0x2a, 0x8d, 0x58, 0xd1, 0x63, 0x57,
+                0xa9, 0x19, 0xa2, 0x06, 0x31, 0xe2, 0x91, 0x14, 0xc8, 0x60, 0x07, 0xa2, 0xb1, 0x8b,
+                0x25, 0xec, 0xff, 0x47, 0x72, 0x16, 0x8c, 0x05,
+            ],
+            c_out: [
+                0x55, 0xdd, 0xba, 0xc4, 0x35, 0x64, 0x19, 0x54, 0xbd, 0xb1, 0xc9, 0x43, 0x4c, 0x36,
+                0x79, 0x32, 0x19, 0x18, 0xbc, 0x1f, 0x29, 0x90, 0x7a, 0xc4, 0x24, 0x43, 0x55, 0x2d,
+                0xfb, 0xe7, 0x05, 0xab, 0x26, 0x19, 0x1b, 0x4e, 0x2b, 0xae, 0xa4, 0xaa, 0xe0, 0x6d,
+                0xa9, 0xf1, 0x38, 0x4e, 0x23, 0x7b, 0xee, 0xab, 0xb1, 0xa2, 0xd8, 0x22, 0x99, 0x5e,
+                0xe7, 0xb9, 0x41, 0x0d, 0x6b, 0xe7, 0x59, 0x2a, 0xed, 0xa9, 0xf5, 0x2d, 0x56, 0xd8,
+                0xc9, 0xf9, 0x3a, 0x0b, 0xe3, 0x8c, 0xfc, 0x8d, 0xc2, 0x94,
+            ],
+            note_type: Some([
+                0xa6, 0x33, 0x05, 0x44, 0xe5, 0x46, 0x39, 0xb5, 0x41, 0x87, 0x01, 0xff, 0x4c, 0xc4,
+                0x5a, 0x31, 0xf6, 0x2e, 0xdd, 0x84, 0x3d, 0xbb, 0xdc, 0x5a, 0xa7, 0x27, 0xab, 0x79,
+                0xb4, 0x42, 0x68, 0x3c,
+            ]),
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x47, 0x30, 0x68, 0xbf, 0x68, 0xe5, 0x0b, 0xe3, 0x85, 0x7d, 0xec, 0xb2, 0xef, 0xd5,
+                0xde, 0x20, 0xea, 0xc8, 0x1b, 0x37, 0x5b, 0xd0, 0xbb, 0xe8, 0x36, 0x86, 0x6e, 0x99,
+                0x36, 0x3b, 0x37, 0x50, 0x9d, 0x53, 0x8f, 0xcc, 0xa9, 0x33, 0x37, 0xad, 0xbc, 0x24,
+                0x81, 0xe2, 0x70, 0x26, 0x18, 0x4c, 0x3f, 0x4f, 0x48, 0xcc, 0x5d, 0x5a, 0x0e, 0x4a,
+                0x4c, 0xfa, 0x4d, 0x6a, 0x24, 0x7f, 0x2e, 0x39,
+            ],
+            ovk: [
+                0x25, 0xb4, 0xc2, 0x6e, 0xb0, 0x3f, 0x71, 0x66, 0x46, 0x61, 0x9a, 0xf0, 0x24, 0x56,
+                0xae, 0x69, 0x59, 0x62, 0xfe, 0x5e, 0x93, 0x1a, 0x63, 0xb5, 0xc7, 0x90, 0x52, 0xec,
+                0xd3, 0x33, 0xe1, 0x84,
+            ],
+            default_d: [
+                0x61, 0x5f, 0x53, 0x89, 0x1a, 0x18, 0xe0, 0x52, 0x17, 0x2d, 0x81,
+            ],
+            default_pk_d: [
+                0x04, 0x47, 0x12, 0x42, 0xe1, 0xf4, 0x2b, 0xf0, 0x81, 0xf0, 0x8e, 0x9d, 0x71, 0xfe,
+                0x4f, 0x3a, 0x65, 0x91, 0xa7, 0xc0, 0x1e, 0xe2, 0xcf, 0x35, 0x30, 0x2f, 0x38, 0xd3,
+                0x34, 0xeb, 0x90, 0x2c,
+            ],
+            v: 15119422206032203650,
+            rseed: [
+                0x45, 0x60, 0x3a, 0x53, 0x46, 0x2c, 0x60, 0xe1, 0xf6, 0xcb, 0x0c, 0x9c, 0xa0, 0x39,
+                0x0c, 0x48, 0x82, 0x24, 0xc3, 0x13, 0x26, 0x9f, 0xcd, 0x59, 0xfc, 0xb6, 0x11, 0xfb,
+                0x2d, 0x9b, 0x4c, 0x8f,
+            ],
+            memo: [
+                0xff, 0xa6, 0x01, 0xbb, 0x1c, 0xb8, 0xd0, 0x7d, 0x79, 0x7b, 0xf5, 0xde, 0x52, 0xbc,
+                0xee, 0xb0, 0x23, 0x01, 0xc8, 0x96, 0x2a, 0xc1, 0xfc, 0x04, 0x91, 0xdc, 0x81, 0xaf,
+                0xfd, 0x6c, 0x1e, 0xbf, 0x89, 0xa1, 0x3d, 0x6f, 0x29, 0x0e, 0xda, 0x5d, 0x5c, 0xef,
+                0x38, 0x22, 0x15, 0xc5, 0xe9, 0x51, 0xd7, 0x13, 0x05, 0xef, 0x33, 0xd9, 0x73, 0x71,
+                0x26, 0xd0, 0xe6, 0x62, 0x90, 0x5f, 0x12, 0x50, 0x92, 0x6f, 0x6a, 0x22, 0x99, 0x90,
+                0xe3, 0x8f, 0x69, 0xad, 0x9a, 0x91, 0x92, 0xb3, 0x02, 0xf2, 0x6b, 0xdd, 0xa4, 0x65,
+                0xd9, 0x0b, 0x94, 0xb1, 0x2c, 0x57, 0xfa, 0x3f, 0xd6, 0x93, 0x00, 0x83, 0xf1, 0x84,
+                0x43, 0x8d, 0x8a, 0x88, 0x9d, 0x3f, 0x5e, 0xce, 0xa2, 0xc6, 0xd2, 0x3d, 0x67, 0x36,
+                0xf2, 0xa0, 0xf1, 0x8e, 0x26, 0xf4, 0xfa, 0x45, 0xd1, 0xbe, 0x8f, 0x3d, 0xc4, 0xa7,
+                0x07, 0x13, 0x7e, 0x95, 0xd2, 0xad, 0x59, 0x4f, 0x6c, 0x03, 0xd2, 0x49, 0x23, 0x06,
+                0x7a, 0xe4, 0x7f, 0xd6, 0x42, 0x5e, 0xfb, 0x9c, 0x1d, 0x50, 0x4e, 0x6f, 0xd5, 0x57,
+                0x53, 0x40, 0x94, 0x56, 0x01, 0xfe, 0x80, 0x6f, 0x57, 0x56, 0xac, 0xb5, 0x62, 0xf1,
+                0x3c, 0x0c, 0xa1, 0xd8, 0x03, 0xa1, 0x95, 0xc2, 0xeb, 0xb2, 0xef, 0x02, 0xac, 0x33,
+                0xe6, 0xa8, 0x8d, 0xea, 0x07, 0x5b, 0xa9, 0x96, 0xd3, 0xc3, 0x36, 0x64, 0x8e, 0x86,
+                0x94, 0xd3, 0xa1, 0x9d, 0x3d, 0xca, 0x53, 0x1b, 0xeb, 0x50, 0xd4, 0x32, 0x7c, 0x5c,
+                0x0c, 0x23, 0xcb, 0x7c, 0xfd, 0xb0, 0x8c, 0xa7, 0xcf, 0x2c, 0xac, 0x6b, 0xc1, 0x39,
+                0xd0, 0x74, 0x14, 0x73, 0xd3, 0x76, 0x02, 0x9c, 0xb4, 0xab, 0x6b, 0xf0, 0x54, 0x55,
+                0x7c, 0xe2, 0x94, 0xc7, 0x28, 0xa4, 0x68, 0x7d, 0x57, 0xec, 0x89, 0x09, 0xff, 0x51,
+                0xa4, 0xd0, 0x2f, 0x9d, 0xcd, 0x11, 0x19, 0x3d, 0x7d, 0x1c, 0x9f, 0xda, 0xe6, 0xa1,
+                0x73, 0x96, 0xa1, 0xbf, 0x57, 0xa9, 0x94, 0x93, 0x4f, 0x5e, 0x7a, 0x59, 0xf0, 0x45,
+                0xde, 0xbe, 0xaf, 0xf6, 0x2e, 0xf3, 0x26, 0xb9, 0x47, 0xf2, 0xa8, 0xb4, 0x95, 0x55,
+                0xe4, 0xd9, 0x9b, 0x3b, 0xf5, 0xc8, 0x1f, 0xf9, 0xfe, 0x31, 0x4e, 0x04, 0x7a, 0xf1,
+                0x52, 0x50, 0x8f, 0x57, 0x01, 0x5c, 0xa4, 0x02, 0xc6, 0x7d, 0x92, 0x5c, 0x99, 0xac,
+                0xea, 0x3e, 0xe8, 0xcc, 0x4b, 0x00, 0x8c, 0x5c, 0xb4, 0x39, 0x66, 0xe7, 0x14, 0xef,
+                0x48, 0x0f, 0xd0, 0x5e, 0x07, 0xc7, 0xb2, 0xdd, 0xa9, 0xaa, 0x39, 0x66, 0x11, 0x3e,
+                0xaa, 0x29, 0x3d, 0x3f, 0x62, 0x2b, 0x30, 0x9d, 0x64, 0x80, 0x3c, 0xe1, 0xe6, 0x37,
+                0x8b, 0x6a, 0xac, 0x4f, 0xab, 0x52, 0x7c, 0x43, 0xcd, 0x45, 0xed, 0x0a, 0x3c, 0x1a,
+                0x4b, 0x9f, 0xb1, 0x8d, 0xcc, 0xcf, 0xcd, 0xb6, 0xac, 0x0c, 0x24, 0x21, 0x63, 0x9c,
+                0xda, 0x00, 0x75, 0xa2, 0x0d, 0xc5, 0x11, 0x1b, 0x8d, 0x3d, 0x31, 0x99, 0x49, 0x5b,
+                0xd9, 0x13, 0x3d, 0xba, 0xb9, 0x45, 0x41, 0x41, 0x0e, 0x4f, 0xba, 0x92, 0xc7, 0xb6,
+                0x06, 0xa5, 0xcb, 0x12, 0x2f, 0x14, 0x0c, 0xf1, 0xa3, 0x59, 0x6f, 0x27, 0x88, 0xf3,
+                0xc8, 0xb9, 0x26, 0x60, 0xf1, 0x4c, 0xb6, 0x5a, 0xf5, 0xdd, 0x23, 0xdf, 0xdb, 0xac,
+                0x13, 0x71, 0xec, 0xf4, 0xb3, 0x37, 0x12, 0xfe, 0xd2, 0x29, 0x2c, 0x44, 0xf7, 0x08,
+                0x34, 0xcf, 0x96, 0xc0, 0x5d, 0x58, 0x82, 0x7e, 0x69, 0xbf, 0xc2, 0xe6, 0x96, 0xfa,
+                0x08, 0x74, 0x86, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ],
+            cv_net: [
+                0x7e, 0xfd, 0xf4, 0x17, 0xcf, 0xd6, 0x44, 0x7d, 0x96, 0x58, 0x1d, 0xd1, 0x7b, 0x82,
+                0x12, 0xee, 0x53, 0x7b, 0x13, 0x4b, 0x05, 0xa5, 0x58, 0x67, 0x4a, 0x39, 0xe6, 0x66,
+                0x97, 0xe6, 0x3a, 0x29,
+            ],
+            rho: [
+                0x9a, 0xd0, 0x7f, 0x1c, 0x28, 0x7b, 0xdd, 0x53, 0x4f, 0x6f, 0x7e, 0xae, 0x08, 0xf7,
+                0x85, 0x72, 0xa3, 0x05, 0xfa, 0x3b, 0x70, 0x68, 0xa3, 0x78, 0x38, 0x27, 0xaf, 0xe2,
+                0x14, 0x7a, 0x27, 0x10,
+            ],
+            cmx: [
+                0xf2, 0x04, 0x22, 0x51, 0xa0, 0x59, 0xa2, 0xf5, 0x8a, 0xb8, 0xe9, 0x0b, 0x52, 0x64,
+                0xd0, 0xa4, 0x3f, 0x96, 0xd7, 0x7e, 0xdd, 0x54, 0xf8, 0x0f, 0xf4, 0x9d, 0x43, 0x86,
+                0x81, 0x4d, 0x73, 0x2e,
+            ],
+            esk: [
+                0xb5, 0x9a, 0x18, 0x4d, 0x24, 0xe6, 0x1b, 0x9f, 0x9d, 0x37, 0x1d, 0xa4, 0xb1, 0x44,
+                0x01, 0x72, 0x02, 0x9a, 0x2e, 0xbc, 0x0a, 0x2a, 0xbe, 0xb8, 0xaf, 0x2b, 0xd1, 0xa0,
+                0x8c, 0x67, 0xd9, 0x3f,
+            ],
+            ephemeral_key: [
+                0x46, 0x73, 0x1f, 0xff, 0xc5, 0x9a, 0xf4, 0xc1, 0x28, 0x82, 0xbc, 0xca, 0xea, 0xa7,
+                0xb8, 0xed, 0x39, 0x0b, 0x14, 0x66, 0x72, 0xe1, 0x36, 0x51, 0xc3, 0x2e, 0x57, 0x80,
+                0x62, 0x68, 0x65, 0xa7,
+            ],
+            shared_secret: [
+                0x9d, 0x56, 0xbd, 0x96, 0x00, 0x39, 0x62, 0x5e, 0x11, 0x7d, 0x7b, 0xfe, 0xd4, 0x3a,
+                0x57, 0x3b, 0x11, 0x51, 0x7f, 0xfa, 0x76, 0x14, 0xea, 0x2d, 0xa7, 0x7e, 0xdf, 0x62,
+                0x7f, 0x6f, 0x13, 0xaa,
+            ],
+            k_enc: [
+                0x04, 0x2f, 0x92, 0x82, 0x13, 0x44, 0xde, 0x97, 0x7c, 0xee, 0x89, 0x9e, 0xd2, 0x1b,
+                0xc8, 0x48, 0xf5, 0xc4, 0xfe, 0xdc, 0x39, 0xf2, 0xdf, 0xed, 0xad, 0x62, 0xcc, 0x7a,
+                0x92, 0x7f, 0x74, 0xfd,
+            ],
+            p_enc: [
+                0x03, 0x61, 0x5f, 0x53, 0x89, 0x1a, 0x18, 0xe0, 0x52, 0x17, 0x2d, 0x81, 0x82, 0xcf,
+                0xb3, 0xe7, 0x63, 0xfa, 0xd2, 0xd1, 0x45, 0x60, 0x3a, 0x53, 0x46, 0x2c, 0x60, 0xe1,
+                0xf6, 0xcb, 0x0c, 0x9c, 0xa0, 0x39, 0x0c, 0x48, 0x82, 0x24, 0xc3, 0x13, 0x26, 0x9f,
+                0xcd, 0x59, 0xfc, 0xb6, 0x11, 0xfb, 0x2d, 0x9b, 0x4c, 0x8f, 0x61, 0x16, 0xcf, 0xec,
+                0x26, 0x47, 0xcc, 0xaa, 0xe1, 0xc7, 0x4b, 0x41, 0x6f, 0x3e, 0x6a, 0xe8, 0xf7, 0xcc,
+                0x60, 0xea, 0xaf, 0x7b, 0x6a, 0x59, 0x0d, 0x51, 0x54, 0x41, 0x38, 0xe1, 0x73, 0x29,
+                0xff, 0xa6, 0x01, 0xbb, 0x1c, 0xb8, 0xd0, 0x7d, 0x79, 0x7b, 0xf5, 0xde, 0x52, 0xbc,
+                0xee, 0xb0, 0x23, 0x01, 0xc8, 0x96, 0x2a, 0xc1, 0xfc, 0x04, 0x91, 0xdc, 0x81, 0xaf,
+                0xfd, 0x6c, 0x1e, 0xbf, 0x89, 0xa1, 0x3d, 0x6f, 0x29, 0x0e, 0xda, 0x5d, 0x5c, 0xef,
+                0x38, 0x22, 0x15, 0xc5, 0xe9, 0x51, 0xd7, 0x13, 0x05, 0xef, 0x33, 0xd9, 0x73, 0x71,
+                0x26, 0xd0, 0xe6, 0x62, 0x90, 0x5f, 0x12, 0x50, 0x92, 0x6f, 0x6a, 0x22, 0x99, 0x90,
+                0xe3, 0x8f, 0x69, 0xad, 0x9a, 0x91, 0x92, 0xb3, 0x02, 0xf2, 0x6b, 0xdd, 0xa4, 0x65,
+                0xd9, 0x0b, 0x94, 0xb1, 0x2c, 0x57, 0xfa, 0x3f, 0xd6, 0x93, 0x00, 0x83, 0xf1, 0x84,
+                0x43, 0x8d, 0x8a, 0x88, 0x9d, 0x3f, 0x5e, 0xce, 0xa2, 0xc6, 0xd2, 0x3d, 0x67, 0x36,
+                0xf2, 0xa0, 0xf1, 0x8e, 0x26, 0xf4, 0xfa, 0x45, 0xd1, 0xbe, 0x8f, 0x3d, 0xc4, 0xa7,
+                0x07, 0x13, 0x7e, 0x95, 0xd2, 0xad, 0x59, 0x4f, 0x6c, 0x03, 0xd2, 0x49, 0x23, 0x06,
+                0x7a, 0xe4, 0x7f, 0xd6, 0x42, 0x5e, 0xfb, 0x9c, 0x1d, 0x50, 0x4e, 0x6f, 0xd5, 0x57,
+                0x53, 0x40, 0x94, 0x56, 0x01, 0xfe, 0x80, 0x6f, 0x57, 0x56, 0xac, 0xb5, 0x62, 0xf1,
+                0x3c, 0x0c, 0xa1, 0xd8, 0x03, 0xa1, 0x95, 0xc2, 0xeb, 0xb2, 0xef, 0x02, 0xac, 0x33,
+                0xe6, 0xa8, 0x8d, 0xea, 0x07, 0x5b, 0xa9, 0x96, 0xd3, 0xc3, 0x36, 0x64, 0x8e, 0x86,
+                0x94, 0xd3, 0xa1, 0x9d, 0x3d, 0xca, 0x53, 0x1b, 0xeb, 0x50, 0xd4, 0x32, 0x7c, 0x5c,
+                0x0c, 0x23, 0xcb, 0x7c, 0xfd, 0xb0, 0x8c, 0xa7, 0xcf, 0x2c, 0xac, 0x6b, 0xc1, 0x39,
+                0xd0, 0x74, 0x14, 0x73, 0xd3, 0x76, 0x02, 0x9c, 0xb4, 0xab, 0x6b, 0xf0, 0x54, 0x55,
+                0x7c, 0xe2, 0x94, 0xc7, 0x28, 0xa4, 0x68, 0x7d, 0x57, 0xec, 0x89, 0x09, 0xff, 0x51,
+                0xa4, 0xd0, 0x2f, 0x9d, 0xcd, 0x11, 0x19, 0x3d, 0x7d, 0x1c, 0x9f, 0xda, 0xe6, 0xa1,
+                0x73, 0x96, 0xa1, 0xbf, 0x57, 0xa9, 0x94, 0x93, 0x4f, 0x5e, 0x7a, 0x59, 0xf0, 0x45,
+                0xde, 0xbe, 0xaf, 0xf6, 0x2e, 0xf3, 0x26, 0xb9, 0x47, 0xf2, 0xa8, 0xb4, 0x95, 0x55,
+                0xe4, 0xd9, 0x9b, 0x3b, 0xf5, 0xc8, 0x1f, 0xf9, 0xfe, 0x31, 0x4e, 0x04, 0x7a, 0xf1,
+                0x52, 0x50, 0x8f, 0x57, 0x01, 0x5c, 0xa4, 0x02, 0xc6, 0x7d, 0x92, 0x5c, 0x99, 0xac,
+                0xea, 0x3e, 0xe8, 0xcc, 0x4b, 0x00, 0x8c, 0x5c, 0xb4, 0x39, 0x66, 0xe7, 0x14, 0xef,
+                0x48, 0x0f, 0xd0, 0x5e, 0x07, 0xc7, 0xb2, 0xdd, 0xa9, 0xaa, 0x39, 0x66, 0x11, 0x3e,
+                0xaa, 0x29, 0x3d, 0x3f, 0x62, 0x2b, 0x30, 0x9d, 0x64, 0x80, 0x3c, 0xe1, 0xe6, 0x37,
+                0x8b, 0x6a, 0xac, 0x4f, 0xab, 0x52, 0x7c, 0x43, 0xcd, 0x45, 0xed, 0x0a, 0x3c, 0x1a,
+                0x4b, 0x9f, 0xb1, 0x8d, 0xcc, 0xcf, 0xcd, 0xb6, 0xac, 0x0c, 0x24, 0x21, 0x63, 0x9c,
+                0xda, 0x00, 0x75, 0xa2, 0x0d, 0xc5, 0x11, 0x1b, 0x8d, 0x3d, 0x31, 0x99, 0x49, 0x5b,
+                0xd9, 0x13, 0x3d, 0xba, 0xb9, 0x45, 0x41, 0x41, 0x0e, 0x4f, 0xba, 0x92, 0xc7, 0xb6,
+                0x06, 0xa5, 0xcb, 0x12, 0x2f, 0x14, 0x0c, 0xf1, 0xa3, 0x59, 0x6f, 0x27, 0x88, 0xf3,
+                0xc8, 0xb9, 0x26, 0x60, 0xf1, 0x4c, 0xb6, 0x5a, 0xf5, 0xdd, 0x23, 0xdf, 0xdb, 0xac,
+                0x13, 0x71, 0xec, 0xf4, 0xb3, 0x37, 0x12, 0xfe, 0xd2, 0x29, 0x2c, 0x44, 0xf7, 0x08,
+                0x34, 0xcf, 0x96, 0xc0, 0x5d, 0x58, 0x82, 0x7e, 0x69, 0xbf, 0xc2, 0xe6, 0x96, 0xfa,
+                0x08, 0x74, 0x86, 0x9c,
+            ],
+            c_enc: [
+                0x16, 0x76, 0x72, 0x3a, 0x18, 0xff, 0x58, 0x77, 0x70, 0x15, 0x8d, 0x6b, 0x85, 0x09,
+                0x3c, 0x49, 0x20, 0x16, 0xf8, 0x7e, 0xc3, 0xfa, 0xe8, 0xb0, 0xb4, 0x7c, 0xd9, 0x29,
+                0x8f, 0xa2, 0x07, 0xc4, 0xb6, 0x09, 0xc6, 0x92, 0xdd, 0xb9, 0x10, 0x19, 0x72, 0xc9,
+                0x4c, 0x71, 0x87, 0x84, 0x85, 0x42, 0x1e, 0xfb, 0x70, 0x1c, 0xf5, 0x15, 0xa2, 0x3f,
+                0xbf, 0x36, 0xfe, 0x93, 0x54, 0x0d, 0x82, 0xd6, 0x9a, 0x72, 0x62, 0x4e, 0x25, 0x4f,
+                0xe3, 0xa0, 0x11, 0xc5, 0xdb, 0xdb, 0xd2, 0xbd, 0xff, 0xb8, 0x83, 0x8a, 0xf3, 0x7d,
+                0x03, 0xce, 0x69, 0x12, 0x6b, 0x2f, 0x68, 0x21, 0x25, 0xb7, 0xa9, 0xb2, 0xa3, 0xee,
+                0x11, 0x8a, 0xe5, 0xad, 0xb4, 0x60, 0xa4, 0x68, 0x7c, 0x24, 0x30, 0x18, 0x7b, 0xfd,
+                0x0f, 0x6c, 0x2a, 0x3d, 0x5d, 0x74, 0x30, 0x1c, 0xbd, 0x8f, 0xd0, 0x26, 0xc8, 0x64,
+                0x4f, 0xbf, 0xa2, 0x65, 0x69, 0x88, 0xe9, 0x58, 0x59, 0x0b, 0x81, 0x6a, 0x1e, 0x64,
+                0x0e, 0x46, 0x71, 0x0e, 0x46, 0xfa, 0x15, 0x94, 0xff, 0x2a, 0x61, 0xd6, 0xf6, 0xe7,
+                0xb4, 0xa9, 0xf6, 0xe0, 0xde, 0x68, 0x3d, 0x95, 0xe5, 0x9d, 0x43, 0x57, 0xf7, 0x9a,
+                0xc4, 0x93, 0x86, 0x6d, 0xab, 0x06, 0x57, 0x76, 0xc0, 0xb1, 0x43, 0x6b, 0x8e, 0x04,
+                0x47, 0x68, 0x43, 0xc2, 0x8b, 0x48, 0x45, 0xea, 0xff, 0x17, 0x83, 0xa8, 0x50, 0xc2,
+                0x4a, 0x90, 0x65, 0xc3, 0x36, 0x51, 0xc4, 0xb3, 0xdd, 0x19, 0x92, 0xf4, 0xf2, 0x08,
+                0xb8, 0x51, 0xbf, 0xff, 0xe9, 0xb7, 0xbb, 0x7a, 0xad, 0x76, 0x7c, 0x23, 0x60, 0xb0,
+                0x5c, 0x11, 0x23, 0x09, 0x66, 0xda, 0x55, 0x7e, 0x31, 0x3a, 0xe6, 0x1c, 0x95, 0x42,
+                0x97, 0x66, 0x10, 0x6b, 0x4b, 0x1b, 0x35, 0x47, 0x64, 0xe4, 0xe1, 0xe4, 0xdf, 0x90,
+                0xc1, 0x2d, 0x24, 0x37, 0x9d, 0x67, 0xba, 0xc6, 0x66, 0x97, 0xaf, 0x23, 0x44, 0x97,
+                0xf2, 0xd6, 0xf9, 0xa6, 0x12, 0x85, 0x0d, 0xd7, 0x1d, 0x1c, 0x98, 0xce, 0x65, 0xd8,
+                0x50, 0x7f, 0xa3, 0x46, 0x35, 0x83, 0x12, 0x39, 0xe2, 0x10, 0xf7, 0xdb, 0xb3, 0x05,
+                0x04, 0x2d, 0x47, 0x50, 0xd9, 0x5a, 0xdf, 0xff, 0xc9, 0x8d, 0xeb, 0x0f, 0x17, 0x13,
+                0xbc, 0x01, 0xaf, 0x5d, 0xb5, 0x99, 0x29, 0x89, 0x76, 0xab, 0xba, 0xdb, 0x0f, 0x4d,
+                0xed, 0x1a, 0x2f, 0xe4, 0xcf, 0x90, 0x60, 0x0e, 0x0d, 0x28, 0xd3, 0x07, 0xc6, 0x41,
+                0xf7, 0x52, 0x3c, 0x16, 0x66, 0x40, 0x1d, 0x78, 0x6f, 0xd2, 0x4a, 0xe1, 0x68, 0x0f,
+                0xe9, 0x26, 0x70, 0x4c, 0xb6, 0xe2, 0xaf, 0x80, 0x1a, 0x0d, 0x82, 0x75, 0x9d, 0xd8,
+                0x7a, 0x8c, 0xd8, 0x7b, 0x85, 0xbb, 0x07, 0x51, 0xa7, 0x08, 0xc9, 0xf4, 0xa7, 0xd3,
+                0x24, 0xe5, 0xc9, 0x3a, 0xd2, 0x2b, 0x86, 0x43, 0xdf, 0xfa, 0x5f, 0x50, 0x79, 0xfc,
+                0x6f, 0x01, 0x6d, 0x94, 0x3c, 0x99, 0x09, 0x27, 0x5c, 0x96, 0xf5, 0xfe, 0x7b, 0x56,
+                0x33, 0x3c, 0x24, 0x01, 0x99, 0x73, 0xd9, 0x4f, 0x06, 0xeb, 0xf6, 0xc0, 0xf6, 0xef,
+                0xdd, 0x42, 0xea, 0xb0, 0x63, 0x49, 0xd5, 0xe8, 0xb9, 0x60, 0xba, 0x8c, 0x68, 0xee,
+                0xfd, 0x44, 0x49, 0x99, 0xf6, 0xfa, 0x3d, 0x6a, 0x3a, 0xe3, 0x1a, 0xe8, 0x54, 0x6e,
+                0xdc, 0x62, 0x78, 0x25, 0x63, 0x7e, 0x1e, 0x86, 0x39, 0x8d, 0x0e, 0xd3, 0xd8, 0x8b,
+                0xfa, 0xea, 0x8b, 0x4b, 0x08, 0x50, 0xd8, 0xa8, 0x28, 0x6e, 0xa9, 0xf3, 0xd1, 0x3f,
+                0xa8, 0xf4, 0x16, 0x53, 0x45, 0x1b, 0x97, 0xb3, 0x8b, 0x06, 0x3a, 0x5f, 0xc6, 0xdb,
+                0xe4, 0xe9, 0x19, 0x94, 0x87, 0xc9, 0x73, 0xef, 0x8f, 0x2c, 0x26, 0x3f, 0x85, 0x05,
+                0xf4, 0xc3, 0xbe, 0xc9, 0xd1, 0x79, 0xbb, 0xd6, 0x5d, 0x1e, 0xdc, 0x58, 0x95, 0xa1,
+                0x6c, 0xc7, 0x98, 0x6b, 0xcf, 0xc4, 0xba, 0xe8, 0x7e, 0xc0, 0xb2, 0x9b, 0xf1, 0xb3,
+                0x97, 0x61, 0x5c, 0x95, 0x13, 0xfa, 0x52, 0xeb, 0xe1, 0xe9, 0xfc, 0xfb, 0xf1, 0x92,
+                0xed, 0x49, 0x26, 0x27, 0x27, 0xa0, 0x8a, 0xd3, 0xc2, 0x95, 0x5b, 0x3d, 0xf2, 0xee,
+                0xad, 0x30, 0x24, 0x3e, 0x06, 0x66, 0xf2, 0x3c, 0x7f, 0x97, 0xe7, 0x84, 0xbe, 0x68,
+                0xcc, 0x22, 0xca, 0x1d, 0x09, 0xd5,
+            ],
+            ock: [
+                0xcf, 0x22, 0xd2, 0x83, 0x95, 0x98, 0x5d, 0x31, 0x6a, 0xf9, 0x50, 0x19, 0x21, 0xba,
+                0xc1, 0x52, 0x57, 0x11, 0xbb, 0x3f, 0x3c, 0xc3, 0xc3, 0xc2, 0x82, 0xa3, 0xd1, 0x8e,
+                0x43, 0xd4, 0x78, 0x05,
+            ],
+            op: [
+                0x04, 0x47, 0x12, 0x42, 0xe1, 0xf4, 0x2b, 0xf0, 0x81, 0xf0, 0x8e, 0x9d, 0x71, 0xfe,
+                0x4f, 0x3a, 0x65, 0x91, 0xa7, 0xc0, 0x1e, 0xe2, 0xcf, 0x35, 0x30, 0x2f, 0x38, 0xd3,
+                0x34, 0xeb, 0x90, 0x2c, 0xb5, 0x9a, 0x18, 0x4d, 0x24, 0xe6, 0x1b, 0x9f, 0x9d, 0x37,
+                0x1d, 0xa4, 0xb1, 0x44, 0x01, 0x72, 0x02, 0x9a, 0x2e, 0xbc, 0x0a, 0x2a, 0xbe, 0xb8,
+                0xaf, 0x2b, 0xd1, 0xa0, 0x8c, 0x67, 0xd9, 0x3f,
+            ],
+            c_out: [
+                0x7a, 0xe6, 0x91, 0xd9, 0xbc, 0xd5, 0x38, 0x42, 0x7b, 0x4f, 0x07, 0xe2, 0x38, 0x81,
+                0x94, 0x18, 0xbb, 0xb8, 0x18, 0x31, 0x88, 0x89, 0x93, 0x08, 0xfd, 0x6a, 0xab, 0x2b,
+                0xf4, 0xf0, 0x69, 0x9c, 0xc5, 0x61, 0x9c, 0x8d, 0x4f, 0xc9, 0x95, 0xc2, 0x11, 0x76,
+                0xbf, 0xea, 0x13, 0xee, 0x04, 0x03, 0xc0, 0xce, 0x57, 0x4f, 0xc8, 0xfa, 0x16, 0x81,
+                0xb3, 0x76, 0xcf, 0x33, 0xc9, 0xff, 0x27, 0xa5, 0xaa, 0x01, 0x58, 0x24, 0xe6, 0x78,
+                0x6e, 0x16, 0xe3, 0x7b, 0x35, 0x5c, 0xf7, 0x54, 0x52, 0xdb,
+            ],
+            note_type: Some([
+                0x61, 0x16, 0xcf, 0xec, 0x26, 0x47, 0xcc, 0xaa, 0xe1, 0xc7, 0x4b, 0x41, 0x6f, 0x3e,
+                0x6a, 0xe8, 0xf7, 0xcc, 0x60, 0xea, 0xaf, 0x7b, 0x6a, 0x59, 0x0d, 0x51, 0x54, 0x41,
+                0x38, 0xe1, 0x73, 0x29,
+            ]),
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xfc, 0x8c, 0x64, 0x1c, 0x0b, 0x28, 0xbe, 0xbf, 0x85, 0x24, 0x25, 0xae, 0x95, 0x5f,
+                0xe6, 0x40, 0x1c, 0xfd, 0x9e, 0x60, 0x63, 0xf2, 0x50, 0x11, 0x3d, 0xa0, 0xb5, 0x8b,
+                0x2a, 0x0f, 0x49, 0xb9, 0x12, 0x0b, 0x89, 0x9f, 0x08, 0x10, 0x6b, 0x30, 0x86, 0xb2,
+                0xf4, 0x11, 0x63, 0x6f, 0x50, 0xab, 0x48, 0x7c, 0xfb, 0x28, 0x81, 0x89, 0x77, 0x8f,
+                0xe4, 0xe5, 0xa1, 0x91, 0x8b, 0x98, 0xd5, 0x0a,
+            ],
+            ovk: [
+                0xbe, 0xd1, 0x7d, 0xf5, 0xf8, 0x88, 0xc8, 0xca, 0x14, 0x67, 0xae, 0x17, 0xdb, 0xbc,
+                0xde, 0x31, 0xc1, 0x10, 0x5c, 0xb5, 0xbd, 0xa8, 0x8a, 0xc6, 0xc6, 0x27, 0x00, 0x2c,
+                0xe2, 0x1c, 0x02, 0x14,
+            ],
+            default_d: [
+                0xd2, 0xf7, 0x5f, 0x7c, 0xe7, 0x1b, 0xa4, 0xa7, 0xab, 0x69, 0xb8,
+            ],
+            default_pk_d: [
+                0x49, 0x19, 0x01, 0x2e, 0x40, 0x43, 0x82, 0xeb, 0xee, 0x8e, 0x60, 0xe9, 0xd4, 0xf1,
+                0x30, 0x79, 0xc0, 0x8d, 0x9c, 0x6d, 0x50, 0xf9, 0x35, 0x86, 0x7d, 0x33, 0x01, 0xf6,
+                0x89, 0xcf, 0xf9, 0x1e,
+            ],
+            v: 7555450289479839818,
+            rseed: [
+                0x13, 0xeb, 0x7c, 0xea, 0xa5, 0xff, 0x12, 0x90, 0xb0, 0x3e, 0xc9, 0x1c, 0xe6, 0xdd,
+                0x28, 0x13, 0x0c, 0x3a, 0xb0, 0xb2, 0x3b, 0x60, 0x2b, 0xd5, 0xbe, 0x5d, 0xc2, 0x60,
+                0x03, 0xaa, 0xe0, 0x4b,
+            ],
+            memo: [
+                0xff, 0x33, 0xd7, 0xbd, 0x25, 0x90, 0xe9, 0x0c, 0x8c, 0x38, 0x8e, 0xa7, 0x95, 0x51,
+                0x22, 0xdb, 0xac, 0xa6, 0x7b, 0x30, 0x39, 0x5a, 0x92, 0x8b, 0x57, 0xb8, 0x57, 0x51,
+                0x23, 0x20, 0x5a, 0xe1, 0x91, 0x52, 0xe4, 0x1e, 0x00, 0x29, 0x31, 0xb4, 0x57, 0x46,
+                0x19, 0x8e, 0x5d, 0xd9, 0x57, 0x1a, 0x56, 0xa7, 0xe0, 0xd4, 0x23, 0xff, 0x27, 0x98,
+                0x9d, 0x3e, 0xb4, 0x17, 0xec, 0xd3, 0xc3, 0x09, 0x3f, 0xb8, 0x2c, 0x56, 0x58, 0xe2,
+                0x96, 0x24, 0xc5, 0x32, 0x19, 0xa6, 0x0c, 0xd0, 0xa8, 0xc4, 0xda, 0x36, 0x7e, 0x29,
+                0xa7, 0x17, 0x79, 0xa7, 0x30, 0x32, 0x98, 0x5a, 0x3d, 0x1f, 0xd0, 0x3d, 0xd4, 0xd0,
+                0x6e, 0x05, 0x56, 0x6f, 0x3b, 0x84, 0x36, 0x7c, 0xf0, 0xfa, 0xee, 0x9b, 0xc3, 0xbd,
+                0x7a, 0x3a, 0x60, 0x6a, 0x9f, 0xdb, 0x84, 0x9c, 0x5d, 0x82, 0xd0, 0xa6, 0x19, 0x23,
+                0xc2, 0xe5, 0xd8, 0xaa, 0x63, 0xa8, 0xa5, 0x0c, 0x38, 0xbd, 0x03, 0x87, 0x72, 0xc4,
+                0x14, 0x3d, 0x8b, 0x7a, 0xcf, 0xd7, 0x4e, 0x72, 0xc0, 0x4d, 0x89, 0x24, 0x8d, 0xff,
+                0x20, 0xfe, 0x8d, 0xc5, 0xec, 0x21, 0x49, 0x05, 0x4e, 0xa2, 0x41, 0x64, 0xe8, 0x5f,
+                0x67, 0x44, 0xad, 0x0c, 0xac, 0xf1, 0xa8, 0xb7, 0x01, 0x26, 0xf4, 0x82, 0xc0, 0x92,
+                0xed, 0x9f, 0x61, 0x27, 0xd2, 0x05, 0x0d, 0x12, 0xe8, 0x78, 0xa7, 0x96, 0x53, 0xa1,
+                0xe8, 0x4d, 0xae, 0xc3, 0xeb, 0xe6, 0x2d, 0x5f, 0x6c, 0x4a, 0xbe, 0x5c, 0xe9, 0x0a,
+                0x7f, 0xe2, 0xe5, 0x2a, 0x8d, 0x78, 0x46, 0xe8, 0xed, 0xf2, 0xf2, 0xbc, 0xe0, 0x5a,
+                0x03, 0x7c, 0x82, 0x6f, 0x22, 0xca, 0xad, 0x12, 0x61, 0x46, 0x7d, 0xcf, 0xb7, 0xd6,
+                0xb6, 0x13, 0x3d, 0xc2, 0x1e, 0x80, 0x96, 0xc7, 0xe9, 0xf8, 0xe9, 0xe1, 0x0c, 0x1e,
+                0x3f, 0xac, 0x40, 0x58, 0xb6, 0x82, 0xc6, 0x8e, 0x54, 0xfa, 0xca, 0xe0, 0xf9, 0xc2,
+                0xdd, 0x4d, 0x64, 0xd9, 0x04, 0x61, 0x52, 0xb4, 0x76, 0x23, 0x32, 0x93, 0x9f, 0x17,
+                0xe6, 0xaa, 0xf7, 0xd8, 0xb9, 0xd3, 0x58, 0xe2, 0x21, 0x8d, 0x4e, 0x0d, 0x69, 0xa4,
+                0xf1, 0x19, 0xe1, 0xc6, 0x4e, 0xec, 0x4c, 0x8b, 0x53, 0x28, 0x09, 0x70, 0x71, 0x31,
+                0xf0, 0x1f, 0x55, 0xc7, 0xad, 0x04, 0xcf, 0xb6, 0x3f, 0x7c, 0x4a, 0x3d, 0x0a, 0x2b,
+                0x0f, 0xfb, 0x0b, 0x05, 0xa6, 0xbe, 0x05, 0x5b, 0x8c, 0x94, 0xca, 0x80, 0xbb, 0x0a,
+                0x1d, 0x13, 0xcd, 0x4c, 0xd6, 0x9a, 0xb9, 0x83, 0x04, 0xae, 0x25, 0x15, 0xd5, 0xf7,
+                0x69, 0x9d, 0x4a, 0xbe, 0xe5, 0xc2, 0x0b, 0xe6, 0x09, 0xd8, 0x73, 0x51, 0x10, 0x12,
+                0xf2, 0x34, 0xbd, 0x85, 0xa7, 0xef, 0xf5, 0xfb, 0x63, 0x4c, 0xff, 0x26, 0x58, 0xba,
+                0x65, 0x16, 0x04, 0x85, 0x63, 0x09, 0x5e, 0xce, 0xfb, 0x30, 0x15, 0xee, 0x3f, 0x03,
+                0xca, 0x52, 0xa1, 0x77, 0xf2, 0x61, 0xec, 0xdc, 0x26, 0xbc, 0x08, 0x9d, 0x34, 0xc6,
+                0x40, 0x48, 0x46, 0xe9, 0xc6, 0x47, 0xfc, 0xfe, 0x98, 0xcc, 0x6a, 0xcd, 0xbb, 0x46,
+                0x4f, 0x64, 0x27, 0x8a, 0xd8, 0xce, 0x9d, 0x1a, 0xe0, 0xd4, 0x15, 0xbc, 0x0c, 0x05,
+                0x24, 0x5f, 0xdd, 0xaf, 0x4e, 0xbc, 0x8d, 0xc7, 0x03, 0xa8, 0x5c, 0xb2, 0x70, 0xf7,
+                0x96, 0xad, 0x2d, 0x93, 0x7e, 0x2a, 0xc0, 0xd5, 0xe0, 0xa3, 0x48, 0x21, 0x75, 0x80,
+                0x00, 0xaa, 0x59, 0xc9, 0xd4, 0x65, 0x24, 0x85, 0x29, 0x4e, 0xe0, 0xab, 0x29, 0x69,
+                0x6b, 0x21, 0x43, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ],
+            cv_net: [
+                0xf5, 0xc1, 0xcf, 0xbc, 0xb9, 0x2d, 0x34, 0xe4, 0x66, 0x1d, 0x58, 0x25, 0x42, 0xf7,
+                0x0d, 0x05, 0x99, 0x09, 0x15, 0x20, 0xfe, 0x2a, 0xfa, 0xd8, 0xe8, 0x75, 0xca, 0x3b,
+                0xcc, 0x70, 0x8a, 0x11,
+            ],
+            rho: [
+                0x31, 0x70, 0x5e, 0xfb, 0xf8, 0x0c, 0x7a, 0x7a, 0xb7, 0x81, 0xdf, 0x53, 0x77, 0xf8,
+                0x4d, 0x4b, 0x32, 0x36, 0xdb, 0x1f, 0x32, 0xac, 0xa7, 0x94, 0x5c, 0xf2, 0x6e, 0xc8,
+                0xb9, 0xd0, 0xb7, 0x32,
+            ],
+            cmx: [
+                0xe1, 0xc7, 0x67, 0xf3, 0x30, 0x15, 0xb5, 0xe2, 0x4a, 0x9a, 0xa5, 0x8b, 0x64, 0x7b,
+                0x6b, 0x61, 0x32, 0x3c, 0xd3, 0x47, 0xe7, 0x21, 0x4c, 0x29, 0x1d, 0x09, 0x95, 0xc0,
+                0xf5, 0xa6, 0x93, 0x2f,
+            ],
+            esk: [
+                0xc0, 0xdb, 0x43, 0x69, 0x10, 0x03, 0x45, 0x7d, 0x61, 0xfb, 0x58, 0x93, 0x20, 0x26,
+                0xf9, 0xdd, 0x2c, 0x35, 0xb9, 0x05, 0x7f, 0xad, 0x50, 0xd8, 0x44, 0x72, 0x83, 0xf9,
+                0x4e, 0xd5, 0x95, 0x3d,
+            ],
+            ephemeral_key: [
+                0xce, 0x67, 0x94, 0x31, 0x5f, 0x46, 0x2d, 0xed, 0xf3, 0xc5, 0x77, 0x4a, 0xac, 0x7f,
+                0x3c, 0x7b, 0x70, 0xba, 0x7d, 0x72, 0x43, 0xbb, 0x0c, 0xc3, 0xb0, 0x67, 0xdc, 0x28,
+                0x38, 0xf1, 0x11, 0xa3,
+            ],
+            shared_secret: [
+                0xea, 0x22, 0x6b, 0x69, 0xec, 0x2d, 0x9f, 0xcf, 0x91, 0x9c, 0xe5, 0x70, 0x06, 0x09,
+                0x89, 0x94, 0xf7, 0x14, 0xb3, 0x9c, 0x34, 0x61, 0x52, 0xbc, 0x11, 0x51, 0xa0, 0xc6,
+                0x9e, 0xe0, 0x04, 0x06,
+            ],
+            k_enc: [
+                0xb4, 0x56, 0x1b, 0xdb, 0xe0, 0xea, 0x44, 0x20, 0x75, 0xe7, 0xe6, 0x6f, 0xb3, 0xc0,
+                0xfa, 0xd3, 0xaf, 0xc2, 0x85, 0x6e, 0xf4, 0xf3, 0x61, 0xb4, 0xac, 0x33, 0xaa, 0xe0,
+                0x15, 0x52, 0xfd, 0x49,
+            ],
+            p_enc: [
+                0x03, 0xd2, 0xf7, 0x5f, 0x7c, 0xe7, 0x1b, 0xa4, 0xa7, 0xab, 0x69, 0xb8, 0x4a, 0x70,
+                0x91, 0xfe, 0x01, 0x5a, 0xda, 0x68, 0x13, 0xeb, 0x7c, 0xea, 0xa5, 0xff, 0x12, 0x90,
+                0xb0, 0x3e, 0xc9, 0x1c, 0xe6, 0xdd, 0x28, 0x13, 0x0c, 0x3a, 0xb0, 0xb2, 0x3b, 0x60,
+                0x2b, 0xd5, 0xbe, 0x5d, 0xc2, 0x60, 0x03, 0xaa, 0xe0, 0x4b, 0x29, 0x8a, 0xc0, 0xaf,
+                0xdc, 0x52, 0x87, 0xd7, 0xad, 0x12, 0x4c, 0xd9, 0x40, 0x5a, 0x62, 0xcd, 0x1c, 0xa0,
+                0x8b, 0x28, 0x2e, 0xfe, 0xf7, 0xf9, 0x28, 0xdf, 0x76, 0xe2, 0x82, 0x1a, 0x41, 0x84,
+                0xff, 0x33, 0xd7, 0xbd, 0x25, 0x90, 0xe9, 0x0c, 0x8c, 0x38, 0x8e, 0xa7, 0x95, 0x51,
+                0x22, 0xdb, 0xac, 0xa6, 0x7b, 0x30, 0x39, 0x5a, 0x92, 0x8b, 0x57, 0xb8, 0x57, 0x51,
+                0x23, 0x20, 0x5a, 0xe1, 0x91, 0x52, 0xe4, 0x1e, 0x00, 0x29, 0x31, 0xb4, 0x57, 0x46,
+                0x19, 0x8e, 0x5d, 0xd9, 0x57, 0x1a, 0x56, 0xa7, 0xe0, 0xd4, 0x23, 0xff, 0x27, 0x98,
+                0x9d, 0x3e, 0xb4, 0x17, 0xec, 0xd3, 0xc3, 0x09, 0x3f, 0xb8, 0x2c, 0x56, 0x58, 0xe2,
+                0x96, 0x24, 0xc5, 0x32, 0x19, 0xa6, 0x0c, 0xd0, 0xa8, 0xc4, 0xda, 0x36, 0x7e, 0x29,
+                0xa7, 0x17, 0x79, 0xa7, 0x30, 0x32, 0x98, 0x5a, 0x3d, 0x1f, 0xd0, 0x3d, 0xd4, 0xd0,
+                0x6e, 0x05, 0x56, 0x6f, 0x3b, 0x84, 0x36, 0x7c, 0xf0, 0xfa, 0xee, 0x9b, 0xc3, 0xbd,
+                0x7a, 0x3a, 0x60, 0x6a, 0x9f, 0xdb, 0x84, 0x9c, 0x5d, 0x82, 0xd0, 0xa6, 0x19, 0x23,
+                0xc2, 0xe5, 0xd8, 0xaa, 0x63, 0xa8, 0xa5, 0x0c, 0x38, 0xbd, 0x03, 0x87, 0x72, 0xc4,
+                0x14, 0x3d, 0x8b, 0x7a, 0xcf, 0xd7, 0x4e, 0x72, 0xc0, 0x4d, 0x89, 0x24, 0x8d, 0xff,
+                0x20, 0xfe, 0x8d, 0xc5, 0xec, 0x21, 0x49, 0x05, 0x4e, 0xa2, 0x41, 0x64, 0xe8, 0x5f,
+                0x67, 0x44, 0xad, 0x0c, 0xac, 0xf1, 0xa8, 0xb7, 0x01, 0x26, 0xf4, 0x82, 0xc0, 0x92,
+                0xed, 0x9f, 0x61, 0x27, 0xd2, 0x05, 0x0d, 0x12, 0xe8, 0x78, 0xa7, 0x96, 0x53, 0xa1,
+                0xe8, 0x4d, 0xae, 0xc3, 0xeb, 0xe6, 0x2d, 0x5f, 0x6c, 0x4a, 0xbe, 0x5c, 0xe9, 0x0a,
+                0x7f, 0xe2, 0xe5, 0x2a, 0x8d, 0x78, 0x46, 0xe8, 0xed, 0xf2, 0xf2, 0xbc, 0xe0, 0x5a,
+                0x03, 0x7c, 0x82, 0x6f, 0x22, 0xca, 0xad, 0x12, 0x61, 0x46, 0x7d, 0xcf, 0xb7, 0xd6,
+                0xb6, 0x13, 0x3d, 0xc2, 0x1e, 0x80, 0x96, 0xc7, 0xe9, 0xf8, 0xe9, 0xe1, 0x0c, 0x1e,
+                0x3f, 0xac, 0x40, 0x58, 0xb6, 0x82, 0xc6, 0x8e, 0x54, 0xfa, 0xca, 0xe0, 0xf9, 0xc2,
+                0xdd, 0x4d, 0x64, 0xd9, 0x04, 0x61, 0x52, 0xb4, 0x76, 0x23, 0x32, 0x93, 0x9f, 0x17,
+                0xe6, 0xaa, 0xf7, 0xd8, 0xb9, 0xd3, 0x58, 0xe2, 0x21, 0x8d, 0x4e, 0x0d, 0x69, 0xa4,
+                0xf1, 0x19, 0xe1, 0xc6, 0x4e, 0xec, 0x4c, 0x8b, 0x53, 0x28, 0x09, 0x70, 0x71, 0x31,
+                0xf0, 0x1f, 0x55, 0xc7, 0xad, 0x04, 0xcf, 0xb6, 0x3f, 0x7c, 0x4a, 0x3d, 0x0a, 0x2b,
+                0x0f, 0xfb, 0x0b, 0x05, 0xa6, 0xbe, 0x05, 0x5b, 0x8c, 0x94, 0xca, 0x80, 0xbb, 0x0a,
+                0x1d, 0x13, 0xcd, 0x4c, 0xd6, 0x9a, 0xb9, 0x83, 0x04, 0xae, 0x25, 0x15, 0xd5, 0xf7,
+                0x69, 0x9d, 0x4a, 0xbe, 0xe5, 0xc2, 0x0b, 0xe6, 0x09, 0xd8, 0x73, 0x51, 0x10, 0x12,
+                0xf2, 0x34, 0xbd, 0x85, 0xa7, 0xef, 0xf5, 0xfb, 0x63, 0x4c, 0xff, 0x26, 0x58, 0xba,
+                0x65, 0x16, 0x04, 0x85, 0x63, 0x09, 0x5e, 0xce, 0xfb, 0x30, 0x15, 0xee, 0x3f, 0x03,
+                0xca, 0x52, 0xa1, 0x77, 0xf2, 0x61, 0xec, 0xdc, 0x26, 0xbc, 0x08, 0x9d, 0x34, 0xc6,
+                0x40, 0x48, 0x46, 0xe9, 0xc6, 0x47, 0xfc, 0xfe, 0x98, 0xcc, 0x6a, 0xcd, 0xbb, 0x46,
+                0x4f, 0x64, 0x27, 0x8a, 0xd8, 0xce, 0x9d, 0x1a, 0xe0, 0xd4, 0x15, 0xbc, 0x0c, 0x05,
+                0x24, 0x5f, 0xdd, 0xaf, 0x4e, 0xbc, 0x8d, 0xc7, 0x03, 0xa8, 0x5c, 0xb2, 0x70, 0xf7,
+                0x96, 0xad, 0x2d, 0x93, 0x7e, 0x2a, 0xc0, 0xd5, 0xe0, 0xa3, 0x48, 0x21, 0x75, 0x80,
+                0x00, 0xaa, 0x59, 0xc9, 0xd4, 0x65, 0x24, 0x85, 0x29, 0x4e, 0xe0, 0xab, 0x29, 0x69,
+                0x6b, 0x21, 0x43, 0x0f,
+            ],
+            c_enc: [
+                0x59, 0x9a, 0x4d, 0x9f, 0x53, 0x3c, 0x46, 0xa9, 0x6f, 0x92, 0xaf, 0x8c, 0x08, 0xae,
+                0x59, 0x71, 0x10, 0x23, 0x0e, 0xb8, 0x41, 0xc2, 0xf7, 0xc9, 0xd4, 0xf1, 0x45, 0x87,
+                0x76, 0x36, 0xc8, 0x9d, 0xd8, 0xf3, 0x84, 0xa9, 0x40, 0xdc, 0x89, 0x72, 0x55, 0x53,
+                0x57, 0xbc, 0x07, 0x48, 0x2a, 0x0a, 0x32, 0x3d, 0x87, 0xae, 0x10, 0xeb, 0x99, 0x82,
+                0x5a, 0xe4, 0xe0, 0x06, 0x0e, 0x25, 0x6c, 0x3c, 0x3b, 0xeb, 0xa3, 0x2f, 0xa2, 0xb2,
+                0xd2, 0x7f, 0x04, 0x6f, 0x7a, 0x93, 0x6d, 0xf8, 0xa9, 0x61, 0xc8, 0x18, 0x4e, 0xe3,
+                0xc6, 0x8e, 0xbc, 0xe9, 0x80, 0x64, 0x45, 0xb4, 0x3e, 0x66, 0x67, 0x19, 0x95, 0xa2,
+                0x43, 0x7a, 0x7f, 0x70, 0x91, 0x47, 0x14, 0x8a, 0x76, 0x03, 0x6d, 0x25, 0x5e, 0xba,
+                0xc4, 0xd0, 0xd8, 0x34, 0x82, 0x93, 0x23, 0x9a, 0x78, 0x64, 0xe7, 0x9b, 0xef, 0xf7,
+                0x6f, 0x61, 0x50, 0xe0, 0xc4, 0xf4, 0x7a, 0x85, 0x26, 0xe3, 0xed, 0x06, 0x75, 0xfa,
+                0xc6, 0xac, 0xcc, 0x30, 0xa4, 0xd6, 0x73, 0xca, 0x80, 0x85, 0x95, 0x96, 0xfe, 0xc9,
+                0xcd, 0x6a, 0x93, 0xfb, 0xa0, 0xe8, 0x9e, 0xf5, 0x3f, 0x3e, 0x26, 0x74, 0xd3, 0x2a,
+                0x4b, 0x43, 0xf9, 0xa4, 0x38, 0x7d, 0xce, 0x33, 0xac, 0xa1, 0xe4, 0xff, 0xdc, 0x6d,
+                0x2d, 0x31, 0x89, 0xc6, 0x23, 0xca, 0x56, 0x4d, 0x03, 0xac, 0x5b, 0x35, 0xb1, 0xa7,
+                0x47, 0xff, 0x44, 0x6b, 0xc2, 0x5e, 0xd2, 0x2d, 0x09, 0x68, 0x2c, 0xef, 0x3a, 0x30,
+                0xff, 0xa5, 0xc4, 0x0e, 0x27, 0x70, 0xf1, 0x84, 0x98, 0xb1, 0x2f, 0x86, 0x8b, 0xa9,
+                0x2a, 0x13, 0xaa, 0x4f, 0xa2, 0x14, 0xb0, 0x62, 0xe3, 0x64, 0x9c, 0xf9, 0xc8, 0x5e,
+                0x7a, 0x8a, 0x55, 0xf5, 0xf3, 0xdd, 0x68, 0x84, 0x2a, 0xea, 0x7c, 0x92, 0x79, 0x2a,
+                0x52, 0x60, 0x0f, 0x86, 0x6c, 0x34, 0xa1, 0x0c, 0x51, 0x14, 0x13, 0x62, 0x02, 0x24,
+                0xfb, 0x85, 0xaf, 0xc6, 0x06, 0xdd, 0x4f, 0x7b, 0x2f, 0x76, 0xbe, 0x76, 0x0c, 0xa1,
+                0x94, 0xb6, 0xd4, 0x88, 0x2e, 0x5a, 0x4a, 0x76, 0x3d, 0x75, 0x0d, 0xb7, 0xe1, 0x68,
+                0xa4, 0x18, 0x11, 0x92, 0x35, 0xda, 0xf9, 0xcb, 0x1b, 0xdb, 0x07, 0xff, 0x46, 0x83,
+                0x3a, 0x87, 0xa3, 0x92, 0x6b, 0x14, 0xa5, 0x26, 0x4f, 0x10, 0x4f, 0x7f, 0x89, 0xf7,
+                0x6f, 0x10, 0x10, 0x8f, 0x2b, 0x6e, 0xa5, 0x05, 0xd4, 0xf0, 0xd2, 0x6d, 0x58, 0x31,
+                0x1c, 0xc7, 0x21, 0x9c, 0x6b, 0xc4, 0x38, 0xd0, 0xe1, 0xb3, 0x17, 0x60, 0x18, 0x73,
+                0x9e, 0x6f, 0x75, 0xd0, 0x73, 0x59, 0xf5, 0xe8, 0x95, 0x7e, 0x12, 0xc3, 0x03, 0xaa,
+                0x52, 0x9b, 0x11, 0xa1, 0x81, 0x66, 0x25, 0xa1, 0x20, 0xf3, 0x6d, 0xcd, 0xdd, 0xff,
+                0x9c, 0x65, 0xbc, 0xac, 0x8f, 0x10, 0x67, 0xc7, 0xfe, 0x88, 0xf6, 0x44, 0x85, 0x94,
+                0xcf, 0x1d, 0xff, 0x8e, 0x29, 0x00, 0xae, 0x84, 0xd2, 0xa7, 0xc8, 0x1b, 0x90, 0x6d,
+                0xd0, 0xbc, 0x86, 0x96, 0xe3, 0x70, 0x98, 0x07, 0x4b, 0x75, 0xd8, 0x38, 0xd8, 0xab,
+                0xdc, 0x90, 0x46, 0x08, 0x2b, 0xe4, 0xa6, 0x09, 0x95, 0xc4, 0xf4, 0xed, 0x80, 0xe2,
+                0xd7, 0x87, 0x38, 0x25, 0x77, 0x3b, 0xa6, 0x3e, 0xe4, 0xcb, 0x97, 0x36, 0x9a, 0x50,
+                0x70, 0xb5, 0x72, 0x5c, 0x5f, 0xeb, 0x32, 0x62, 0x45, 0x87, 0x80, 0x1e, 0x5a, 0xc0,
+                0x30, 0xe6, 0x45, 0xbd, 0xf2, 0xe5, 0x86, 0xcf, 0x98, 0x66, 0xea, 0xfb, 0x76, 0xf5,
+                0x59, 0x76, 0xa3, 0x3d, 0x62, 0xae, 0xdc, 0x76, 0x27, 0x78, 0x3b, 0x48, 0x48, 0x93,
+                0x61, 0xf9, 0x9c, 0xae, 0xb1, 0xb1, 0x9c, 0x55, 0x22, 0x58, 0x9f, 0xd2, 0x1d, 0x51,
+                0x45, 0x49, 0xd7, 0x4a, 0xb1, 0x92, 0x25, 0xed, 0x6e, 0x4c, 0x20, 0x3a, 0xdd, 0xfa,
+                0x55, 0xfc, 0x9e, 0xc9, 0x89, 0xb6, 0x69, 0x02, 0x3c, 0xf3, 0x05, 0xb4, 0x2b, 0x33,
+                0x0f, 0xc2, 0x30, 0x80, 0xab, 0xe4, 0x25, 0x01, 0xe5, 0x9c, 0x85, 0x1c, 0x54, 0xc7,
+                0x49, 0x66, 0xf6, 0x0b, 0xe9, 0xdc, 0x56, 0x1a, 0x2d, 0x91, 0xf5, 0xd3, 0x2a, 0xdd,
+                0x19, 0xb8, 0x9a, 0xca, 0x7a, 0x73, 0x85, 0x39, 0x59, 0x33, 0x48, 0x6f, 0xab, 0x00,
+                0xcc, 0x53, 0x03, 0xc5, 0xf3, 0xf0,
+            ],
+            ock: [
+                0xe3, 0xf2, 0x74, 0x2e, 0xa1, 0x97, 0x55, 0xa7, 0x99, 0x73, 0x1a, 0xcf, 0xe9, 0x98,
+                0x86, 0xfb, 0x9f, 0xbb, 0x80, 0x48, 0xb5, 0x3a, 0x77, 0x72, 0xa2, 0x80, 0xd8, 0x17,
+                0x19, 0xff, 0xfd, 0x28,
+            ],
+            op: [
+                0x49, 0x19, 0x01, 0x2e, 0x40, 0x43, 0x82, 0xeb, 0xee, 0x8e, 0x60, 0xe9, 0xd4, 0xf1,
+                0x30, 0x79, 0xc0, 0x8d, 0x9c, 0x6d, 0x50, 0xf9, 0x35, 0x86, 0x7d, 0x33, 0x01, 0xf6,
+                0x89, 0xcf, 0xf9, 0x1e, 0xc0, 0xdb, 0x43, 0x69, 0x10, 0x03, 0x45, 0x7d, 0x61, 0xfb,
+                0x58, 0x93, 0x20, 0x26, 0xf9, 0xdd, 0x2c, 0x35, 0xb9, 0x05, 0x7f, 0xad, 0x50, 0xd8,
+                0x44, 0x72, 0x83, 0xf9, 0x4e, 0xd5, 0x95, 0x3d,
+            ],
+            c_out: [
+                0x92, 0xe7, 0x7c, 0x9b, 0x69, 0x92, 0xee, 0x85, 0x06, 0x30, 0x6a, 0x96, 0xc8, 0xa5,
+                0x1c, 0xc9, 0xa8, 0x96, 0x18, 0xc6, 0x36, 0x6f, 0xce, 0x78, 0xb2, 0x9a, 0xdb, 0x10,
+                0x9b, 0x4a, 0x3b, 0x17, 0x48, 0x49, 0x13, 0x4f, 0x7a, 0xa2, 0x9c, 0x79, 0x1b, 0x91,
+                0x5f, 0xd7, 0x5a, 0x6f, 0xfc, 0x57, 0x42, 0x78, 0xef, 0x50, 0x2b, 0x84, 0x02, 0x46,
+                0x9a, 0xb5, 0xa7, 0xce, 0x77, 0x2b, 0x52, 0x2c, 0x4b, 0xaa, 0x12, 0x95, 0xd8, 0x8f,
+                0x15, 0xdc, 0x75, 0x1d, 0xdf, 0x7d, 0x20, 0x8d, 0xd5, 0x17,
+            ],
+            note_type: Some([
+                0x29, 0x8a, 0xc0, 0xaf, 0xdc, 0x52, 0x87, 0xd7, 0xad, 0x12, 0x4c, 0xd9, 0x40, 0x5a,
+                0x62, 0xcd, 0x1c, 0xa0, 0x8b, 0x28, 0x2e, 0xfe, 0xf7, 0xf9, 0x28, 0xdf, 0x76, 0xe2,
+                0x82, 0x1a, 0x41, 0x84,
+            ]),
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x53, 0x3d, 0xc3, 0xd4, 0x93, 0xf2, 0xb8, 0x7a, 0x03, 0x3d, 0xf5, 0x07, 0x05, 0xf2,
+                0x90, 0x54, 0x16, 0x38, 0xe9, 0x08, 0x7d, 0xcd, 0xbc, 0xfe, 0x52, 0x7e, 0x77, 0x5a,
+                0xaf, 0x09, 0x30, 0x29, 0xac, 0xec, 0x74, 0xdd, 0xe6, 0x02, 0xfc, 0x7c, 0x73, 0xcb,
+                0x38, 0x50, 0xbd, 0xfb, 0xf2, 0x61, 0x79, 0x4c, 0x9c, 0x29, 0x9d, 0x0b, 0x98, 0xee,
+                0x0f, 0x20, 0x71, 0xd6, 0xd4, 0xe3, 0x7b, 0x05,
+            ],
+            ovk: [
+                0x32, 0x4d, 0xce, 0x2a, 0x1e, 0xa1, 0xe4, 0x30, 0x4f, 0x49, 0xe4, 0x3a, 0xe0, 0x65,
+                0xe3, 0xfb, 0x19, 0x6f, 0x76, 0xd9, 0xb8, 0x79, 0xc7, 0x20, 0x08, 0x62, 0xea, 0xd1,
+                0x8d, 0xea, 0x5f, 0xb6,
+            ],
+            default_d: [
+                0x20, 0x8c, 0x6d, 0x90, 0x6c, 0xfa, 0x93, 0xf1, 0x2d, 0x6a, 0x7e,
+            ],
+            default_pk_d: [
+                0x64, 0xce, 0xac, 0xec, 0x3c, 0x2e, 0xa7, 0x9c, 0x4c, 0xd3, 0xe2, 0xf0, 0xfb, 0xb9,
+                0xe1, 0xd4, 0x39, 0x55, 0xae, 0x66, 0xd8, 0x93, 0x92, 0xbf, 0x48, 0xaf, 0xb6, 0xc4,
+                0xab, 0x00, 0xa0, 0x28,
+            ],
+            v: 12711846894898776584,
+            rseed: [
+                0x7b, 0xdc, 0x8b, 0xa3, 0xe4, 0xe3, 0xd1, 0xd9, 0x33, 0xbf, 0xb5, 0x80, 0xf5, 0xb3,
+                0xe8, 0x7a, 0x2a, 0x06, 0x51, 0x70, 0x51, 0x41, 0x0f, 0xe1, 0xb4, 0xff, 0x1e, 0xa0,
+                0xad, 0xe8, 0x24, 0xf3,
+            ],
+            memo: [
+                0xff, 0x38, 0x51, 0x54, 0x56, 0xa5, 0x7c, 0x7a, 0x91, 0x6a, 0x74, 0x38, 0x8e, 0xe8,
+                0xf1, 0x28, 0x1f, 0x9a, 0xde, 0x0a, 0xe2, 0xa2, 0x61, 0x3a, 0x06, 0x12, 0xc4, 0x69,
+                0xdf, 0x79, 0x2b, 0x8d, 0xf4, 0xca, 0xe4, 0xfc, 0x25, 0xc1, 0xca, 0xdb, 0xa9, 0x5a,
+                0x80, 0x7c, 0xe6, 0x1e, 0x5a, 0x53, 0x03, 0xfa, 0xaf, 0x9e, 0x14, 0x65, 0x39, 0x96,
+                0xb5, 0xa8, 0xad, 0xc3, 0x4f, 0xd4, 0x75, 0xef, 0x14, 0x99, 0x09, 0x4b, 0xab, 0xaf,
+                0x1f, 0x3f, 0x07, 0xda, 0x9a, 0x39, 0x0b, 0x1d, 0x9f, 0xc9, 0xa0, 0x83, 0x27, 0x98,
+                0x7a, 0xdf, 0xe9, 0x56, 0x48, 0x63, 0xfb, 0xdf, 0xa8, 0xf6, 0xb4, 0x6a, 0x88, 0x41,
+                0x58, 0x30, 0x99, 0xaf, 0xb7, 0x87, 0x01, 0x18, 0xfa, 0xce, 0x76, 0x34, 0x7e, 0x40,
+                0xb6, 0xfd, 0x8c, 0xd1, 0x55, 0x82, 0xae, 0x8e, 0x23, 0xbe, 0x9a, 0x02, 0x19, 0xbc,
+                0x3e, 0x4e, 0x45, 0x46, 0xa3, 0x0d, 0x3b, 0xbb, 0xbd, 0x16, 0x86, 0x08, 0x68, 0x76,
+                0xbe, 0x0e, 0x4c, 0x85, 0x9b, 0xe7, 0x1f, 0xb5, 0x8f, 0x4f, 0xab, 0x3d, 0x28, 0xc0,
+                0xb4, 0xf7, 0xe7, 0x5a, 0xd1, 0xed, 0xb7, 0xf8, 0x89, 0x46, 0xfb, 0x40, 0xcf, 0xa5,
+                0x78, 0x6a, 0x0f, 0xcb, 0xa1, 0x30, 0x3c, 0x83, 0x47, 0xec, 0xee, 0x93, 0xd4, 0x6d,
+                0x14, 0x0b, 0xb5, 0xf6, 0x95, 0x31, 0xd6, 0x66, 0x54, 0x8b, 0x10, 0x9c, 0xe7, 0x64,
+                0xbe, 0xad, 0x7c, 0x87, 0xbd, 0x4c, 0x87, 0x64, 0x94, 0xde, 0x82, 0xdb, 0x6e, 0x50,
+                0x73, 0xa6, 0xc9, 0x4f, 0x7c, 0x09, 0x9a, 0x40, 0xd7, 0xa3, 0x1c, 0x4a, 0x04, 0xb6,
+                0x9c, 0x9f, 0xcc, 0xf3, 0xc7, 0xdd, 0x56, 0xf5, 0x54, 0x47, 0x76, 0xc5, 0x3b, 0x4d,
+                0xf7, 0x95, 0x39, 0x81, 0xd5, 0x5a, 0x96, 0xa6, 0xdc, 0xff, 0x99, 0x04, 0xa9, 0x08,
+                0x42, 0xe5, 0xba, 0xfe, 0xc8, 0x84, 0x0c, 0x2d, 0x25, 0x5b, 0xf5, 0xad, 0x61, 0xc4,
+                0x60, 0xf9, 0x8f, 0xeb, 0x82, 0xa1, 0x0f, 0xa1, 0xc0, 0x99, 0xf6, 0x27, 0x76, 0x79,
+                0x82, 0x36, 0xc5, 0xca, 0x7f, 0x1e, 0x46, 0xeb, 0xdb, 0x2b, 0x14, 0x4d, 0x87, 0x13,
+                0xe5, 0x6c, 0x77, 0x2f, 0x2c, 0x3b, 0x86, 0x0e, 0xa5, 0xb0, 0x3a, 0x88, 0x54, 0xbc,
+                0x6e, 0x65, 0x90, 0xd6, 0x3c, 0xc0, 0xea, 0x54, 0xf1, 0x0b, 0x73, 0xba, 0x24, 0x1b,
+                0xf7, 0x4b, 0x63, 0x55, 0x51, 0xa2, 0xaa, 0xca, 0x96, 0x87, 0xac, 0x52, 0x69, 0xfd,
+                0x36, 0x8b, 0x26, 0xd7, 0x0a, 0x73, 0x7f, 0x26, 0x76, 0x85, 0x99, 0x8a, 0x3f, 0x7d,
+                0x26, 0x37, 0x91, 0x49, 0x09, 0xc7, 0x46, 0x49, 0x5d, 0x24, 0xc4, 0x98, 0x63, 0x5e,
+                0xf9, 0x7a, 0xc6, 0x6a, 0x40, 0x08, 0x94, 0xc0, 0x9f, 0x73, 0x48, 0x8e, 0xb7, 0xcf,
+                0x33, 0xf6, 0xda, 0xd1, 0x66, 0x6a, 0x05, 0xf9, 0x1a, 0xd7, 0x75, 0x79, 0x65, 0xc2,
+                0x99, 0x36, 0xe7, 0xfa, 0x48, 0xd7, 0x7e, 0x89, 0xee, 0x09, 0x62, 0xf5, 0x8c, 0x05,
+                0x1d, 0x11, 0xd0, 0x55, 0xfc, 0xe2, 0x04, 0xa5, 0x62, 0xde, 0x68, 0x08, 0x8a, 0x1b,
+                0x26, 0x48, 0xb8, 0x17, 0x4c, 0xbc, 0xfc, 0x8b, 0x5b, 0x5c, 0xd0, 0x77, 0x11, 0x5a,
+                0xfd, 0xe1, 0x84, 0x05, 0x05, 0x4e, 0x5d, 0xa9, 0xa0, 0x43, 0x10, 0x34, 0x2c, 0x5d,
+                0x3b, 0x52, 0x6e, 0x0b, 0x02, 0xc5, 0xca, 0x17, 0x22, 0xba, 0xde, 0xee, 0x23, 0xd1,
+                0x45, 0xe8, 0xeb, 0x22, 0x13, 0xfc, 0x4a, 0xf1, 0xe4, 0x50, 0xe4, 0xd5, 0x21, 0x7c,
+                0x66, 0x17, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ],
+            cv_net: [
+                0x65, 0x73, 0x3c, 0x9d, 0x97, 0xea, 0x82, 0xf6, 0xde, 0xf3, 0xde, 0x1f, 0xe8, 0x7e,
+                0x12, 0x37, 0x6a, 0x92, 0x49, 0xdc, 0x86, 0x14, 0x67, 0x2d, 0x5e, 0xda, 0x15, 0xf3,
+                0xca, 0xf4, 0x5b, 0x8c,
+            ],
+            rho: [
+                0x56, 0xbc, 0x48, 0x21, 0xa5, 0x3d, 0x5e, 0x9e, 0x6d, 0x7a, 0x04, 0x44, 0x44, 0x45,
+                0x4f, 0xfb, 0xc2, 0x36, 0x9c, 0xb1, 0x48, 0xeb, 0x76, 0xf1, 0xed, 0xf1, 0xb5, 0xc7,
+                0x41, 0x84, 0x28, 0x2a,
+            ],
+            cmx: [
+                0xd7, 0x60, 0xac, 0xdb, 0xca, 0xda, 0xd1, 0x88, 0x08, 0x4f, 0xe4, 0x1a, 0x5c, 0x03,
+                0xc2, 0xc8, 0xce, 0x34, 0xe1, 0x5f, 0x9d, 0xf4, 0x7b, 0x86, 0x9c, 0x44, 0xc7, 0x21,
+                0x13, 0xa4, 0x0c, 0x3d,
+            ],
+            esk: [
+                0x9b, 0x32, 0x77, 0x19, 0x3b, 0x63, 0x60, 0x8e, 0x6a, 0x3d, 0xdf, 0x7c, 0xe2, 0xd2,
+                0x33, 0x58, 0x4e, 0x66, 0x17, 0xd6, 0xf6, 0xa2, 0x1c, 0xdc, 0x86, 0x48, 0x56, 0x2c,
+                0xbd, 0x86, 0x3f, 0x09,
+            ],
+            ephemeral_key: [
+                0x5a, 0x48, 0x58, 0x15, 0xc4, 0xa7, 0x47, 0x06, 0xe9, 0xde, 0x87, 0xfa, 0x60, 0xa2,
+                0x81, 0x6f, 0x89, 0x0b, 0xe3, 0xdb, 0x54, 0xeb, 0x3f, 0x4b, 0xaf, 0x37, 0xdb, 0xc9,
+                0xbd, 0xe5, 0xfe, 0x9d,
+            ],
+            shared_secret: [
+                0x96, 0x8d, 0xf2, 0xe8, 0x5d, 0x7b, 0xd1, 0x08, 0xf5, 0x72, 0x12, 0x53, 0x93, 0x76,
+                0xaf, 0x25, 0x83, 0x2e, 0xf4, 0xdb, 0xd6, 0x40, 0x2a, 0x41, 0x4d, 0x73, 0xc5, 0x6b,
+                0xee, 0xe4, 0xf2, 0xa8,
+            ],
+            k_enc: [
+                0xf7, 0x73, 0x91, 0x24, 0x3f, 0xdb, 0x35, 0xb2, 0x26, 0x94, 0xdb, 0x91, 0xde, 0xbd,
+                0x78, 0x55, 0x79, 0x3c, 0xa7, 0x1e, 0x82, 0xbd, 0xc2, 0xee, 0x74, 0xc9, 0xb7, 0xb6,
+                0x97, 0xc0, 0x24, 0x71,
+            ],
+            p_enc: [
+                0x03, 0x20, 0x8c, 0x6d, 0x90, 0x6c, 0xfa, 0x93, 0xf1, 0x2d, 0x6a, 0x7e, 0x08, 0x0a,
+                0x98, 0x91, 0x66, 0x8d, 0x69, 0xb0, 0x7b, 0xdc, 0x8b, 0xa3, 0xe4, 0xe3, 0xd1, 0xd9,
+                0x33, 0xbf, 0xb5, 0x80, 0xf5, 0xb3, 0xe8, 0x7a, 0x2a, 0x06, 0x51, 0x70, 0x51, 0x41,
+                0x0f, 0xe1, 0xb4, 0xff, 0x1e, 0xa0, 0xad, 0xe8, 0x24, 0xf3, 0xf9, 0x78, 0x1e, 0xbe,
+                0x31, 0x7a, 0x07, 0x10, 0xae, 0x54, 0x61, 0xe3, 0x4f, 0xe6, 0xf1, 0xb1, 0xaa, 0x9b,
+                0x4e, 0x67, 0xb1, 0x49, 0x10, 0x98, 0x48, 0x02, 0xc2, 0xa7, 0xe3, 0x81, 0x93, 0xbc,
+                0xff, 0x38, 0x51, 0x54, 0x56, 0xa5, 0x7c, 0x7a, 0x91, 0x6a, 0x74, 0x38, 0x8e, 0xe8,
+                0xf1, 0x28, 0x1f, 0x9a, 0xde, 0x0a, 0xe2, 0xa2, 0x61, 0x3a, 0x06, 0x12, 0xc4, 0x69,
+                0xdf, 0x79, 0x2b, 0x8d, 0xf4, 0xca, 0xe4, 0xfc, 0x25, 0xc1, 0xca, 0xdb, 0xa9, 0x5a,
+                0x80, 0x7c, 0xe6, 0x1e, 0x5a, 0x53, 0x03, 0xfa, 0xaf, 0x9e, 0x14, 0x65, 0x39, 0x96,
+                0xb5, 0xa8, 0xad, 0xc3, 0x4f, 0xd4, 0x75, 0xef, 0x14, 0x99, 0x09, 0x4b, 0xab, 0xaf,
+                0x1f, 0x3f, 0x07, 0xda, 0x9a, 0x39, 0x0b, 0x1d, 0x9f, 0xc9, 0xa0, 0x83, 0x27, 0x98,
+                0x7a, 0xdf, 0xe9, 0x56, 0x48, 0x63, 0xfb, 0xdf, 0xa8, 0xf6, 0xb4, 0x6a, 0x88, 0x41,
+                0x58, 0x30, 0x99, 0xaf, 0xb7, 0x87, 0x01, 0x18, 0xfa, 0xce, 0x76, 0x34, 0x7e, 0x40,
+                0xb6, 0xfd, 0x8c, 0xd1, 0x55, 0x82, 0xae, 0x8e, 0x23, 0xbe, 0x9a, 0x02, 0x19, 0xbc,
+                0x3e, 0x4e, 0x45, 0x46, 0xa3, 0x0d, 0x3b, 0xbb, 0xbd, 0x16, 0x86, 0x08, 0x68, 0x76,
+                0xbe, 0x0e, 0x4c, 0x85, 0x9b, 0xe7, 0x1f, 0xb5, 0x8f, 0x4f, 0xab, 0x3d, 0x28, 0xc0,
+                0xb4, 0xf7, 0xe7, 0x5a, 0xd1, 0xed, 0xb7, 0xf8, 0x89, 0x46, 0xfb, 0x40, 0xcf, 0xa5,
+                0x78, 0x6a, 0x0f, 0xcb, 0xa1, 0x30, 0x3c, 0x83, 0x47, 0xec, 0xee, 0x93, 0xd4, 0x6d,
+                0x14, 0x0b, 0xb5, 0xf6, 0x95, 0x31, 0xd6, 0x66, 0x54, 0x8b, 0x10, 0x9c, 0xe7, 0x64,
+                0xbe, 0xad, 0x7c, 0x87, 0xbd, 0x4c, 0x87, 0x64, 0x94, 0xde, 0x82, 0xdb, 0x6e, 0x50,
+                0x73, 0xa6, 0xc9, 0x4f, 0x7c, 0x09, 0x9a, 0x40, 0xd7, 0xa3, 0x1c, 0x4a, 0x04, 0xb6,
+                0x9c, 0x9f, 0xcc, 0xf3, 0xc7, 0xdd, 0x56, 0xf5, 0x54, 0x47, 0x76, 0xc5, 0x3b, 0x4d,
+                0xf7, 0x95, 0x39, 0x81, 0xd5, 0x5a, 0x96, 0xa6, 0xdc, 0xff, 0x99, 0x04, 0xa9, 0x08,
+                0x42, 0xe5, 0xba, 0xfe, 0xc8, 0x84, 0x0c, 0x2d, 0x25, 0x5b, 0xf5, 0xad, 0x61, 0xc4,
+                0x60, 0xf9, 0x8f, 0xeb, 0x82, 0xa1, 0x0f, 0xa1, 0xc0, 0x99, 0xf6, 0x27, 0x76, 0x79,
+                0x82, 0x36, 0xc5, 0xca, 0x7f, 0x1e, 0x46, 0xeb, 0xdb, 0x2b, 0x14, 0x4d, 0x87, 0x13,
+                0xe5, 0x6c, 0x77, 0x2f, 0x2c, 0x3b, 0x86, 0x0e, 0xa5, 0xb0, 0x3a, 0x88, 0x54, 0xbc,
+                0x6e, 0x65, 0x90, 0xd6, 0x3c, 0xc0, 0xea, 0x54, 0xf1, 0x0b, 0x73, 0xba, 0x24, 0x1b,
+                0xf7, 0x4b, 0x63, 0x55, 0x51, 0xa2, 0xaa, 0xca, 0x96, 0x87, 0xac, 0x52, 0x69, 0xfd,
+                0x36, 0x8b, 0x26, 0xd7, 0x0a, 0x73, 0x7f, 0x26, 0x76, 0x85, 0x99, 0x8a, 0x3f, 0x7d,
+                0x26, 0x37, 0x91, 0x49, 0x09, 0xc7, 0x46, 0x49, 0x5d, 0x24, 0xc4, 0x98, 0x63, 0x5e,
+                0xf9, 0x7a, 0xc6, 0x6a, 0x40, 0x08, 0x94, 0xc0, 0x9f, 0x73, 0x48, 0x8e, 0xb7, 0xcf,
+                0x33, 0xf6, 0xda, 0xd1, 0x66, 0x6a, 0x05, 0xf9, 0x1a, 0xd7, 0x75, 0x79, 0x65, 0xc2,
+                0x99, 0x36, 0xe7, 0xfa, 0x48, 0xd7, 0x7e, 0x89, 0xee, 0x09, 0x62, 0xf5, 0x8c, 0x05,
+                0x1d, 0x11, 0xd0, 0x55, 0xfc, 0xe2, 0x04, 0xa5, 0x62, 0xde, 0x68, 0x08, 0x8a, 0x1b,
+                0x26, 0x48, 0xb8, 0x17, 0x4c, 0xbc, 0xfc, 0x8b, 0x5b, 0x5c, 0xd0, 0x77, 0x11, 0x5a,
+                0xfd, 0xe1, 0x84, 0x05, 0x05, 0x4e, 0x5d, 0xa9, 0xa0, 0x43, 0x10, 0x34, 0x2c, 0x5d,
+                0x3b, 0x52, 0x6e, 0x0b, 0x02, 0xc5, 0xca, 0x17, 0x22, 0xba, 0xde, 0xee, 0x23, 0xd1,
+                0x45, 0xe8, 0xeb, 0x22, 0x13, 0xfc, 0x4a, 0xf1, 0xe4, 0x50, 0xe4, 0xd5, 0x21, 0x7c,
+                0x66, 0x17, 0x00, 0x8c,
+            ],
+            c_enc: [
+                0xf9, 0x09, 0x97, 0x73, 0x8b, 0x14, 0xd8, 0xa8, 0x4e, 0x32, 0x74, 0xbb, 0x70, 0x76,
+                0x31, 0x15, 0xb7, 0x2e, 0x0a, 0x3d, 0xde, 0x8e, 0xa4, 0x70, 0x91, 0x1f, 0xb4, 0x58,
+                0x70, 0xb0, 0x14, 0x8e, 0x7d, 0x37, 0x2b, 0xf2, 0x26, 0x8b, 0x3e, 0xe8, 0xda, 0xe5,
+                0xfd, 0xe5, 0xea, 0x9b, 0x61, 0x59, 0x8e, 0xf1, 0x1b, 0x73, 0x14, 0x4f, 0x75, 0x53,
+                0xb2, 0x13, 0xa0, 0x4c, 0x85, 0xf2, 0x5c, 0x54, 0x6c, 0x8a, 0x38, 0xa6, 0x0e, 0x50,
+                0x86, 0x08, 0xb9, 0xca, 0x59, 0x3b, 0x94, 0xd8, 0x68, 0x8d, 0x6e, 0xff, 0xa5, 0x36,
+                0x04, 0xd4, 0xdb, 0xc0, 0xf3, 0x45, 0x03, 0xaa, 0xe4, 0x6f, 0x3c, 0x8a, 0x8d, 0x2e,
+                0x46, 0xa8, 0x1f, 0x09, 0x12, 0x6c, 0x45, 0x36, 0xfd, 0x02, 0x58, 0xf5, 0x97, 0x40,
+                0xad, 0x0d, 0xb8, 0x02, 0xcc, 0x02, 0x42, 0x53, 0x4d, 0xdf, 0x52, 0xa6, 0xbf, 0x6a,
+                0x03, 0x4d, 0xe6, 0x26, 0xf0, 0x18, 0x84, 0x4a, 0xdc, 0xb2, 0x6d, 0xcd, 0xc2, 0x85,
+                0x16, 0x37, 0x16, 0xdd, 0x54, 0x65, 0x1c, 0x88, 0x73, 0x53, 0xf1, 0xff, 0xef, 0xa0,
+                0x37, 0x71, 0x2a, 0xc0, 0xdf, 0x3a, 0x92, 0x98, 0x19, 0x06, 0x87, 0x54, 0x9d, 0x79,
+                0xc6, 0xa3, 0x60, 0x0c, 0xc1, 0xc7, 0x29, 0xa3, 0x93, 0xd4, 0x4f, 0xec, 0xe5, 0x7f,
+                0xd4, 0xcb, 0x0c, 0x0f, 0xb0, 0xc7, 0x86, 0x1b, 0x92, 0x5b, 0x94, 0xcd, 0x6a, 0x26,
+                0x90, 0xf0, 0x02, 0xc4, 0x3a, 0x16, 0x6e, 0x56, 0x77, 0x72, 0x9f, 0x35, 0x52, 0xae,
+                0xe0, 0xf2, 0xc1, 0x95, 0xaa, 0x91, 0xb2, 0xdd, 0xe3, 0x65, 0xdd, 0x14, 0xf2, 0xf0,
+                0x7b, 0x3c, 0x38, 0x34, 0x7f, 0x6c, 0x0d, 0xab, 0x82, 0x84, 0x1e, 0xba, 0xde, 0x1e,
+                0xf8, 0x13, 0xf2, 0xcd, 0x88, 0x5b, 0x57, 0x84, 0x37, 0x44, 0x45, 0x24, 0x93, 0x6a,
+                0x65, 0x46, 0xc4, 0x55, 0xd6, 0xc9, 0x2e, 0x6d, 0x3d, 0xc5, 0x38, 0xb6, 0xcd, 0x9f,
+                0x6d, 0x4c, 0xc0, 0xd7, 0x4d, 0x7b, 0xc2, 0x46, 0x7e, 0x21, 0x5b, 0xe8, 0xc3, 0xd4,
+                0xff, 0x91, 0x8a, 0x2d, 0x98, 0x71, 0x00, 0xff, 0x34, 0x02, 0x4c, 0x88, 0x62, 0x79,
+                0xd6, 0x4c, 0xaf, 0xdf, 0xd9, 0x0f, 0x1c, 0x04, 0xc4, 0x6b, 0xc9, 0xd5, 0xe9, 0xe2,
+                0xaf, 0xd0, 0x3a, 0xb7, 0x55, 0xe4, 0x0f, 0x08, 0x7e, 0xb5, 0x1e, 0xe3, 0xd1, 0x02,
+                0xb6, 0xb0, 0x69, 0xb6, 0x50, 0xf5, 0xd8, 0x55, 0x03, 0x35, 0x47, 0x1b, 0x24, 0x46,
+                0x5d, 0x93, 0x4d, 0x63, 0x34, 0x39, 0xb1, 0x08, 0xd9, 0x04, 0x2b, 0x37, 0xf9, 0xf7,
+                0x2e, 0x74, 0xfd, 0x6b, 0xa0, 0x01, 0x58, 0x5b, 0x08, 0x62, 0xdb, 0x99, 0x4a, 0x5e,
+                0xc1, 0x2d, 0xc9, 0x1e, 0x01, 0x48, 0x6a, 0x8d, 0xc6, 0x8a, 0xb9, 0xa3, 0x41, 0x93,
+                0x52, 0x61, 0x73, 0xec, 0xc0, 0xd1, 0x55, 0xb5, 0xcd, 0xd6, 0xbc, 0x07, 0xe6, 0x3e,
+                0x41, 0xaf, 0x9e, 0x52, 0x4c, 0xd3, 0xe6, 0x55, 0x5d, 0x38, 0xb4, 0x6d, 0xb2, 0xd9,
+                0x9e, 0x5b, 0xa4, 0xa4, 0x95, 0xff, 0x30, 0xfe, 0xf2, 0x54, 0xc9, 0xfe, 0x7b, 0x79,
+                0x0c, 0xe5, 0x6a, 0x40, 0xf4, 0x00, 0x27, 0xbb, 0x62, 0x05, 0x86, 0x38, 0xc4, 0x94,
+                0x17, 0x7b, 0x7f, 0x5c, 0x8f, 0x29, 0x44, 0x9e, 0x9e, 0xc3, 0xbd, 0xb3, 0xab, 0x04,
+                0x16, 0x0d, 0x96, 0xd0, 0xd4, 0x04, 0x79, 0x5d, 0x54, 0x28, 0x40, 0x82, 0xb6, 0x35,
+                0x7d, 0x58, 0x1d, 0xc2, 0x64, 0x81, 0x13, 0x67, 0xbb, 0xb1, 0x31, 0x9a, 0x31, 0xf7,
+                0x66, 0x4a, 0x4e, 0xca, 0x93, 0x2a, 0xbb, 0xd7, 0x33, 0xa7, 0x1a, 0x31, 0xaf, 0x23,
+                0x11, 0xc4, 0x9a, 0xc9, 0xaf, 0x22, 0xf8, 0x16, 0x7b, 0x25, 0x51, 0xac, 0xf5, 0x73,
+                0xd9, 0x1b, 0x40, 0x98, 0xc4, 0xde, 0xa8, 0xa9, 0x79, 0x9d, 0x9d, 0x54, 0x52, 0x0c,
+                0xc6, 0x3e, 0x55, 0x71, 0x8a, 0x24, 0x85, 0xbf, 0x6f, 0x63, 0x16, 0x30, 0x7c, 0xea,
+                0x21, 0x5e, 0x22, 0x22, 0x8d, 0x45, 0x34, 0x9a, 0x03, 0x50, 0x31, 0xa4, 0xcb, 0x67,
+                0x7b, 0x52, 0x3a, 0x3a, 0x51, 0x25, 0x2c, 0x6c, 0x61, 0xd0, 0xe2, 0x43, 0x2b, 0x94,
+                0xac, 0x9c, 0x0d, 0xb5, 0x40, 0xf3, 0x5b, 0x1d, 0xde, 0x91, 0xa3, 0xaf, 0x37, 0xa6,
+                0x71, 0xb8, 0xaa, 0x9f, 0x69, 0xf0,
+            ],
+            ock: [
+                0x42, 0x46, 0x14, 0xa3, 0xb5, 0x79, 0x96, 0xef, 0xb1, 0x24, 0xb7, 0xf4, 0x50, 0xae,
+                0x2a, 0xf7, 0xf6, 0xdc, 0x8c, 0x8c, 0xee, 0xa9, 0x4f, 0x17, 0x74, 0x77, 0x72, 0x1b,
+                0x84, 0x61, 0x3b, 0x23,
+            ],
+            op: [
+                0x64, 0xce, 0xac, 0xec, 0x3c, 0x2e, 0xa7, 0x9c, 0x4c, 0xd3, 0xe2, 0xf0, 0xfb, 0xb9,
+                0xe1, 0xd4, 0x39, 0x55, 0xae, 0x66, 0xd8, 0x93, 0x92, 0xbf, 0x48, 0xaf, 0xb6, 0xc4,
+                0xab, 0x00, 0xa0, 0x28, 0x9b, 0x32, 0x77, 0x19, 0x3b, 0x63, 0x60, 0x8e, 0x6a, 0x3d,
+                0xdf, 0x7c, 0xe2, 0xd2, 0x33, 0x58, 0x4e, 0x66, 0x17, 0xd6, 0xf6, 0xa2, 0x1c, 0xdc,
+                0x86, 0x48, 0x56, 0x2c, 0xbd, 0x86, 0x3f, 0x09,
             ],
             c_out: [
-                0xca, 0xb7, 0x8d, 0xd1, 0x83, 0xf3, 0xe1, 0x6a, 0xf7, 0x6e, 0x9a, 0x90, 0x3d, 0xd4,
-                0x2a, 0x96, 0x67, 0xbf, 0xe7, 0x08, 0xce, 0x88, 0x79, 0xb8, 0x38, 0x6e, 0x62, 0xac,
-                0x9f, 0x66, 0x74, 0xf4, 0x93, 0x59, 0x5d, 0xa5, 0x06, 0xe9, 0xef, 0x06, 0xbb, 0xa2,
-                0x4a, 0x93, 0x80, 0x60, 0xe5, 0xd3, 0x82, 0xcc, 0x75, 0xdf, 0xab, 0x97, 0xe0, 0xf8,
-                0x49, 0x4b, 0x47, 0x6a, 0xdf, 0x4f, 0xfd, 0x96, 0xff, 0x7f, 0x1b, 0x4f, 0x16, 0xf8,
-                0x59, 0x4b, 0x7c, 0x5a, 0x21, 0x9c, 0x7a, 0x00, 0xad, 0x15,
+                0x8b, 0x94, 0x8b, 0x33, 0xf5, 0x55, 0xcd, 0x45, 0x5f, 0xaa, 0x36, 0x51, 0x7b, 0x8e,
+                0xab, 0x29, 0xe1, 0xa5, 0x1f, 0x6c, 0xec, 0x21, 0x79, 0xd9, 0xea, 0xe4, 0xea, 0xca,
+                0x92, 0x50, 0xbb, 0x9b, 0x55, 0xe4, 0xb5, 0x49, 0x49, 0x15, 0xc1, 0xf0, 0x01, 0x65,
+                0xf8, 0x9d, 0x7c, 0x02, 0xa0, 0x25, 0x45, 0xb9, 0xd5, 0x98, 0x08, 0x6e, 0xeb, 0x96,
+                0x1e, 0x58, 0x7e, 0x43, 0xfd, 0xfc, 0x65, 0xfe, 0x52, 0xf1, 0xe0, 0xc6, 0xa0, 0x46,
+                0x46, 0x48, 0xcd, 0x1f, 0xc8, 0x9e, 0x80, 0xbd, 0x78, 0x0f,
+            ],
+            note_type: Some([
+                0xf9, 0x78, 0x1e, 0xbe, 0x31, 0x7a, 0x07, 0x10, 0xae, 0x54, 0x61, 0xe3, 0x4f, 0xe6,
+                0xf1, 0xb1, 0xaa, 0x9b, 0x4e, 0x67, 0xb1, 0x49, 0x10, 0x98, 0x48, 0x02, 0xc2, 0xa7,
+                0xe3, 0x81, 0x93, 0xbc,
+            ]),
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x77, 0x5c, 0x7f, 0x5c, 0xab, 0x43, 0x86, 0x88, 0x64, 0x3d, 0xdd, 0x15, 0x8d, 0xda,
+                0xed, 0xf9, 0xa0, 0xea, 0xef, 0x61, 0x4b, 0x54, 0x90, 0x60, 0xf1, 0xe4, 0xd7, 0xcc,
+                0x3e, 0x7e, 0x8b, 0x64, 0x49, 0x9a, 0x81, 0x8a, 0x6d, 0x0e, 0x33, 0x57, 0x68, 0x6e,
+                0x65, 0xbc, 0x27, 0x4e, 0x3f, 0x7d, 0x45, 0x5b, 0x91, 0x1f, 0x13, 0x9f, 0x19, 0xf0,
+                0x81, 0x61, 0x57, 0x51, 0x91, 0x3e, 0xb4, 0x12,
             ],
+            ovk: [
+                0x45, 0xe1, 0x59, 0x6c, 0xbf, 0x46, 0x70, 0xb7, 0xe0, 0x5d, 0xfd, 0xaf, 0xbb, 0x0c,
+                0xf3, 0xdd, 0xee, 0x28, 0xd7, 0x6a, 0x82, 0x42, 0x8e, 0x8a, 0xba, 0x43, 0x64, 0xe8,
+                0x4b, 0xac, 0x37, 0x92,
+            ],
+            default_d: [
+                0x2d, 0x0e, 0x22, 0xbe, 0xb8, 0x62, 0xfe, 0x52, 0xc1, 0x4c, 0xf5,
+            ],
+            default_pk_d: [
+                0x9a, 0xe4, 0x94, 0xa9, 0xfc, 0xff, 0x9b, 0x74, 0x49, 0x14, 0x53, 0x31, 0x04, 0x4f,
+                0x9a, 0x02, 0x53, 0xe5, 0x24, 0xa0, 0x2c, 0x77, 0x95, 0xe9, 0x8f, 0x83, 0xec, 0x7d,
+                0x96, 0xdc, 0xe6, 0xb7,
+            ],
+            v: 10238534295395242511,
+            rseed: [
+                0xad, 0x8c, 0x7d, 0x94, 0x37, 0xe2, 0x0e, 0x2a, 0x1f, 0x20, 0xe8, 0x18, 0xf9, 0x05,
+                0x7c, 0x5a, 0xba, 0xaa, 0x2e, 0x5c, 0x15, 0xb9, 0x49, 0x45, 0xcd, 0x42, 0x4c, 0x28,
+                0xa5, 0xfa, 0x38, 0x5d,
+            ],
+            memo: [
+                0xff, 0xad, 0xfe, 0x49, 0x07, 0xb2, 0x74, 0xd8, 0x42, 0x70, 0x7d, 0xb3, 0x69, 0x7a,
+                0x5a, 0xe6, 0xc8, 0xf5, 0x42, 0xe5, 0xec, 0xc0, 0x7f, 0xe4, 0x73, 0x50, 0xd1, 0x01,
+                0x46, 0x70, 0x21, 0x2e, 0xfe, 0x81, 0xfb, 0x7c, 0x73, 0xe8, 0x45, 0x0d, 0xf8, 0x14,
+                0xef, 0x62, 0x32, 0xf7, 0x49, 0x0f, 0x63, 0xcc, 0xf0, 0x74, 0x80, 0xf8, 0x84, 0xa6,
+                0x6e, 0xaf, 0xfc, 0x28, 0xfe, 0xa4, 0x48, 0xd7, 0xb4, 0x01, 0xcd, 0xae, 0x10, 0xe7,
+                0xc0, 0xc7, 0xf9, 0xa7, 0xb1, 0x53, 0x31, 0x96, 0x9f, 0xc8, 0xcb, 0x36, 0x39, 0x67,
+                0x73, 0xde, 0x19, 0x19, 0x31, 0xc7, 0x50, 0xf6, 0xce, 0x5c, 0xaa, 0xf2, 0x97, 0x68,
+                0xeb, 0xb2, 0x7d, 0xac, 0xc7, 0x38, 0x05, 0x6a, 0x81, 0x25, 0xb4, 0x77, 0x2b, 0xf8,
+                0x7a, 0xe1, 0x0a, 0x8a, 0x30, 0x9b, 0x9b, 0xd6, 0x55, 0x04, 0x3c, 0xfc, 0x31, 0x59,
+                0x49, 0x43, 0x68, 0xc5, 0xab, 0x8c, 0xad, 0xb7, 0xf6, 0x71, 0xe9, 0x62, 0x6b, 0xd2,
+                0x63, 0xe3, 0x11, 0x81, 0xa6, 0x04, 0xb5, 0x06, 0xa0, 0x3b, 0x43, 0x9a, 0x7f, 0xfe,
+                0x43, 0x55, 0x89, 0x24, 0x77, 0xe2, 0xbd, 0xf3, 0x38, 0xc6, 0x2c, 0x39, 0x22, 0xf7,
+                0xd3, 0xc9, 0xa5, 0x6c, 0x71, 0x03, 0xd9, 0x11, 0x94, 0x8a, 0x84, 0xb5, 0xae, 0x2d,
+                0xbb, 0x16, 0xa3, 0x76, 0x1a, 0xdd, 0x05, 0x3a, 0x0f, 0x96, 0x7e, 0x6b, 0x5b, 0xc9,
+                0x42, 0x11, 0xb6, 0x54, 0x71, 0x53, 0x26, 0x7c, 0x6e, 0xe1, 0xca, 0xd0, 0xd9, 0x74,
+                0xa7, 0x10, 0x88, 0x58, 0x37, 0x35, 0xe4, 0xf6, 0x3d, 0x33, 0x15, 0x6d, 0xad, 0xd5,
+                0x4c, 0x2f, 0xaf, 0x89, 0x11, 0x4a, 0x12, 0x7b, 0x97, 0xb9, 0x4c, 0xc2, 0xa2, 0x2e,
+                0xf3, 0x03, 0xf4, 0x59, 0xd0, 0x4f, 0xc0, 0xb5, 0x3a, 0xce, 0x59, 0x18, 0xd4, 0x7f,
+                0xf3, 0x3a, 0x55, 0x8b, 0xd7, 0x1a, 0x75, 0xf3, 0x55, 0xfb, 0xd0, 0x6b, 0xbc, 0xcf,
+                0x4e, 0x02, 0xc3, 0xc0, 0xa4, 0xb6, 0x3d, 0x0c, 0xc9, 0x49, 0x80, 0x1d, 0x63, 0xa6,
+                0x4c, 0xb2, 0xd3, 0x23, 0x73, 0xb2, 0xc7, 0xb2, 0x74, 0xab, 0x2d, 0xb4, 0x68, 0x21,
+                0x42, 0xc8, 0xb2, 0x1d, 0x84, 0xc4, 0x81, 0xf5, 0xef, 0x21, 0xe4, 0xb5, 0xe3, 0x60,
+                0x34, 0x51, 0xbf, 0x94, 0x77, 0x4d, 0x0e, 0xf4, 0x7f, 0x63, 0xfa, 0x6a, 0xbb, 0x78,
+                0xd2, 0x1c, 0x19, 0x3c, 0xbe, 0x65, 0xb6, 0x95, 0xfe, 0x67, 0x42, 0x3c, 0x1e, 0x2d,
+                0x31, 0x2e, 0x27, 0x76, 0xfa, 0x24, 0xec, 0xe8, 0x46, 0x83, 0xe7, 0x48, 0x76, 0xc5,
+                0x5e, 0xa0, 0x36, 0x9e, 0x4e, 0xa0, 0xe8, 0x64, 0x94, 0xe0, 0x0d, 0xde, 0x23, 0x6a,
+                0x16, 0x89, 0x73, 0x1f, 0x0a, 0x5d, 0x82, 0x03, 0xaf, 0xde, 0x5c, 0x42, 0x36, 0x40,
+                0xb8, 0x1e, 0x4f, 0x63, 0x1c, 0x98, 0x1c, 0x11, 0xa2, 0xe1, 0xd1, 0x84, 0xc6, 0x7c,
+                0x52, 0x8d, 0xf9, 0x2d, 0x53, 0xae, 0xc4, 0x4a, 0x40, 0xa4, 0xea, 0x2a, 0x13, 0x1b,
+                0x47, 0x33, 0xcf, 0xe4, 0x5c, 0x6b, 0x00, 0x12, 0xc3, 0xe9, 0xe2, 0x09, 0x75, 0xba,
+                0xae, 0xcb, 0x02, 0x32, 0xdf, 0x88, 0x0b, 0xd7, 0xd1, 0xde, 0x13, 0xe1, 0x34, 0x94,
+                0x62, 0xec, 0x8d, 0x5d, 0xf3, 0xe7, 0x80, 0xff, 0xa7, 0x2e, 0xba, 0x8a, 0x8d, 0xf7,
+                0xfc, 0xf3, 0x98, 0xec, 0x23, 0x05, 0x13, 0xca, 0x9d, 0x61, 0x23, 0xf8, 0xb9, 0xd8,
+                0x17, 0x85, 0x60, 0xda, 0xf9, 0x75, 0x11, 0x19, 0x55, 0xa2, 0xbc, 0xa3, 0x42, 0x3e,
+                0xee, 0xfc, 0x52, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ],
+            cv_net: [
+                0x81, 0xa8, 0xbb, 0x76, 0xf2, 0x62, 0x73, 0x62, 0x8b, 0x9f, 0x9b, 0x66, 0x04, 0x94,
+                0xb3, 0x45, 0xb7, 0x9d, 0x45, 0x16, 0x3c, 0x7b, 0x4c, 0xc5, 0x5a, 0x49, 0xff, 0x3f,
+                0xc6, 0xb8, 0x1d, 0xaa,
+            ],
+            rho: [
+                0xd6, 0xff, 0xc4, 0x74, 0x88, 0xad, 0x05, 0x93, 0x89, 0x70, 0xc4, 0xb1, 0x56, 0xd0,
+                0x53, 0xb9, 0x3b, 0xcb, 0xb4, 0x37, 0x57, 0x1c, 0x62, 0xf3, 0x75, 0x60, 0x7e, 0x90,
+                0x4e, 0xb3, 0xa2, 0x08,
+            ],
+            cmx: [
+                0x8f, 0x56, 0xd1, 0x3f, 0xd9, 0xc8, 0x3e, 0xb7, 0x1b, 0x95, 0x87, 0x7a, 0x4f, 0x29,
+                0x39, 0x64, 0xbf, 0x3f, 0x73, 0x1d, 0x8d, 0xf2, 0x04, 0x32, 0x2c, 0xed, 0xcb, 0x38,
+                0x68, 0x21, 0x90, 0x3c,
+            ],
+            esk: [
+                0x24, 0x50, 0xae, 0xde, 0xb9, 0x7e, 0x62, 0xd7, 0x9c, 0xcb, 0x44, 0xb0, 0xb0, 0x4f,
+                0xe7, 0x93, 0x92, 0x5d, 0x49, 0xc4, 0xc0, 0x1f, 0x49, 0x2e, 0xa9, 0xec, 0x88, 0x17,
+                0x18, 0x65, 0x40, 0x33,
+            ],
+            ephemeral_key: [
+                0x51, 0x66, 0x26, 0x31, 0x6e, 0xea, 0x63, 0xa6, 0x45, 0xae, 0x56, 0x23, 0x81, 0x5a,
+                0x31, 0x74, 0xb3, 0xed, 0x36, 0x64, 0xc3, 0x3e, 0x6a, 0x51, 0x81, 0xa9, 0xf5, 0xb5,
+                0x42, 0x76, 0x7a, 0x2d,
+            ],
+            shared_secret: [
+                0xf6, 0x04, 0x23, 0x98, 0x7f, 0x0e, 0x67, 0x6d, 0x1a, 0x3b, 0xb6, 0xef, 0xe0, 0x39,
+                0x42, 0x1d, 0xbb, 0xc8, 0x24, 0xb6, 0x90, 0xc1, 0x94, 0xa4, 0x90, 0xe4, 0x17, 0x1d,
+                0xde, 0x21, 0x58, 0x19,
+            ],
+            k_enc: [
+                0x20, 0x98, 0x25, 0x7e, 0x2b, 0x9b, 0x7f, 0xc0, 0x62, 0x82, 0x38, 0x03, 0x38, 0x59,
+                0x7d, 0xcb, 0x62, 0x7d, 0xdf, 0x47, 0x3e, 0x83, 0xa7, 0x2e, 0x61, 0xb0, 0xf2, 0x2c,
+                0xcf, 0xaf, 0xbe, 0x4e,
+            ],
+            p_enc: [
+                0x03, 0x2d, 0x0e, 0x22, 0xbe, 0xb8, 0x62, 0xfe, 0x52, 0xc1, 0x4c, 0xf5, 0x0f, 0x12,
+                0xb0, 0x11, 0xb2, 0x94, 0x16, 0x8e, 0xad, 0x8c, 0x7d, 0x94, 0x37, 0xe2, 0x0e, 0x2a,
+                0x1f, 0x20, 0xe8, 0x18, 0xf9, 0x05, 0x7c, 0x5a, 0xba, 0xaa, 0x2e, 0x5c, 0x15, 0xb9,
+                0x49, 0x45, 0xcd, 0x42, 0x4c, 0x28, 0xa5, 0xfa, 0x38, 0x5d, 0x76, 0xba, 0x24, 0x3f,
+                0x28, 0x42, 0xb7, 0xb5, 0xfc, 0x74, 0x6a, 0xe5, 0x1b, 0x0b, 0xc4, 0xbd, 0x4f, 0xc9,
+                0xfd, 0x83, 0x35, 0x65, 0xea, 0x85, 0x2b, 0x92, 0xb2, 0x24, 0xf6, 0x99, 0x03, 0x18,
+                0xff, 0xad, 0xfe, 0x49, 0x07, 0xb2, 0x74, 0xd8, 0x42, 0x70, 0x7d, 0xb3, 0x69, 0x7a,
+                0x5a, 0xe6, 0xc8, 0xf5, 0x42, 0xe5, 0xec, 0xc0, 0x7f, 0xe4, 0x73, 0x50, 0xd1, 0x01,
+                0x46, 0x70, 0x21, 0x2e, 0xfe, 0x81, 0xfb, 0x7c, 0x73, 0xe8, 0x45, 0x0d, 0xf8, 0x14,
+                0xef, 0x62, 0x32, 0xf7, 0x49, 0x0f, 0x63, 0xcc, 0xf0, 0x74, 0x80, 0xf8, 0x84, 0xa6,
+                0x6e, 0xaf, 0xfc, 0x28, 0xfe, 0xa4, 0x48, 0xd7, 0xb4, 0x01, 0xcd, 0xae, 0x10, 0xe7,
+                0xc0, 0xc7, 0xf9, 0xa7, 0xb1, 0x53, 0x31, 0x96, 0x9f, 0xc8, 0xcb, 0x36, 0x39, 0x67,
+                0x73, 0xde, 0x19, 0x19, 0x31, 0xc7, 0x50, 0xf6, 0xce, 0x5c, 0xaa, 0xf2, 0x97, 0x68,
+                0xeb, 0xb2, 0x7d, 0xac, 0xc7, 0x38, 0x05, 0x6a, 0x81, 0x25, 0xb4, 0x77, 0x2b, 0xf8,
+                0x7a, 0xe1, 0x0a, 0x8a, 0x30, 0x9b, 0x9b, 0xd6, 0x55, 0x04, 0x3c, 0xfc, 0x31, 0x59,
+                0x49, 0x43, 0x68, 0xc5, 0xab, 0x8c, 0xad, 0xb7, 0xf6, 0x71, 0xe9, 0x62, 0x6b, 0xd2,
+                0x63, 0xe3, 0x11, 0x81, 0xa6, 0x04, 0xb5, 0x06, 0xa0, 0x3b, 0x43, 0x9a, 0x7f, 0xfe,
+                0x43, 0x55, 0x89, 0x24, 0x77, 0xe2, 0xbd, 0xf3, 0x38, 0xc6, 0x2c, 0x39, 0x22, 0xf7,
+                0xd3, 0xc9, 0xa5, 0x6c, 0x71, 0x03, 0xd9, 0x11, 0x94, 0x8a, 0x84, 0xb5, 0xae, 0x2d,
+                0xbb, 0x16, 0xa3, 0x76, 0x1a, 0xdd, 0x05, 0x3a, 0x0f, 0x96, 0x7e, 0x6b, 0x5b, 0xc9,
+                0x42, 0x11, 0xb6, 0x54, 0x71, 0x53, 0x26, 0x7c, 0x6e, 0xe1, 0xca, 0xd0, 0xd9, 0x74,
+                0xa7, 0x10, 0x88, 0x58, 0x37, 0x35, 0xe4, 0xf6, 0x3d, 0x33, 0x15, 0x6d, 0xad, 0xd5,
+                0x4c, 0x2f, 0xaf, 0x89, 0x11, 0x4a, 0x12, 0x7b, 0x97, 0xb9, 0x4c, 0xc2, 0xa2, 0x2e,
+                0xf3, 0x03, 0xf4, 0x59, 0xd0, 0x4f, 0xc0, 0xb5, 0x3a, 0xce, 0x59, 0x18, 0xd4, 0x7f,
+                0xf3, 0x3a, 0x55, 0x8b, 0xd7, 0x1a, 0x75, 0xf3, 0x55, 0xfb, 0xd0, 0x6b, 0xbc, 0xcf,
+                0x4e, 0x02, 0xc3, 0xc0, 0xa4, 0xb6, 0x3d, 0x0c, 0xc9, 0x49, 0x80, 0x1d, 0x63, 0xa6,
+                0x4c, 0xb2, 0xd3, 0x23, 0x73, 0xb2, 0xc7, 0xb2, 0x74, 0xab, 0x2d, 0xb4, 0x68, 0x21,
+                0x42, 0xc8, 0xb2, 0x1d, 0x84, 0xc4, 0x81, 0xf5, 0xef, 0x21, 0xe4, 0xb5, 0xe3, 0x60,
+                0x34, 0x51, 0xbf, 0x94, 0x77, 0x4d, 0x0e, 0xf4, 0x7f, 0x63, 0xfa, 0x6a, 0xbb, 0x78,
+                0xd2, 0x1c, 0x19, 0x3c, 0xbe, 0x65, 0xb6, 0x95, 0xfe, 0x67, 0x42, 0x3c, 0x1e, 0x2d,
+                0x31, 0x2e, 0x27, 0x76, 0xfa, 0x24, 0xec, 0xe8, 0x46, 0x83, 0xe7, 0x48, 0x76, 0xc5,
+                0x5e, 0xa0, 0x36, 0x9e, 0x4e, 0xa0, 0xe8, 0x64, 0x94, 0xe0, 0x0d, 0xde, 0x23, 0x6a,
+                0x16, 0x89, 0x73, 0x1f, 0x0a, 0x5d, 0x82, 0x03, 0xaf, 0xde, 0x5c, 0x42, 0x36, 0x40,
+                0xb8, 0x1e, 0x4f, 0x63, 0x1c, 0x98, 0x1c, 0x11, 0xa2, 0xe1, 0xd1, 0x84, 0xc6, 0x7c,
+                0x52, 0x8d, 0xf9, 0x2d, 0x53, 0xae, 0xc4, 0x4a, 0x40, 0xa4, 0xea, 0x2a, 0x13, 0x1b,
+                0x47, 0x33, 0xcf, 0xe4, 0x5c, 0x6b, 0x00, 0x12, 0xc3, 0xe9, 0xe2, 0x09, 0x75, 0xba,
+                0xae, 0xcb, 0x02, 0x32, 0xdf, 0x88, 0x0b, 0xd7, 0xd1, 0xde, 0x13, 0xe1, 0x34, 0x94,
+                0x62, 0xec, 0x8d, 0x5d, 0xf3, 0xe7, 0x80, 0xff, 0xa7, 0x2e, 0xba, 0x8a, 0x8d, 0xf7,
+                0xfc, 0xf3, 0x98, 0xec, 0x23, 0x05, 0x13, 0xca, 0x9d, 0x61, 0x23, 0xf8, 0xb9, 0xd8,
+                0x17, 0x85, 0x60, 0xda, 0xf9, 0x75, 0x11, 0x19, 0x55, 0xa2, 0xbc, 0xa3, 0x42, 0x3e,
+                0xee, 0xfc, 0x52, 0x7b,
+            ],
+            c_enc: [
+                0xa4, 0x01, 0xab, 0x60, 0x1f, 0x8d, 0x69, 0xd9, 0x38, 0x0c, 0x3d, 0xef, 0x1f, 0x1a,
+                0x34, 0xbe, 0x6c, 0xfa, 0x4d, 0x83, 0x8b, 0xf8, 0x7f, 0x00, 0xe3, 0x6b, 0xe6, 0xbe,
+                0x68, 0x60, 0xbe, 0xa8, 0x3d, 0xab, 0xdd, 0x00, 0xab, 0xe7, 0xe0, 0xd1, 0x21, 0x90,
+                0xfb, 0x54, 0xb0, 0xf2, 0xad, 0xcf, 0xef, 0x9e, 0xf4, 0x2b, 0xa2, 0x31, 0x77, 0x6a,
+                0xd3, 0xee, 0x09, 0x86, 0xdb, 0x3f, 0x4f, 0xc0, 0xa8, 0xa1, 0xc6, 0xa7, 0xfe, 0x54,
+                0xa6, 0x6b, 0xd7, 0x68, 0xa9, 0xde, 0xd2, 0x5b, 0xb1, 0x89, 0xd5, 0x87, 0x1c, 0xaf,
+                0x4d, 0xf8, 0x95, 0x6c, 0x2f, 0x30, 0x70, 0x15, 0x89, 0xa4, 0xdc, 0xdb, 0x68, 0x11,
+                0x6d, 0x0f, 0x50, 0x9b, 0x34, 0x1e, 0x8f, 0x25, 0x8e, 0x17, 0x38, 0xb5, 0x51, 0x9c,
+                0x99, 0xf1, 0xdb, 0xd0, 0x86, 0x31, 0x56, 0x2f, 0x90, 0xd1, 0x5e, 0x72, 0x8a, 0x85,
+                0x25, 0xa1, 0x1b, 0xfe, 0x53, 0x95, 0x24, 0x5d, 0x71, 0x79, 0xcf, 0x8e, 0x97, 0xa8,
+                0x3f, 0xaa, 0x4c, 0xf3, 0xb2, 0xa8, 0xb5, 0xef, 0x62, 0x13, 0xe3, 0x30, 0x89, 0xb4,
+                0xeb, 0x03, 0xe7, 0xc2, 0xf0, 0x12, 0x11, 0xfc, 0x53, 0xbc, 0x01, 0x16, 0x40, 0x05,
+                0x01, 0x5d, 0xbf, 0x33, 0xc6, 0x50, 0xa3, 0xf8, 0x33, 0xba, 0x67, 0x77, 0xcf, 0xf1,
+                0xd7, 0x38, 0xe2, 0x1c, 0x58, 0xdc, 0x05, 0xc3, 0xb4, 0xec, 0xb9, 0x7a, 0x6c, 0xe0,
+                0xb0, 0xc5, 0xee, 0x94, 0x4c, 0x24, 0xb3, 0x3b, 0xb0, 0xce, 0x32, 0xbe, 0x02, 0x3e,
+                0x21, 0x3f, 0xf7, 0xc9, 0xd4, 0x12, 0x4f, 0xc9, 0xdc, 0x4a, 0xa7, 0xca, 0x47, 0x13,
+                0x86, 0x48, 0xe2, 0xbb, 0x80, 0x7c, 0xea, 0x7a, 0x58, 0xe7, 0x67, 0xd3, 0x27, 0x07,
+                0x4a, 0xe5, 0xe3, 0x9c, 0x3c, 0x17, 0xb7, 0x7c, 0x09, 0x0a, 0xf9, 0x42, 0x5b, 0xc6,
+                0x40, 0xd2, 0x1d, 0xd6, 0x81, 0xa6, 0x37, 0x45, 0xe9, 0x02, 0x59, 0xe2, 0xd1, 0x09,
+                0x0c, 0x88, 0x48, 0x8e, 0x21, 0x48, 0xb9, 0xee, 0x24, 0x31, 0xc5, 0xae, 0xf5, 0x10,
+                0x95, 0xb3, 0x5a, 0x37, 0x7c, 0xfa, 0x76, 0x5d, 0x82, 0x24, 0x98, 0x83, 0x00, 0x04,
+                0x71, 0x79, 0xa5, 0x09, 0x40, 0x28, 0xbe, 0x52, 0x7d, 0x5d, 0xe1, 0xc2, 0x69, 0xff,
+                0x45, 0x2c, 0x0a, 0xaf, 0x5a, 0x47, 0x7e, 0x93, 0x90, 0xa0, 0xf0, 0xa8, 0x68, 0x11,
+                0x3c, 0x7c, 0xd1, 0x9e, 0x2e, 0xac, 0x54, 0x0d, 0xc6, 0x59, 0xda, 0x29, 0x60, 0x06,
+                0x77, 0x6e, 0xda, 0x0d, 0xf9, 0x81, 0xc4, 0x11, 0xc1, 0x50, 0x01, 0xa9, 0x8b, 0x6a,
+                0xd6, 0x58, 0xd9, 0xa6, 0x4c, 0x12, 0x6a, 0xbe, 0xfc, 0x73, 0x9a, 0xa1, 0xf4, 0x44,
+                0xbb, 0x83, 0xf3, 0xf1, 0x4d, 0x11, 0x3d, 0x02, 0x8f, 0xae, 0x10, 0xe4, 0xc5, 0xdb,
+                0xe7, 0x78, 0x51, 0x96, 0x83, 0xcd, 0xf4, 0xc2, 0xf4, 0x6c, 0x4a, 0x52, 0xae, 0x12,
+                0x09, 0xe1, 0x12, 0x7f, 0x9d, 0xc4, 0xed, 0x86, 0x7d, 0x8e, 0xda, 0x02, 0x4a, 0x68,
+                0x9f, 0x6b, 0x15, 0xb8, 0x05, 0x38, 0x03, 0x02, 0x44, 0x02, 0xa1, 0xce, 0x6f, 0x1c,
+                0x63, 0x6f, 0x2e, 0xfc, 0xf9, 0xd0, 0x60, 0x51, 0x5c, 0xd6, 0x14, 0x71, 0x8d, 0x51,
+                0x52, 0x7d, 0x26, 0x7a, 0xd8, 0x95, 0xfa, 0xd8, 0xec, 0xfb, 0x23, 0x51, 0xf8, 0x92,
+                0x45, 0x0d, 0xc8, 0x74, 0xe8, 0x74, 0x39, 0x2c, 0x91, 0xed, 0x3a, 0xf1, 0x18, 0x38,
+                0xc4, 0xb5, 0x48, 0x2e, 0x8c, 0x92, 0xeb, 0xc7, 0xa0, 0x08, 0x8e, 0x49, 0xd2, 0xb0,
+                0xb4, 0xa1, 0xbd, 0x33, 0x3b, 0x38, 0x7f, 0x49, 0xe3, 0x0f, 0xd2, 0x1a, 0x6e, 0xdc,
+                0x89, 0x94, 0x83, 0x4f, 0x28, 0xe9, 0xf2, 0x52, 0x9a, 0x7e, 0x27, 0x24, 0x21, 0x6d,
+                0x9e, 0x1a, 0xe5, 0xb4, 0x6e, 0xb1, 0x9a, 0x53, 0xea, 0x2b, 0x97, 0x99, 0x65, 0xf7,
+                0x5b, 0x83, 0xf6, 0x86, 0xed, 0xc0, 0x1d, 0x25, 0x7a, 0x06, 0x58, 0xd7, 0x4e, 0x25,
+                0xc0, 0xe1, 0xa8, 0xb0, 0x65, 0x60, 0x43, 0x1f, 0x85, 0x10, 0x5c, 0xf9, 0x8a, 0x1f,
+                0xfe, 0x28, 0x40, 0x8a, 0x64, 0xf4, 0xc0, 0x27, 0x8d, 0x36, 0xed, 0xea, 0x76, 0x40,
+                0xa2, 0x18, 0x26, 0xc3, 0x5d, 0x13, 0x20, 0x25, 0x08, 0x07, 0x2b, 0x68, 0x82, 0xf4,
+                0xd8, 0x2e, 0x93, 0x3c, 0x89, 0xe1,
+            ],
+            ock: [
+                0x71, 0x5c, 0x9a, 0x01, 0x87, 0xab, 0x90, 0xb2, 0x4d, 0x3c, 0xbb, 0xa3, 0xf1, 0xab,
+                0x30, 0x67, 0xc5, 0x63, 0x06, 0x04, 0x48, 0xc0, 0x0e, 0xf2, 0x74, 0xb7, 0xea, 0x66,
+                0x11, 0x13, 0x0d, 0x26,
+            ],
+            op: [
+                0x9a, 0xe4, 0x94, 0xa9, 0xfc, 0xff, 0x9b, 0x74, 0x49, 0x14, 0x53, 0x31, 0x04, 0x4f,
+                0x9a, 0x02, 0x53, 0xe5, 0x24, 0xa0, 0x2c, 0x77, 0x95, 0xe9, 0x8f, 0x83, 0xec, 0x7d,
+                0x96, 0xdc, 0xe6, 0xb7, 0x24, 0x50, 0xae, 0xde, 0xb9, 0x7e, 0x62, 0xd7, 0x9c, 0xcb,
+                0x44, 0xb0, 0xb0, 0x4f, 0xe7, 0x93, 0x92, 0x5d, 0x49, 0xc4, 0xc0, 0x1f, 0x49, 0x2e,
+                0xa9, 0xec, 0x88, 0x17, 0x18, 0x65, 0x40, 0x33,
+            ],
+            c_out: [
+                0x22, 0xce, 0xb6, 0x94, 0x21, 0xab, 0x9e, 0xd0, 0x29, 0x97, 0x3f, 0xf2, 0x2e, 0xc9,
+                0x5f, 0x23, 0x36, 0x56, 0xbe, 0x41, 0xd2, 0x25, 0x1a, 0x76, 0x77, 0xce, 0xb0, 0xd3,
+                0x14, 0x22, 0x11, 0x6f, 0x8c, 0xa5, 0xf0, 0xae, 0x23, 0x12, 0xd4, 0xec, 0x60, 0x0c,
+                0x5d, 0x7c, 0x56, 0x44, 0x5b, 0x6d, 0x8d, 0xc4, 0xb8, 0x0b, 0x47, 0x0b, 0xb1, 0xf6,
+                0x51, 0xa5, 0x38, 0x28, 0x0d, 0xaa, 0x94, 0x20, 0x3a, 0xb5, 0x02, 0xa8, 0x15, 0x09,
+                0xe4, 0x3a, 0x61, 0xa6, 0x98, 0x56, 0x57, 0xd9, 0xe8, 0x4e,
+            ],
+            note_type: Some([
+                0x76, 0xba, 0x24, 0x3f, 0x28, 0x42, 0xb7, 0xb5, 0xfc, 0x74, 0x6a, 0xe5, 0x1b, 0x0b,
+                0xc4, 0xbd, 0x4f, 0xc9, 0xfd, 0x83, 0x35, 0x65, 0xea, 0x85, 0x2b, 0x92, 0xb2, 0x24,
+                0xf6, 0x99, 0x03, 0x18,
+            ]),
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x9c, 0xe9, 0x20, 0x37, 0x6a, 0x6a, 0x54, 0x1e, 0x6a, 0xad, 0x66, 0x0e, 0xfa, 0x09,
+                0x8d, 0xc5, 0x4c, 0x18, 0xfc, 0xeb, 0x13, 0xd0, 0x99, 0x9f, 0xbc, 0xc7, 0xfd, 0x45,
+                0xa5, 0x7c, 0xcc, 0x10, 0xb8, 0xaa, 0x86, 0xc4, 0x54, 0x0d, 0x0a, 0x9f, 0xc6, 0x6d,
+                0xf8, 0x5d, 0xad, 0xd6, 0x21, 0x56, 0x36, 0x5e, 0x28, 0xa3, 0xe9, 0x80, 0xb9, 0x8d,
+                0x13, 0x1b, 0x50, 0x3a, 0xa0, 0x6a, 0x6c, 0x19,
+            ],
+            ovk: [
+                0xf8, 0x1a, 0xd6, 0x17, 0xfa, 0x26, 0xf0, 0xdf, 0xb8, 0x36, 0x55, 0xb8, 0xa2, 0x9a,
+                0x7f, 0x83, 0x42, 0x32, 0x42, 0x5e, 0x8c, 0x47, 0x45, 0x88, 0xf1, 0x8d, 0xd3, 0x26,
+                0xaa, 0x39, 0x6c, 0x3e,
+            ],
+            default_d: [
+                0xfb, 0x8e, 0xa2, 0xcc, 0x0a, 0xd2, 0x30, 0x91, 0x32, 0xfd, 0x11,
+            ],
+            default_pk_d: [
+                0xcc, 0x18, 0xe4, 0xb6, 0x5f, 0x89, 0x34, 0x06, 0x31, 0x5d, 0xb7, 0x1f, 0xac, 0x06,
+                0x5d, 0x71, 0xd0, 0xea, 0xba, 0x7c, 0xf3, 0xc2, 0xba, 0x94, 0x77, 0x12, 0x32, 0x75,
+                0x43, 0x4b, 0x1e, 0xb0,
+            ],
+            v: 2690686290017047047,
+            rseed: [
+                0x0b, 0x39, 0x05, 0xa4, 0xe3, 0xbd, 0x01, 0xc5, 0x4d, 0xf8, 0x64, 0x34, 0x43, 0xbe,
+                0x0f, 0x88, 0x90, 0x32, 0xea, 0x32, 0x5b, 0xf0, 0x71, 0x07, 0xfd, 0x41, 0xd6, 0x73,
+                0xee, 0xba, 0xe6, 0xfa,
+            ],
+            memo: [
+                0xff, 0x63, 0x7b, 0x70, 0xcc, 0x0e, 0xd3, 0xf0, 0x09, 0x58, 0xdf, 0xb8, 0xdc, 0xf0,
+                0x0e, 0x85, 0xa1, 0xd0, 0xa6, 0xa8, 0x90, 0x81, 0x40, 0xc2, 0xf4, 0x34, 0xc2, 0xe2,
+                0x60, 0xef, 0xb0, 0xbc, 0xa2, 0x00, 0x35, 0x04, 0xc9, 0x99, 0x93, 0xa9, 0xe1, 0xc0,
+                0xff, 0x9c, 0xef, 0xe6, 0xa6, 0x65, 0xd7, 0x91, 0x42, 0x86, 0x90, 0xe4, 0x7e, 0xf8,
+                0xc1, 0x31, 0xa8, 0xe9, 0xbf, 0xb4, 0xc3, 0x08, 0x02, 0x35, 0x03, 0x2d, 0x73, 0x1b,
+                0x0d, 0x38, 0x41, 0x22, 0x5f, 0x1c, 0x11, 0xe2, 0xc2, 0x8e, 0xe8, 0x4d, 0x35, 0xf9,
+                0x22, 0x61, 0x00, 0x56, 0x59, 0x72, 0xeb, 0x26, 0x9d, 0x27, 0x8e, 0xf6, 0x49, 0x79,
+                0xbf, 0x65, 0x15, 0xed, 0x4a, 0x68, 0x40, 0xb0, 0x88, 0x3a, 0x9e, 0x6e, 0xf6, 0x4a,
+                0x0e, 0xfc, 0xae, 0x1c, 0xf2, 0x1d, 0xfe, 0x74, 0x85, 0x4e, 0x84, 0xc2, 0x74, 0x9f,
+                0xac, 0x03, 0x82, 0x52, 0x75, 0xc9, 0xb6, 0x30, 0x21, 0x84, 0xc7, 0x2d, 0xf4, 0xc4,
+                0xbb, 0x28, 0x62, 0xe4, 0xe8, 0xa7, 0xd9, 0xa4, 0xa2, 0x82, 0x86, 0x6f, 0x9a, 0x7b,
+                0x2c, 0xfc, 0x9a, 0x56, 0x31, 0x3d, 0xa0, 0xc4, 0x7a, 0x34, 0xb7, 0xb9, 0xcd, 0xa3,
+                0xac, 0xe8, 0x18, 0x5f, 0x07, 0xdf, 0x36, 0xe4, 0x48, 0xa7, 0x6a, 0xa4, 0x77, 0xf2,
+                0x24, 0xd8, 0x7a, 0x07, 0x4f, 0x43, 0xaf, 0x5d, 0x5f, 0x79, 0xb3, 0xab, 0x11, 0x28,
+                0xf0, 0x81, 0x91, 0x44, 0x7f, 0xa6, 0x46, 0xbf, 0xdd, 0xe5, 0xb5, 0x1e, 0x23, 0x3c,
+                0xa6, 0x15, 0x5d, 0x10, 0x15, 0x85, 0xbc, 0x2c, 0x40, 0x15, 0x8a, 0xc2, 0x10, 0x6e,
+                0x66, 0xa2, 0x6e, 0x46, 0x42, 0x33, 0x70, 0x63, 0x68, 0x76, 0xb4, 0x34, 0xa7, 0x4f,
+                0x8c, 0xe8, 0x06, 0x00, 0x50, 0xb0, 0x82, 0xa7, 0x9b, 0x61, 0xbb, 0x5d, 0x34, 0x4e,
+                0xb5, 0xa1, 0x15, 0x83, 0x26, 0xce, 0xd9, 0xa9, 0xd9, 0xf5, 0x4f, 0xb2, 0xfe, 0x8f,
+                0x9f, 0x05, 0xcd, 0x11, 0x1e, 0xe4, 0x6c, 0x47, 0x10, 0xf6, 0xf6, 0x3a, 0x62, 0x69,
+                0x45, 0x57, 0xef, 0x1b, 0x12, 0xc8, 0x80, 0x06, 0xb6, 0x78, 0x72, 0x50, 0x5f, 0x4e,
+                0x88, 0x3b, 0x58, 0x59, 0x07, 0x92, 0x9a, 0x2f, 0x3f, 0xdb, 0x0d, 0x8f, 0x79, 0x14,
+                0xc4, 0x2d, 0xde, 0x2d, 0x20, 0x00, 0xf5, 0xae, 0x02, 0xd4, 0x18, 0x21, 0xc8, 0xe1,
+                0xee, 0x01, 0x38, 0xeb, 0xcb, 0x72, 0x8d, 0x7c, 0x6c, 0x3c, 0x80, 0x02, 0x7e, 0x43,
+                0x75, 0x94, 0xc6, 0x70, 0xfd, 0x6f, 0x39, 0x08, 0x22, 0x2e, 0xe7, 0xa1, 0xb9, 0x17,
+                0xf8, 0x27, 0x1a, 0xbe, 0x66, 0x0e, 0x39, 0xe0, 0x51, 0xaa, 0xa6, 0xfc, 0xa1, 0x86,
+                0x22, 0x76, 0xe2, 0xba, 0xa0, 0xfe, 0x0b, 0x16, 0x2a, 0xeb, 0xcf, 0xe3, 0xd9, 0x34,
+                0x9c, 0x8d, 0x15, 0x4b, 0xb7, 0xee, 0x28, 0x21, 0x2c, 0x1b, 0xaa, 0x70, 0x5d, 0x82,
+                0x07, 0x0d, 0x70, 0x32, 0xf2, 0x69, 0x5d, 0x17, 0x96, 0x80, 0x9f, 0xab, 0x41, 0x24,
+                0x69, 0x26, 0xaf, 0x99, 0x2b, 0x6e, 0xee, 0x95, 0xa9, 0xa0, 0x6b, 0xc4, 0x56, 0x2c,
+                0x5f, 0x2f, 0x1b, 0x19, 0x54, 0x95, 0x00, 0x37, 0x2e, 0x7a, 0xd5, 0x79, 0xa6, 0xd6,
+                0xd7, 0x8b, 0x33, 0x15, 0x31, 0x30, 0xfb, 0x44, 0x8f, 0xb7, 0x9e, 0x8a, 0x66, 0x9d,
+                0xb8, 0xa0, 0xf3, 0x5c, 0xdf, 0x9a, 0xe5, 0xd3, 0x2d, 0x73, 0x2f, 0xc7, 0x94, 0x18,
+                0xe2, 0x3b, 0x45, 0x1d, 0xdc, 0x95, 0xa2, 0x2a, 0xba, 0xbb, 0x05, 0x6e, 0xc6, 0xb5,
+                0xe8, 0xba, 0x4f, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ],
+            cv_net: [
+                0x40, 0x21, 0x95, 0x68, 0x0e, 0x02, 0x27, 0x30, 0x2c, 0x3a, 0x75, 0x6a, 0x34, 0xdf,
+                0xdb, 0x13, 0x6b, 0xbd, 0x28, 0x7d, 0x7d, 0xc1, 0x25, 0x81, 0xd0, 0x8e, 0x2a, 0x63,
+                0xb9, 0xc3, 0x92, 0x3e,
+            ],
+            rho: [
+                0x85, 0x2f, 0x5c, 0x39, 0xd3, 0xf3, 0x55, 0xa3, 0x85, 0xe2, 0xab, 0xd2, 0x54, 0x3a,
+                0xa5, 0xed, 0x09, 0xc6, 0xee, 0x3b, 0x7f, 0x39, 0x34, 0x14, 0xe1, 0x1c, 0xd4, 0x20,
+                0x4c, 0x3f, 0x8d, 0x26,
+            ],
+            cmx: [
+                0x69, 0x4b, 0x6f, 0x3a, 0xb8, 0x37, 0xa9, 0x26, 0xd6, 0x77, 0x3e, 0xc4, 0xa6, 0x76,
+                0x5d, 0xef, 0x82, 0x89, 0x33, 0x74, 0x2d, 0x93, 0x29, 0xfc, 0x88, 0x67, 0x1c, 0xcd,
+                0x81, 0x21, 0xa4, 0x23,
+            ],
+            esk: [
+                0xaa, 0x84, 0x16, 0x79, 0xd4, 0xd2, 0x40, 0xb0, 0xab, 0xc4, 0xa5, 0xd8, 0x9a, 0xa8,
+                0xd6, 0xb3, 0xb0, 0x86, 0x92, 0x23, 0xed, 0x76, 0x3b, 0x67, 0x6a, 0x72, 0xcb, 0x74,
+                0xfb, 0x18, 0xd1, 0x17,
+            ],
+            ephemeral_key: [
+                0x3c, 0x04, 0xbe, 0x6e, 0x42, 0xa6, 0xca, 0x7f, 0x5d, 0xda, 0x0d, 0x82, 0xdf, 0x30,
+                0x7b, 0xd9, 0x6b, 0xb7, 0xb1, 0xae, 0x8d, 0x62, 0x31, 0x87, 0xe3, 0x9c, 0x00, 0xa4,
+                0x8c, 0x25, 0xaa, 0x9d,
+            ],
+            shared_secret: [
+                0x3a, 0x60, 0x2b, 0xaf, 0xb8, 0xa2, 0x66, 0x5a, 0x74, 0xdf, 0x34, 0xab, 0x6e, 0x3c,
+                0x48, 0x8b, 0x09, 0xe2, 0x28, 0x4e, 0xa1, 0x7d, 0x56, 0x02, 0x62, 0xe2, 0x1f, 0x7f,
+                0x3c, 0xba, 0xa3, 0x95,
+            ],
+            k_enc: [
+                0x1b, 0x6d, 0xd1, 0x03, 0x49, 0x63, 0x67, 0xc9, 0x2b, 0x36, 0x8f, 0xc2, 0xf1, 0xc6,
+                0x2e, 0x56, 0xc8, 0xc9, 0xfb, 0xe3, 0x4a, 0x35, 0x84, 0x1f, 0xe1, 0xa3, 0x70, 0x96,
+                0x43, 0xe1, 0x35, 0xe1,
+            ],
+            p_enc: [
+                0x03, 0xfb, 0x8e, 0xa2, 0xcc, 0x0a, 0xd2, 0x30, 0x91, 0x32, 0xfd, 0x11, 0x07, 0xd2,
+                0x7a, 0xc6, 0xec, 0x3c, 0x57, 0x25, 0x0b, 0x39, 0x05, 0xa4, 0xe3, 0xbd, 0x01, 0xc5,
+                0x4d, 0xf8, 0x64, 0x34, 0x43, 0xbe, 0x0f, 0x88, 0x90, 0x32, 0xea, 0x32, 0x5b, 0xf0,
+                0x71, 0x07, 0xfd, 0x41, 0xd6, 0x73, 0xee, 0xba, 0xe6, 0xfa, 0x64, 0xd0, 0x87, 0x40,
+                0x89, 0x86, 0xe7, 0x3d, 0x6e, 0x28, 0x4f, 0xea, 0x9a, 0x23, 0xc3, 0x93, 0x11, 0x78,
+                0x2f, 0x86, 0xca, 0xbf, 0xf9, 0x45, 0x5e, 0x4c, 0xf6, 0x99, 0xe5, 0xf5, 0xd4, 0xbc,
+                0xff, 0x63, 0x7b, 0x70, 0xcc, 0x0e, 0xd3, 0xf0, 0x09, 0x58, 0xdf, 0xb8, 0xdc, 0xf0,
+                0x0e, 0x85, 0xa1, 0xd0, 0xa6, 0xa8, 0x90, 0x81, 0x40, 0xc2, 0xf4, 0x34, 0xc2, 0xe2,
+                0x60, 0xef, 0xb0, 0xbc, 0xa2, 0x00, 0x35, 0x04, 0xc9, 0x99, 0x93, 0xa9, 0xe1, 0xc0,
+                0xff, 0x9c, 0xef, 0xe6, 0xa6, 0x65, 0xd7, 0x91, 0x42, 0x86, 0x90, 0xe4, 0x7e, 0xf8,
+                0xc1, 0x31, 0xa8, 0xe9, 0xbf, 0xb4, 0xc3, 0x08, 0x02, 0x35, 0x03, 0x2d, 0x73, 0x1b,
+                0x0d, 0x38, 0x41, 0x22, 0x5f, 0x1c, 0x11, 0xe2, 0xc2, 0x8e, 0xe8, 0x4d, 0x35, 0xf9,
+                0x22, 0x61, 0x00, 0x56, 0x59, 0x72, 0xeb, 0x26, 0x9d, 0x27, 0x8e, 0xf6, 0x49, 0x79,
+                0xbf, 0x65, 0x15, 0xed, 0x4a, 0x68, 0x40, 0xb0, 0x88, 0x3a, 0x9e, 0x6e, 0xf6, 0x4a,
+                0x0e, 0xfc, 0xae, 0x1c, 0xf2, 0x1d, 0xfe, 0x74, 0x85, 0x4e, 0x84, 0xc2, 0x74, 0x9f,
+                0xac, 0x03, 0x82, 0x52, 0x75, 0xc9, 0xb6, 0x30, 0x21, 0x84, 0xc7, 0x2d, 0xf4, 0xc4,
+                0xbb, 0x28, 0x62, 0xe4, 0xe8, 0xa7, 0xd9, 0xa4, 0xa2, 0x82, 0x86, 0x6f, 0x9a, 0x7b,
+                0x2c, 0xfc, 0x9a, 0x56, 0x31, 0x3d, 0xa0, 0xc4, 0x7a, 0x34, 0xb7, 0xb9, 0xcd, 0xa3,
+                0xac, 0xe8, 0x18, 0x5f, 0x07, 0xdf, 0x36, 0xe4, 0x48, 0xa7, 0x6a, 0xa4, 0x77, 0xf2,
+                0x24, 0xd8, 0x7a, 0x07, 0x4f, 0x43, 0xaf, 0x5d, 0x5f, 0x79, 0xb3, 0xab, 0x11, 0x28,
+                0xf0, 0x81, 0x91, 0x44, 0x7f, 0xa6, 0x46, 0xbf, 0xdd, 0xe5, 0xb5, 0x1e, 0x23, 0x3c,
+                0xa6, 0x15, 0x5d, 0x10, 0x15, 0x85, 0xbc, 0x2c, 0x40, 0x15, 0x8a, 0xc2, 0x10, 0x6e,
+                0x66, 0xa2, 0x6e, 0x46, 0x42, 0x33, 0x70, 0x63, 0x68, 0x76, 0xb4, 0x34, 0xa7, 0x4f,
+                0x8c, 0xe8, 0x06, 0x00, 0x50, 0xb0, 0x82, 0xa7, 0x9b, 0x61, 0xbb, 0x5d, 0x34, 0x4e,
+                0xb5, 0xa1, 0x15, 0x83, 0x26, 0xce, 0xd9, 0xa9, 0xd9, 0xf5, 0x4f, 0xb2, 0xfe, 0x8f,
+                0x9f, 0x05, 0xcd, 0x11, 0x1e, 0xe4, 0x6c, 0x47, 0x10, 0xf6, 0xf6, 0x3a, 0x62, 0x69,
+                0x45, 0x57, 0xef, 0x1b, 0x12, 0xc8, 0x80, 0x06, 0xb6, 0x78, 0x72, 0x50, 0x5f, 0x4e,
+                0x88, 0x3b, 0x58, 0x59, 0x07, 0x92, 0x9a, 0x2f, 0x3f, 0xdb, 0x0d, 0x8f, 0x79, 0x14,
+                0xc4, 0x2d, 0xde, 0x2d, 0x20, 0x00, 0xf5, 0xae, 0x02, 0xd4, 0x18, 0x21, 0xc8, 0xe1,
+                0xee, 0x01, 0x38, 0xeb, 0xcb, 0x72, 0x8d, 0x7c, 0x6c, 0x3c, 0x80, 0x02, 0x7e, 0x43,
+                0x75, 0x94, 0xc6, 0x70, 0xfd, 0x6f, 0x39, 0x08, 0x22, 0x2e, 0xe7, 0xa1, 0xb9, 0x17,
+                0xf8, 0x27, 0x1a, 0xbe, 0x66, 0x0e, 0x39, 0xe0, 0x51, 0xaa, 0xa6, 0xfc, 0xa1, 0x86,
+                0x22, 0x76, 0xe2, 0xba, 0xa0, 0xfe, 0x0b, 0x16, 0x2a, 0xeb, 0xcf, 0xe3, 0xd9, 0x34,
+                0x9c, 0x8d, 0x15, 0x4b, 0xb7, 0xee, 0x28, 0x21, 0x2c, 0x1b, 0xaa, 0x70, 0x5d, 0x82,
+                0x07, 0x0d, 0x70, 0x32, 0xf2, 0x69, 0x5d, 0x17, 0x96, 0x80, 0x9f, 0xab, 0x41, 0x24,
+                0x69, 0x26, 0xaf, 0x99, 0x2b, 0x6e, 0xee, 0x95, 0xa9, 0xa0, 0x6b, 0xc4, 0x56, 0x2c,
+                0x5f, 0x2f, 0x1b, 0x19, 0x54, 0x95, 0x00, 0x37, 0x2e, 0x7a, 0xd5, 0x79, 0xa6, 0xd6,
+                0xd7, 0x8b, 0x33, 0x15, 0x31, 0x30, 0xfb, 0x44, 0x8f, 0xb7, 0x9e, 0x8a, 0x66, 0x9d,
+                0xb8, 0xa0, 0xf3, 0x5c, 0xdf, 0x9a, 0xe5, 0xd3, 0x2d, 0x73, 0x2f, 0xc7, 0x94, 0x18,
+                0xe2, 0x3b, 0x45, 0x1d, 0xdc, 0x95, 0xa2, 0x2a, 0xba, 0xbb, 0x05, 0x6e, 0xc6, 0xb5,
+                0xe8, 0xba, 0x4f, 0x52,
+            ],
+            c_enc: [
+                0xb4, 0x15, 0x88, 0x23, 0x1d, 0x6b, 0xa2, 0x9c, 0xc5, 0xb9, 0xaa, 0xf0, 0xc1, 0xf0,
+                0xba, 0x44, 0x16, 0x6e, 0xdb, 0x8a, 0x27, 0x29, 0xca, 0xba, 0x53, 0x71, 0xe7, 0xac,
+                0x36, 0x90, 0x0f, 0xaa, 0x64, 0xf5, 0x76, 0x0d, 0xce, 0x55, 0x20, 0xda, 0x82, 0x8d,
+                0x5e, 0x25, 0xbd, 0x83, 0x51, 0x95, 0x11, 0x64, 0x12, 0x11, 0x80, 0x9d, 0xff, 0xd8,
+                0xcf, 0xeb, 0xff, 0xf3, 0xcd, 0xdc, 0xd2, 0x75, 0x88, 0x1e, 0x39, 0xb6, 0x3d, 0xac,
+                0x4d, 0x98, 0x6b, 0x10, 0xc0, 0xe4, 0xc5, 0x52, 0x63, 0xde, 0x3e, 0x02, 0x54, 0x94,
+                0x81, 0x8a, 0x38, 0x08, 0xd9, 0xab, 0xc6, 0xec, 0x38, 0x8f, 0x95, 0x26, 0x73, 0x95,
+                0x0a, 0xa2, 0xd0, 0xe4, 0xba, 0x00, 0x53, 0x75, 0xac, 0x60, 0x5d, 0xc8, 0x25, 0xde,
+                0x4d, 0xd8, 0x93, 0x8b, 0x94, 0x7f, 0xf7, 0x19, 0x4c, 0xfe, 0x7c, 0x1d, 0x79, 0xa1,
+                0x27, 0x15, 0x5d, 0x11, 0xcb, 0xe3, 0x43, 0xf3, 0x2f, 0xd1, 0x0c, 0x7d, 0xae, 0x39,
+                0x1f, 0x00, 0xb4, 0x4f, 0xbe, 0x30, 0x1c, 0x63, 0xfd, 0x4b, 0xf1, 0xc0, 0xdf, 0xb6,
+                0xc9, 0xec, 0xb4, 0xc3, 0xf3, 0xfe, 0xf5, 0x40, 0xb6, 0x7e, 0xb9, 0x23, 0x13, 0x71,
+                0x9c, 0x5a, 0x30, 0x7a, 0xd3, 0x95, 0x6b, 0xb9, 0x4e, 0x29, 0x86, 0x85, 0x2a, 0x64,
+                0x5a, 0x95, 0xd6, 0xdc, 0x75, 0xaa, 0x27, 0x4c, 0xcf, 0xd2, 0x71, 0xd0, 0xea, 0xe2,
+                0x65, 0x81, 0xf5, 0xf5, 0x5d, 0x64, 0x74, 0xaa, 0xad, 0x37, 0x4c, 0x86, 0x45, 0x05,
+                0xe6, 0x92, 0x37, 0xf6, 0x66, 0x99, 0xee, 0x39, 0xe9, 0xfc, 0xf5, 0xb1, 0xb7, 0x03,
+                0x35, 0x1e, 0x71, 0xf6, 0x3b, 0x02, 0x33, 0x40, 0x82, 0xee, 0xbe, 0xd8, 0x68, 0xb5,
+                0x61, 0x2a, 0x33, 0x95, 0x78, 0x5a, 0x33, 0x2a, 0x52, 0x43, 0xe4, 0x98, 0x6e, 0x1f,
+                0xf5, 0xb4, 0x2d, 0x06, 0x69, 0xc1, 0x5c, 0x45, 0xff, 0x81, 0xe2, 0x2e, 0xea, 0xe4,
+                0xde, 0x7d, 0x9a, 0x4f, 0x57, 0x24, 0xc8, 0x96, 0x03, 0x94, 0x92, 0x5b, 0xa1, 0xa1,
+                0x90, 0x0f, 0xa2, 0xb5, 0x59, 0x3d, 0x55, 0x45, 0x5e, 0x0b, 0xe0, 0x31, 0x8c, 0x80,
+                0x23, 0x81, 0xec, 0x9c, 0x0a, 0x83, 0xc2, 0xe5, 0xf9, 0x33, 0x9f, 0x02, 0x9c, 0x44,
+                0x24, 0x72, 0x8f, 0x91, 0x9d, 0x18, 0x4f, 0x36, 0x16, 0x50, 0xba, 0x65, 0xd6, 0x98,
+                0xa8, 0xd1, 0x67, 0xbe, 0xd9, 0xdd, 0x01, 0xfa, 0x70, 0x74, 0xe4, 0x6a, 0xf6, 0x57,
+                0x16, 0xdd, 0xd9, 0x7e, 0x7b, 0xb6, 0x00, 0x13, 0x05, 0x96, 0x8c, 0xd5, 0xb4, 0x87,
+                0x0d, 0xf2, 0x00, 0x42, 0xe7, 0x69, 0xe0, 0x2d, 0xf1, 0x8b, 0x9f, 0xde, 0x9f, 0xda,
+                0xa7, 0x6b, 0x00, 0xca, 0x26, 0x45, 0x9d, 0x54, 0x37, 0x19, 0x19, 0x72, 0xd7, 0x08,
+                0xde, 0xda, 0xbf, 0x1d, 0x61, 0x7f, 0x73, 0x3a, 0x60, 0xeb, 0xfe, 0xc6, 0xac, 0xf0,
+                0x0b, 0xb1, 0xdf, 0xbf, 0x11, 0x2d, 0x3a, 0xaa, 0xc9, 0xfb, 0xd2, 0x30, 0xcc, 0xaa,
+                0x9c, 0xf3, 0x58, 0x45, 0x93, 0x54, 0xac, 0x5b, 0x29, 0xbd, 0xb7, 0x3a, 0x45, 0x27,
+                0x1b, 0x1f, 0x9e, 0xd0, 0x0e, 0x3e, 0x20, 0xb1, 0x2f, 0xed, 0x5c, 0xd5, 0x6a, 0xbb,
+                0xb0, 0xb9, 0x4a, 0x9e, 0xee, 0x5f, 0xf8, 0xf9, 0x36, 0x1d, 0xfd, 0x6c, 0x94, 0x08,
+                0x5d, 0x28, 0x98, 0xe5, 0x46, 0xeb, 0x92, 0xe6, 0xdb, 0xe9, 0xf0, 0x2e, 0xb5, 0xbf,
+                0x7d, 0x12, 0x67, 0x5d, 0x3c, 0x6a, 0xc7, 0x18, 0x4b, 0x26, 0x01, 0xe4, 0xf4, 0x05,
+                0x37, 0x3a, 0x4f, 0x1c, 0x5d, 0xf7, 0x6b, 0x3c, 0xb5, 0x29, 0x99, 0xd8, 0x0f, 0x59,
+                0xb3, 0x94, 0xbc, 0xed, 0x9f, 0x66, 0xbc, 0xf7, 0xdc, 0x37, 0xc2, 0xb4, 0xc6, 0xf7,
+                0x74, 0x5b, 0xc6, 0xf0, 0x37, 0x74, 0xfa, 0xc6, 0x24, 0x5d, 0x7c, 0x63, 0x6d, 0xfc,
+                0x5f, 0x76, 0x58, 0xb2, 0xd2, 0xfd, 0x84, 0xac, 0xa9, 0xe0, 0xef, 0xcd, 0xe0, 0x09,
+                0x3e, 0x62, 0x29, 0x38, 0xb7, 0x5d, 0xae, 0x66, 0xcf, 0x63, 0xf6, 0xd2, 0x35, 0x17,
+                0x2e, 0x5a, 0x0b, 0xbe, 0xcd, 0x15, 0x56, 0x6c, 0x61, 0xfe, 0x5a, 0x58, 0x94, 0x7c,
+                0x18, 0xb9, 0xb5, 0xa1, 0x21, 0x11, 0x25, 0x94, 0x3b, 0x09, 0x32, 0x24, 0x96, 0x7b,
+                0x7e, 0x44, 0x16, 0x70, 0x64, 0xc9,
+            ],
+            ock: [
+                0xbc, 0x1b, 0xa7, 0xae, 0x73, 0xe7, 0x39, 0x7a, 0x64, 0xe0, 0xbd, 0x98, 0x63, 0xf1,
+                0x33, 0x95, 0xdc, 0x0b, 0x15, 0xd4, 0x4e, 0x86, 0x70, 0xf1, 0x85, 0x5b, 0x68, 0xc2,
+                0x9f, 0x97, 0x9a, 0xd2,
+            ],
+            op: [
+                0xcc, 0x18, 0xe4, 0xb6, 0x5f, 0x89, 0x34, 0x06, 0x31, 0x5d, 0xb7, 0x1f, 0xac, 0x06,
+                0x5d, 0x71, 0xd0, 0xea, 0xba, 0x7c, 0xf3, 0xc2, 0xba, 0x94, 0x77, 0x12, 0x32, 0x75,
+                0x43, 0x4b, 0x1e, 0xb0, 0xaa, 0x84, 0x16, 0x79, 0xd4, 0xd2, 0x40, 0xb0, 0xab, 0xc4,
+                0xa5, 0xd8, 0x9a, 0xa8, 0xd6, 0xb3, 0xb0, 0x86, 0x92, 0x23, 0xed, 0x76, 0x3b, 0x67,
+                0x6a, 0x72, 0xcb, 0x74, 0xfb, 0x18, 0xd1, 0x17,
+            ],
+            c_out: [
+                0xe2, 0x76, 0x3c, 0x2c, 0xd3, 0x04, 0x29, 0x45, 0x25, 0xf6, 0x6d, 0x17, 0xcd, 0xb4,
+                0x2a, 0x6d, 0xaf, 0xd7, 0x47, 0x38, 0x37, 0x71, 0x52, 0x35, 0x62, 0xb2, 0x71, 0xbb,
+                0xf5, 0xb2, 0x88, 0x41, 0xb5, 0xca, 0x65, 0xfd, 0xd3, 0x42, 0xee, 0x80, 0x2f, 0xee,
+                0x12, 0x12, 0x47, 0x22, 0xcf, 0xf5, 0xe1, 0x99, 0xd6, 0xd9, 0x5c, 0x2f, 0x88, 0xc4,
+                0xe2, 0x31, 0x31, 0xf4, 0xe7, 0x6b, 0xa7, 0x6b, 0x9d, 0x64, 0x66, 0x78, 0xd8, 0x53,
+                0xd1, 0xdc, 0xaf, 0x81, 0xb8, 0x0e, 0x2e, 0xfd, 0xf0, 0x60,
+            ],
+            note_type: Some([
+                0x64, 0xd0, 0x87, 0x40, 0x89, 0x86, 0xe7, 0x3d, 0x6e, 0x28, 0x4f, 0xea, 0x9a, 0x23,
+                0xc3, 0x93, 0x11, 0x78, 0x2f, 0x86, 0xca, 0xbf, 0xf9, 0x45, 0x5e, 0x4c, 0xf6, 0x99,
+                0xe5, 0xf5, 0xd4, 0xbc,
+            ]),
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xb4, 0x9e, 0x3c, 0x5b, 0xb9, 0x9e, 0x47, 0xc5, 0x3d, 0x6e, 0x5c, 0x34, 0x7c, 0x99,
+                0x8f, 0x30, 0x2d, 0x3f, 0xf4, 0x75, 0x23, 0xe7, 0xc3, 0xd7, 0xb6, 0x4c, 0x82, 0x98,
+                0xdc, 0x7b, 0x10, 0xe9, 0x54, 0xdf, 0x06, 0x00, 0x0b, 0xc0, 0xcc, 0x30, 0xec, 0xf6,
+                0x75, 0x5d, 0x92, 0x7e, 0xee, 0xce, 0xe6, 0xec, 0x9e, 0x8e, 0x0c, 0xba, 0xa3, 0x1b,
+                0x71, 0xe0, 0xa4, 0x33, 0x4a, 0xd6, 0x42, 0x1b,
+            ],
+            ovk: [
+                0x97, 0x9f, 0x06, 0x58, 0x66, 0x73, 0xbc, 0x6f, 0xf1, 0xc5, 0xd3, 0xb3, 0x20, 0xf3,
+                0x49, 0xa5, 0xb3, 0xa8, 0xb3, 0x55, 0x59, 0x22, 0x96, 0xaa, 0xf6, 0x1c, 0x5b, 0x72,
+                0x52, 0xf7, 0x3e, 0xc0,
+            ],
+            default_d: [
+                0x8d, 0xb1, 0x31, 0xa6, 0x5b, 0xa6, 0xca, 0x91, 0xc9, 0xe9, 0x7b,
+            ],
+            default_pk_d: [
+                0x6f, 0xce, 0x26, 0xab, 0xe6, 0xc0, 0xb6, 0x84, 0x37, 0x36, 0x96, 0x46, 0xee, 0xe1,
+                0xe9, 0xdc, 0xa5, 0x1a, 0x42, 0x58, 0xf3, 0xae, 0x72, 0x23, 0x87, 0xf6, 0xd0, 0xdf,
+                0xf4, 0x1a, 0x1f, 0x88,
+            ],
+            v: 5531329397987978327,
+            rseed: [
+                0x1f, 0xbd, 0x83, 0xd5, 0x4a, 0xaf, 0x44, 0x1e, 0x31, 0x9e, 0xa4, 0x7a, 0x86, 0x2a,
+                0xd0, 0x29, 0x3c, 0xed, 0xf5, 0xdd, 0x9e, 0xda, 0xde, 0xee, 0x33, 0xcb, 0x52, 0x2c,
+                0xd0, 0x11, 0x8b, 0xbd,
+            ],
+            memo: [
+                0xff, 0x81, 0x1a, 0xce, 0x9a, 0x23, 0xbd, 0xa3, 0x9a, 0xba, 0x72, 0xf1, 0x56, 0x6f,
+                0xc1, 0x68, 0x84, 0x97, 0xd2, 0xa7, 0x92, 0x8c, 0x36, 0x70, 0x15, 0x25, 0x67, 0x8b,
+                0xc9, 0x72, 0x14, 0xb3, 0x1b, 0x37, 0xba, 0xb4, 0x6b, 0x88, 0xf2, 0x7f, 0x04, 0x48,
+                0xde, 0xcb, 0x31, 0x62, 0x2d, 0x0f, 0x0f, 0x87, 0xa8, 0x55, 0xba, 0x54, 0x00, 0x03,
+                0x32, 0x03, 0x1f, 0x73, 0xab, 0xff, 0xd4, 0x65, 0x91, 0xda, 0x0b, 0x88, 0x72, 0x35,
+                0x04, 0xed, 0xb2, 0x33, 0x72, 0x30, 0xda, 0xd2, 0xac, 0xc0, 0xd8, 0xbb, 0x68, 0xbc,
+                0x83, 0x7a, 0x2f, 0xf9, 0x30, 0xbf, 0xf0, 0x6f, 0xde, 0x74, 0xeb, 0x90, 0xaa, 0xe4,
+                0xf6, 0x0d, 0xbb, 0x6e, 0xb8, 0x27, 0xea, 0x99, 0x88, 0x4a, 0xcd, 0x62, 0x85, 0xa9,
+                0x88, 0x92, 0x80, 0x2c, 0xf5, 0x9d, 0x5d, 0x60, 0xd0, 0x16, 0x63, 0x38, 0x7b, 0x3e,
+                0xd2, 0x72, 0x3b, 0xd6, 0x48, 0x9e, 0x9c, 0x2c, 0x10, 0x6d, 0x4a, 0xa2, 0xde, 0x23,
+                0xce, 0xd1, 0x6c, 0x72, 0x04, 0x29, 0xc7, 0x75, 0x3a, 0x77, 0x38, 0xec, 0x7d, 0x9d,
+                0xb8, 0x62, 0x42, 0x29, 0xed, 0xd2, 0x17, 0xb8, 0x0d, 0x74, 0x87, 0x5a, 0x14, 0xca,
+                0xe4, 0x86, 0x3f, 0x13, 0x9e, 0x9c, 0x0b, 0x13, 0x1b, 0x2a, 0x4c, 0x28, 0x07, 0x1a,
+                0x38, 0xec, 0x61, 0xf6, 0x68, 0x01, 0xaa, 0x59, 0x56, 0xfc, 0xb2, 0xa4, 0x6b, 0x95,
+                0x87, 0x66, 0x5b, 0x75, 0x71, 0xaa, 0x03, 0x48, 0x1f, 0xd8, 0xd9, 0xd5, 0x69, 0x8f,
+                0x83, 0x6f, 0xc8, 0x63, 0x5e, 0x69, 0xe3, 0xbd, 0xe4, 0x2f, 0x4a, 0xc0, 0x71, 0x32,
+                0x8b, 0x54, 0x09, 0xf6, 0xe4, 0x2d, 0x79, 0x0a, 0xed, 0xd7, 0x3b, 0xc1, 0xa2, 0x35,
+                0x47, 0x23, 0xb3, 0xb8, 0x19, 0xd0, 0x63, 0x7a, 0x6f, 0xa4, 0x66, 0x39, 0x46, 0xa3,
+                0x0a, 0xc5, 0xaf, 0xdd, 0x30, 0xce, 0x83, 0x0f, 0x67, 0x91, 0xb4, 0x57, 0x52, 0x70,
+                0xa1, 0x72, 0x0f, 0x91, 0x86, 0x6e, 0x2b, 0x86, 0xf4, 0x78, 0x88, 0x94, 0xc8, 0xda,
+                0x62, 0xd8, 0xb9, 0x1f, 0xaf, 0x52, 0x0e, 0x3b, 0xed, 0xbc, 0x12, 0x06, 0xa5, 0xa5,
+                0xe6, 0xef, 0xd3, 0xdf, 0xde, 0x08, 0x43, 0xc3, 0xb0, 0x67, 0x57, 0x64, 0x3f, 0xc0,
+                0x06, 0x00, 0x88, 0x38, 0xca, 0x47, 0x30, 0x87, 0xf8, 0x97, 0x79, 0x18, 0xcc, 0x1b,
+                0x81, 0xc9, 0xe6, 0x8e, 0x3b, 0x88, 0x8f, 0xe6, 0xf7, 0xc6, 0x30, 0xf1, 0xbc, 0x7a,
+                0xe1, 0x88, 0xf5, 0x12, 0x84, 0x20, 0x41, 0xca, 0xda, 0x1e, 0x05, 0xf8, 0x66, 0xd2,
+                0x56, 0x2d, 0xbe, 0x09, 0xc4, 0xb4, 0x30, 0x68, 0xf7, 0x54, 0xda, 0xd3, 0x4d, 0xf0,
+                0xfc, 0xfc, 0x18, 0x1f, 0x31, 0x80, 0x1a, 0x79, 0x92, 0xd2, 0xf1, 0x6b, 0xe0, 0x21,
+                0x1b, 0x4a, 0x22, 0xf6, 0x2a, 0xab, 0x64, 0x70, 0x1b, 0xf4, 0xa4, 0xe6, 0xd6, 0x66,
+                0xfc, 0x30, 0x4a, 0x5c, 0x79, 0xc6, 0x09, 0xac, 0xc4, 0x3b, 0x00, 0xb4, 0x86, 0x48,
+                0x93, 0xd3, 0x7d, 0x50, 0x07, 0xf0, 0xc3, 0x29, 0xa4, 0x75, 0x50, 0x52, 0x57, 0x75,
+                0x70, 0xdd, 0x38, 0xfa, 0xc0, 0x43, 0xcd, 0x91, 0xc1, 0x2e, 0xe3, 0x4e, 0x9c, 0xfa,
+                0xe3, 0x92, 0xa7, 0x8b, 0xda, 0xbd, 0x4e, 0xe3, 0x1d, 0xc0, 0xde, 0xb0, 0x2f, 0xe7,
+                0xb1, 0xd8, 0xb0, 0x17, 0x8a, 0xc9, 0x51, 0x31, 0x05, 0xfc, 0xc7, 0xe3, 0x0b, 0xa8,
+                0xe0, 0x16, 0xaa, 0x36, 0xa6, 0xb5, 0xdf, 0x5e, 0x5a, 0x19, 0x09, 0xf6, 0x3a, 0xba,
+                0x09, 0x5d, 0x98, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ],
+            cv_net: [
+                0x50, 0xaf, 0x90, 0x31, 0xf4, 0xe0, 0x4b, 0x79, 0xd7, 0xda, 0xb5, 0xe8, 0x5b, 0x51,
+                0xee, 0x9b, 0xea, 0x56, 0xf7, 0xc5, 0x6b, 0x52, 0x22, 0x73, 0xd2, 0x30, 0xaa, 0x51,
+                0x2b, 0xa9, 0xe7, 0x06,
+            ],
+            rho: [
+                0x09, 0x1d, 0x83, 0x73, 0x3a, 0x9f, 0xfb, 0x18, 0xc1, 0x7a, 0xd1, 0x93, 0x8d, 0xd2,
+                0x67, 0x93, 0xc3, 0xfe, 0xfa, 0xda, 0xee, 0xa8, 0xe2, 0x3c, 0x44, 0xd5, 0xe0, 0x18,
+                0x4b, 0xc8, 0x45, 0x10,
+            ],
+            cmx: [
+                0x76, 0xf1, 0xbd, 0x50, 0xf9, 0xb9, 0x06, 0xcb, 0x9f, 0xf2, 0xdd, 0x91, 0x8a, 0x36,
+                0x7e, 0x5f, 0xb1, 0xa2, 0xef, 0x39, 0xf1, 0x4f, 0x6c, 0xe9, 0x4f, 0xf9, 0xf0, 0x91,
+                0x55, 0xf8, 0xc2, 0x11,
+            ],
+            esk: [
+                0x2f, 0x98, 0x2d, 0xec, 0xa7, 0x60, 0x51, 0x41, 0xd9, 0xc9, 0xa1, 0xe6, 0xfb, 0x57,
+                0xe2, 0xb8, 0x01, 0xb4, 0x49, 0x6f, 0xbd, 0xd4, 0xc0, 0xa8, 0xb9, 0x5f, 0xc8, 0x7e,
+                0xa7, 0x37, 0x3e, 0x2f,
+            ],
+            ephemeral_key: [
+                0xda, 0x72, 0x84, 0xa0, 0xe0, 0xde, 0x52, 0x09, 0x3c, 0xc2, 0xe1, 0x9c, 0x0a, 0xf1,
+                0x93, 0xbd, 0xb4, 0x2c, 0x80, 0xc9, 0xc7, 0xf9, 0xf2, 0x36, 0x00, 0xe6, 0x08, 0x01,
+                0x72, 0xc5, 0xf5, 0x39,
+            ],
+            shared_secret: [
+                0x9b, 0xcf, 0xb9, 0x6f, 0x4c, 0xf1, 0x83, 0xc1, 0x7f, 0xb1, 0x99, 0xda, 0x16, 0x5f,
+                0xbf, 0x8a, 0x47, 0x47, 0x7e, 0x00, 0x36, 0x6d, 0x1c, 0xb7, 0x3b, 0x32, 0xec, 0x0e,
+                0x3a, 0xc1, 0x98, 0x0f,
+            ],
+            k_enc: [
+                0x21, 0xe0, 0x97, 0x87, 0x0a, 0xee, 0xc0, 0x19, 0x76, 0x86, 0xee, 0x37, 0x22, 0x78,
+                0xfe, 0x4a, 0xa2, 0x23, 0x8d, 0x87, 0x65, 0x32, 0x63, 0x84, 0x8a, 0x2f, 0xf5, 0x27,
+                0x9f, 0x2b, 0x1d, 0x9b,
+            ],
+            p_enc: [
+                0x03, 0x8d, 0xb1, 0x31, 0xa6, 0x5b, 0xa6, 0xca, 0x91, 0xc9, 0xe9, 0x7b, 0x57, 0xac,
+                0xbf, 0xfe, 0xc7, 0x3a, 0xc3, 0x4c, 0x1f, 0xbd, 0x83, 0xd5, 0x4a, 0xaf, 0x44, 0x1e,
+                0x31, 0x9e, 0xa4, 0x7a, 0x86, 0x2a, 0xd0, 0x29, 0x3c, 0xed, 0xf5, 0xdd, 0x9e, 0xda,
+                0xde, 0xee, 0x33, 0xcb, 0x52, 0x2c, 0xd0, 0x11, 0x8b, 0xbd, 0xc3, 0xcc, 0x4f, 0x43,
+                0xfa, 0x01, 0x88, 0x52, 0x1b, 0xc6, 0x1b, 0x21, 0xdd, 0x04, 0xe3, 0x7a, 0x83, 0xec,
+                0xe6, 0x8c, 0xa7, 0xa2, 0xfa, 0x6c, 0x8f, 0x9e, 0x34, 0xa6, 0x29, 0x03, 0x35, 0xaa,
+                0xff, 0x81, 0x1a, 0xce, 0x9a, 0x23, 0xbd, 0xa3, 0x9a, 0xba, 0x72, 0xf1, 0x56, 0x6f,
+                0xc1, 0x68, 0x84, 0x97, 0xd2, 0xa7, 0x92, 0x8c, 0x36, 0x70, 0x15, 0x25, 0x67, 0x8b,
+                0xc9, 0x72, 0x14, 0xb3, 0x1b, 0x37, 0xba, 0xb4, 0x6b, 0x88, 0xf2, 0x7f, 0x04, 0x48,
+                0xde, 0xcb, 0x31, 0x62, 0x2d, 0x0f, 0x0f, 0x87, 0xa8, 0x55, 0xba, 0x54, 0x00, 0x03,
+                0x32, 0x03, 0x1f, 0x73, 0xab, 0xff, 0xd4, 0x65, 0x91, 0xda, 0x0b, 0x88, 0x72, 0x35,
+                0x04, 0xed, 0xb2, 0x33, 0x72, 0x30, 0xda, 0xd2, 0xac, 0xc0, 0xd8, 0xbb, 0x68, 0xbc,
+                0x83, 0x7a, 0x2f, 0xf9, 0x30, 0xbf, 0xf0, 0x6f, 0xde, 0x74, 0xeb, 0x90, 0xaa, 0xe4,
+                0xf6, 0x0d, 0xbb, 0x6e, 0xb8, 0x27, 0xea, 0x99, 0x88, 0x4a, 0xcd, 0x62, 0x85, 0xa9,
+                0x88, 0x92, 0x80, 0x2c, 0xf5, 0x9d, 0x5d, 0x60, 0xd0, 0x16, 0x63, 0x38, 0x7b, 0x3e,
+                0xd2, 0x72, 0x3b, 0xd6, 0x48, 0x9e, 0x9c, 0x2c, 0x10, 0x6d, 0x4a, 0xa2, 0xde, 0x23,
+                0xce, 0xd1, 0x6c, 0x72, 0x04, 0x29, 0xc7, 0x75, 0x3a, 0x77, 0x38, 0xec, 0x7d, 0x9d,
+                0xb8, 0x62, 0x42, 0x29, 0xed, 0xd2, 0x17, 0xb8, 0x0d, 0x74, 0x87, 0x5a, 0x14, 0xca,
+                0xe4, 0x86, 0x3f, 0x13, 0x9e, 0x9c, 0x0b, 0x13, 0x1b, 0x2a, 0x4c, 0x28, 0x07, 0x1a,
+                0x38, 0xec, 0x61, 0xf6, 0x68, 0x01, 0xaa, 0x59, 0x56, 0xfc, 0xb2, 0xa4, 0x6b, 0x95,
+                0x87, 0x66, 0x5b, 0x75, 0x71, 0xaa, 0x03, 0x48, 0x1f, 0xd8, 0xd9, 0xd5, 0x69, 0x8f,
+                0x83, 0x6f, 0xc8, 0x63, 0x5e, 0x69, 0xe3, 0xbd, 0xe4, 0x2f, 0x4a, 0xc0, 0x71, 0x32,
+                0x8b, 0x54, 0x09, 0xf6, 0xe4, 0x2d, 0x79, 0x0a, 0xed, 0xd7, 0x3b, 0xc1, 0xa2, 0x35,
+                0x47, 0x23, 0xb3, 0xb8, 0x19, 0xd0, 0x63, 0x7a, 0x6f, 0xa4, 0x66, 0x39, 0x46, 0xa3,
+                0x0a, 0xc5, 0xaf, 0xdd, 0x30, 0xce, 0x83, 0x0f, 0x67, 0x91, 0xb4, 0x57, 0x52, 0x70,
+                0xa1, 0x72, 0x0f, 0x91, 0x86, 0x6e, 0x2b, 0x86, 0xf4, 0x78, 0x88, 0x94, 0xc8, 0xda,
+                0x62, 0xd8, 0xb9, 0x1f, 0xaf, 0x52, 0x0e, 0x3b, 0xed, 0xbc, 0x12, 0x06, 0xa5, 0xa5,
+                0xe6, 0xef, 0xd3, 0xdf, 0xde, 0x08, 0x43, 0xc3, 0xb0, 0x67, 0x57, 0x64, 0x3f, 0xc0,
+                0x06, 0x00, 0x88, 0x38, 0xca, 0x47, 0x30, 0x87, 0xf8, 0x97, 0x79, 0x18, 0xcc, 0x1b,
+                0x81, 0xc9, 0xe6, 0x8e, 0x3b, 0x88, 0x8f, 0xe6, 0xf7, 0xc6, 0x30, 0xf1, 0xbc, 0x7a,
+                0xe1, 0x88, 0xf5, 0x12, 0x84, 0x20, 0x41, 0xca, 0xda, 0x1e, 0x05, 0xf8, 0x66, 0xd2,
+                0x56, 0x2d, 0xbe, 0x09, 0xc4, 0xb4, 0x30, 0x68, 0xf7, 0x54, 0xda, 0xd3, 0x4d, 0xf0,
+                0xfc, 0xfc, 0x18, 0x1f, 0x31, 0x80, 0x1a, 0x79, 0x92, 0xd2, 0xf1, 0x6b, 0xe0, 0x21,
+                0x1b, 0x4a, 0x22, 0xf6, 0x2a, 0xab, 0x64, 0x70, 0x1b, 0xf4, 0xa4, 0xe6, 0xd6, 0x66,
+                0xfc, 0x30, 0x4a, 0x5c, 0x79, 0xc6, 0x09, 0xac, 0xc4, 0x3b, 0x00, 0xb4, 0x86, 0x48,
+                0x93, 0xd3, 0x7d, 0x50, 0x07, 0xf0, 0xc3, 0x29, 0xa4, 0x75, 0x50, 0x52, 0x57, 0x75,
+                0x70, 0xdd, 0x38, 0xfa, 0xc0, 0x43, 0xcd, 0x91, 0xc1, 0x2e, 0xe3, 0x4e, 0x9c, 0xfa,
+                0xe3, 0x92, 0xa7, 0x8b, 0xda, 0xbd, 0x4e, 0xe3, 0x1d, 0xc0, 0xde, 0xb0, 0x2f, 0xe7,
+                0xb1, 0xd8, 0xb0, 0x17, 0x8a, 0xc9, 0x51, 0x31, 0x05, 0xfc, 0xc7, 0xe3, 0x0b, 0xa8,
+                0xe0, 0x16, 0xaa, 0x36, 0xa6, 0xb5, 0xdf, 0x5e, 0x5a, 0x19, 0x09, 0xf6, 0x3a, 0xba,
+                0x09, 0x5d, 0x98, 0x77,
+            ],
+            c_enc: [
+                0x13, 0xd7, 0xdf, 0xcd, 0x1d, 0x75, 0x4d, 0xcd, 0x16, 0x52, 0x32, 0x83, 0x8f, 0x14,
+                0xdd, 0x80, 0x5e, 0x12, 0xcc, 0x7e, 0x75, 0x15, 0x43, 0xd2, 0xa6, 0x8e, 0x23, 0x7a,
+                0x92, 0x3b, 0xce, 0xeb, 0xa3, 0x5a, 0x62, 0x43, 0xc6, 0xa4, 0xc5, 0xf0, 0xd2, 0xa4,
+                0xc3, 0x86, 0x07, 0xa6, 0xf1, 0x1b, 0x17, 0xfd, 0xd6, 0xc6, 0x92, 0x66, 0xf2, 0xc9,
+                0x6a, 0xdc, 0x44, 0x6f, 0x2e, 0x2d, 0x07, 0x3e, 0xe9, 0xea, 0xe2, 0x9a, 0x37, 0xef,
+                0x5d, 0x03, 0xf6, 0x78, 0xf5, 0x56, 0x29, 0x45, 0xb2, 0x08, 0x27, 0x76, 0xce, 0x9f,
+                0x39, 0x08, 0x87, 0x3a, 0x99, 0xa6, 0xa2, 0x8b, 0xae, 0xdc, 0x7f, 0x54, 0x89, 0xce,
+                0x4b, 0x30, 0xd8, 0x43, 0x66, 0xc5, 0x46, 0xb4, 0x36, 0x67, 0x91, 0x44, 0xf9, 0x27,
+                0xf7, 0x1c, 0x65, 0x09, 0x69, 0xda, 0x22, 0x42, 0x28, 0x5a, 0x86, 0x27, 0x96, 0x54,
+                0x89, 0xb7, 0x0b, 0x35, 0x6c, 0xf7, 0x4e, 0x07, 0x8a, 0xa2, 0x7d, 0xa8, 0xf9, 0x2f,
+                0xb3, 0x09, 0x57, 0x12, 0x62, 0xf2, 0xd4, 0xc3, 0x36, 0xf7, 0x12, 0x15, 0x9b, 0x3e,
+                0x9b, 0x43, 0x24, 0x38, 0x5b, 0xb3, 0x26, 0x2a, 0xc5, 0xf3, 0x13, 0x57, 0xaf, 0x9e,
+                0x1a, 0xaa, 0x75, 0xd0, 0x1c, 0x06, 0x31, 0xbf, 0xdd, 0x34, 0xc5, 0x9b, 0x27, 0xd5,
+                0x3b, 0xeb, 0xf1, 0xaa, 0x54, 0xe9, 0xc4, 0xaa, 0x98, 0x0f, 0x24, 0x7b, 0xf4, 0x22,
+                0xa0, 0xe6, 0xdb, 0xf5, 0x54, 0x6e, 0xdc, 0x10, 0x0f, 0xce, 0x6c, 0xce, 0xc8, 0x32,
+                0x7e, 0xb4, 0x8a, 0x9a, 0x39, 0xe4, 0xc2, 0xa9, 0x12, 0xb2, 0x98, 0x85, 0xe0, 0xc3,
+                0xe7, 0x33, 0x55, 0x58, 0xbd, 0x85, 0x84, 0x38, 0xd0, 0x35, 0xd2, 0xf2, 0xbe, 0x1d,
+                0x35, 0x66, 0xe4, 0x22, 0xfe, 0x37, 0xc0, 0xcb, 0x2e, 0x05, 0x8d, 0xad, 0x8c, 0xc6,
+                0x45, 0x62, 0xa5, 0x50, 0x1b, 0x54, 0xa4, 0x4f, 0x9a, 0x77, 0x77, 0xc6, 0xd2, 0x77,
+                0x04, 0xa4, 0xce, 0xad, 0x26, 0xa1, 0xc2, 0x56, 0x01, 0x8d, 0xc1, 0xbb, 0xfa, 0x58,
+                0x84, 0xa0, 0x6c, 0xc7, 0x25, 0x23, 0xaf, 0xfb, 0x43, 0xf5, 0xc5, 0xbc, 0x2f, 0x1d,
+                0x36, 0x04, 0x0f, 0x85, 0xf7, 0xe8, 0xc0, 0x62, 0xc1, 0xf2, 0x26, 0x50, 0x9d, 0x20,
+                0xf9, 0xa4, 0x88, 0x5e, 0x15, 0x70, 0x4f, 0x73, 0x01, 0xdf, 0x60, 0x3d, 0xa1, 0xfc,
+                0x5b, 0xca, 0x84, 0xf8, 0x55, 0xc1, 0x17, 0xcb, 0x30, 0x55, 0xc5, 0x70, 0x83, 0x45,
+                0x7e, 0x1d, 0x14, 0x85, 0x7c, 0x2b, 0xf9, 0x41, 0xe8, 0x20, 0x73, 0x5c, 0x58, 0x8a,
+                0xae, 0x6f, 0x66, 0x45, 0xdc, 0x3f, 0xbd, 0x30, 0x65, 0xab, 0xa1, 0x7f, 0xd2, 0x48,
+                0x2a, 0x1b, 0x37, 0xb2, 0xf3, 0x88, 0x07, 0x5e, 0x46, 0xbb, 0x9d, 0x37, 0x27, 0xcc,
+                0x73, 0xdb, 0xae, 0x0e, 0x96, 0xa8, 0x44, 0x5f, 0xda, 0x8f, 0x87, 0x64, 0xf9, 0x68,
+                0x0b, 0xf6, 0xc5, 0x91, 0xa8, 0x48, 0x10, 0xfa, 0x0c, 0x1b, 0x5a, 0x2f, 0x2a, 0xa9,
+                0xad, 0xbb, 0x88, 0x64, 0x22, 0x31, 0x72, 0x1e, 0xd6, 0xea, 0x12, 0x16, 0xab, 0x9b,
+                0xfa, 0x0e, 0x12, 0x4c, 0xe4, 0x74, 0x94, 0x44, 0x53, 0x4d, 0x68, 0x70, 0x19, 0x74,
+                0x60, 0xf7, 0x49, 0xef, 0xb0, 0x28, 0x8f, 0x96, 0x28, 0x3f, 0xc9, 0x37, 0xef, 0xbb,
+                0x14, 0x59, 0xaa, 0x73, 0xc2, 0x7b, 0x6b, 0x2b, 0x5c, 0x57, 0x7d, 0x46, 0x60, 0xf9,
+                0x8e, 0x81, 0x8c, 0xaa, 0xad, 0xbe, 0x45, 0x4e, 0xcd, 0x16, 0xc1, 0xd8, 0xa9, 0x9b,
+                0x77, 0x97, 0x8e, 0x93, 0xd6, 0x9d, 0xcb, 0x8b, 0xf0, 0xe8, 0x4a, 0x0a, 0x91, 0x3f,
+                0x55, 0xcc, 0x16, 0x50, 0xc2, 0xb9, 0x2d, 0x4c, 0x9d, 0xcd, 0xb1, 0x2e, 0xe2, 0x36,
+                0x7e, 0xd9, 0x79, 0xb9, 0x53, 0x5f, 0xe1, 0x5c, 0x87, 0xd1, 0x7f, 0x37, 0xa3, 0x24,
+                0x84, 0x7f, 0x16, 0x45, 0x39, 0x75, 0x7d, 0x83, 0x00, 0x87, 0xf6, 0x39, 0xeb, 0x6c,
+                0x3e, 0xfb, 0x8d, 0xa4, 0xff, 0xa5, 0xd7, 0xca, 0x58, 0x34, 0x4d, 0x65, 0x81, 0x76,
+                0x64, 0xa7, 0x4e, 0xaf, 0xa1, 0xa4, 0x7f, 0x69, 0xf1, 0xc8, 0x10, 0x6b, 0x6f, 0x5f,
+                0x96, 0x4f, 0x4c, 0x73, 0x68, 0xed, 0x11, 0x06, 0x29, 0x54, 0xd2, 0xe8, 0xd3, 0x0c,
+                0xcc, 0xac, 0xba, 0xd9, 0xa2, 0xfa,
+            ],
+            ock: [
+                0xc7, 0x5b, 0x5b, 0xfa, 0x9f, 0x2e, 0xeb, 0xd9, 0x99, 0x80, 0x78, 0xf1, 0x8f, 0x0e,
+                0x9b, 0x79, 0xf1, 0xe2, 0x13, 0xe8, 0x25, 0x61, 0x6f, 0xeb, 0x26, 0x08, 0xe9, 0xc7,
+                0x81, 0xb5, 0x00, 0x95,
+            ],
+            op: [
+                0x6f, 0xce, 0x26, 0xab, 0xe6, 0xc0, 0xb6, 0x84, 0x37, 0x36, 0x96, 0x46, 0xee, 0xe1,
+                0xe9, 0xdc, 0xa5, 0x1a, 0x42, 0x58, 0xf3, 0xae, 0x72, 0x23, 0x87, 0xf6, 0xd0, 0xdf,
+                0xf4, 0x1a, 0x1f, 0x88, 0x2f, 0x98, 0x2d, 0xec, 0xa7, 0x60, 0x51, 0x41, 0xd9, 0xc9,
+                0xa1, 0xe6, 0xfb, 0x57, 0xe2, 0xb8, 0x01, 0xb4, 0x49, 0x6f, 0xbd, 0xd4, 0xc0, 0xa8,
+                0xb9, 0x5f, 0xc8, 0x7e, 0xa7, 0x37, 0x3e, 0x2f,
+            ],
+            c_out: [
+                0xca, 0x4d, 0x6e, 0xb3, 0xea, 0x95, 0xc5, 0x5a, 0x91, 0x16, 0x85, 0x66, 0xe6, 0x67,
+                0x63, 0xd1, 0x9e, 0x9c, 0x44, 0x33, 0x07, 0x3c, 0x08, 0x9a, 0x7d, 0xb9, 0x5b, 0x93,
+                0xc8, 0xc4, 0x55, 0x0e, 0xb0, 0x8e, 0x28, 0xdd, 0xef, 0xba, 0x64, 0xe0, 0x58, 0xac,
+                0x68, 0x44, 0xad, 0x77, 0x20, 0x67, 0xa1, 0x7c, 0x32, 0x53, 0xc3, 0x9a, 0x72, 0x4d,
+                0xd8, 0x15, 0xf7, 0x29, 0x8c, 0x1d, 0x59, 0x09, 0x1f, 0x1b, 0x38, 0x7a, 0x26, 0x46,
+                0xe7, 0xfe, 0x36, 0x3a, 0xde, 0x83, 0x63, 0xa9, 0x2a, 0xde,
+            ],
+            note_type: Some([
+                0xc3, 0xcc, 0x4f, 0x43, 0xfa, 0x01, 0x88, 0x52, 0x1b, 0xc6, 0x1b, 0x21, 0xdd, 0x04,
+                0xe3, 0x7a, 0x83, 0xec, 0xe6, 0x8c, 0xa7, 0xa2, 0xfa, 0x6c, 0x8f, 0x9e, 0x34, 0xa6,
+                0x29, 0x03, 0x35, 0xaa,
+            ]),
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xa6, 0x68, 0x13, 0x52, 0xa3, 0x52, 0x26, 0x91, 0x10, 0x0f, 0x53, 0xfc, 0x34, 0xab,
+                0x73, 0x32, 0x8a, 0xf1, 0xb9, 0xf3, 0xa4, 0xa0, 0x6d, 0xbd, 0x3a, 0x14, 0x99, 0x67,
+                0x09, 0xe6, 0xf2, 0x84, 0x31, 0xee, 0x72, 0xf2, 0x69, 0xae, 0xd7, 0x5d, 0x36, 0x34,
+                0x89, 0x36, 0x90, 0x5e, 0xbb, 0x91, 0x80, 0x7d, 0x74, 0xd5, 0x0c, 0xb2, 0x7f, 0xcd,
+                0x8b, 0x4f, 0xb6, 0xf4, 0x48, 0xc3, 0x62, 0x03,
+            ],
+            ovk: [
+                0x78, 0xf1, 0x45, 0xea, 0x29, 0xd2, 0x71, 0xb9, 0x40, 0xc6, 0x99, 0x41, 0xe4, 0xc3,
+                0xfd, 0x2d, 0x71, 0xf3, 0xb1, 0x90, 0x69, 0x0e, 0xe1, 0x6f, 0x5d, 0x14, 0xac, 0x22,
+                0x24, 0xe6, 0xfc, 0x89,
+            ],
+            default_d: [
+                0x11, 0x6e, 0x79, 0x94, 0x55, 0xae, 0xa1, 0x91, 0x8f, 0xbf, 0xd4,
+            ],
+            default_pk_d: [
+                0x3e, 0x5e, 0x46, 0xeb, 0x0f, 0xe8, 0xe6, 0xf0, 0xcf, 0x6a, 0xab, 0x2b, 0x41, 0xfb,
+                0xcf, 0xfb, 0xb2, 0x98, 0xf8, 0xd5, 0x34, 0xc8, 0xd9, 0xd3, 0x11, 0xe4, 0xc6, 0x10,
+                0x3a, 0x56, 0x6a, 0xaa,
+            ],
+            v: 15093716717054627455,
+            rseed: [
+                0x7e, 0x62, 0x25, 0x8d, 0x65, 0xa1, 0x92, 0x15, 0x7c, 0xdf, 0x2e, 0xc3, 0x21, 0x40,
+                0x7f, 0x68, 0x2f, 0x5e, 0xec, 0x6a, 0x32, 0x97, 0xab, 0x20, 0xb7, 0x06, 0x1c, 0x62,
+                0x24, 0x57, 0x16, 0xa4,
+            ],
+            memo: [
+                0xff, 0x4f, 0x71, 0xfb, 0xfc, 0x34, 0xc7, 0x9b, 0x44, 0xe0, 0x9e, 0x42, 0x12, 0xac,
+                0x26, 0x53, 0xf6, 0xc4, 0x03, 0x64, 0x3e, 0x1c, 0x5b, 0x9a, 0xd1, 0x34, 0xd8, 0x9c,
+                0x68, 0x0b, 0x70, 0x72, 0x83, 0xaf, 0x54, 0x32, 0x6f, 0xc4, 0xf8, 0x4d, 0x6a, 0x58,
+                0x29, 0xa0, 0xad, 0x48, 0x30, 0x80, 0x6c, 0x05, 0x75, 0x84, 0x92, 0xcd, 0x6a, 0xc4,
+                0x6b, 0xa0, 0x1a, 0x2b, 0x37, 0x22, 0xb5, 0xe4, 0xcd, 0xaf, 0xbb, 0x3f, 0x36, 0x78,
+                0x5f, 0x42, 0x4a, 0xf0, 0x44, 0xda, 0xc5, 0xdb, 0x5f, 0x7d, 0xf8, 0x39, 0xeb, 0x63,
+                0xc0, 0xc1, 0x7d, 0x8b, 0x0c, 0x79, 0xdb, 0x86, 0x30, 0x94, 0x20, 0x15, 0xbe, 0x13,
+                0xf7, 0x9a, 0xf6, 0xf4, 0x3e, 0x5a, 0xb0, 0x77, 0x81, 0x14, 0x79, 0x8f, 0x44, 0x22,
+                0x58, 0xee, 0xdc, 0x43, 0x6f, 0xcc, 0x38, 0x6b, 0x36, 0xb5, 0x7e, 0x19, 0x17, 0xd7,
+                0x20, 0x17, 0x73, 0x66, 0xf4, 0x24, 0xb0, 0xa5, 0x4b, 0x0b, 0x60, 0xf4, 0xfb, 0x13,
+                0x58, 0xc2, 0x0a, 0xa4, 0x1d, 0xc5, 0x02, 0xe1, 0xdd, 0x8a, 0x16, 0x33, 0xf3, 0xd8,
+                0xe3, 0x27, 0x6b, 0x59, 0xe7, 0xd2, 0xc4, 0xe6, 0x24, 0xa6, 0xf5, 0x36, 0x95, 0xbc,
+                0xaf, 0x24, 0x7e, 0x36, 0x48, 0x3f, 0x13, 0xb2, 0x04, 0x42, 0x22, 0x37, 0xfc, 0x6a,
+                0xb3, 0xeb, 0xa0, 0x2f, 0xc4, 0x14, 0x2b, 0x42, 0x97, 0xeb, 0xb5, 0x68, 0x3d, 0xb8,
+                0xd2, 0x43, 0x19, 0x70, 0x6a, 0xd2, 0x6a, 0xaf, 0xd8, 0x1c, 0x53, 0xb7, 0x40, 0xf3,
+                0x45, 0x43, 0xa6, 0xb3, 0xe9, 0xf5, 0xbb, 0x7d, 0x5c, 0x49, 0xe8, 0xc3, 0x7f, 0x61,
+                0x49, 0x21, 0x25, 0x4f, 0x32, 0x12, 0x39, 0x4c, 0x79, 0x7d, 0x1c, 0xee, 0x78, 0x99,
+                0xb7, 0xb4, 0xb6, 0x5b, 0x59, 0xb7, 0x34, 0x2f, 0x92, 0x53, 0x1c, 0x1d, 0x59, 0xe1,
+                0x79, 0x70, 0xb7, 0x31, 0x74, 0x14, 0x43, 0x8c, 0xd8, 0x0b, 0xd0, 0xf9, 0xa6, 0x7c,
+                0x9b, 0x9e, 0x55, 0x2f, 0x01, 0x3c, 0x11, 0x5a, 0x95, 0x4f, 0x35, 0xe0, 0x61, 0x6c,
+                0x68, 0xd4, 0x31, 0x63, 0xd3, 0x34, 0xda, 0xc3, 0x82, 0x70, 0x33, 0xe5, 0xad, 0x84,
+                0x88, 0xbf, 0xd9, 0xc4, 0xbb, 0xbe, 0x8f, 0x59, 0x35, 0xc6, 0xc5, 0xea, 0x04, 0xc3,
+                0xad, 0x49, 0xc7, 0x47, 0xa9, 0xe7, 0x23, 0x1b, 0xcd, 0x7d, 0x16, 0x21, 0x5e, 0x6e,
+                0x80, 0x73, 0x7d, 0x6b, 0x54, 0xfe, 0xc8, 0xb8, 0x84, 0x02, 0xf0, 0x47, 0x52, 0x45,
+                0xe1, 0x74, 0xa7, 0x45, 0xb8, 0x31, 0xf8, 0xfe, 0x03, 0xa7, 0x6f, 0xb9, 0xce, 0xca,
+                0x4d, 0x22, 0xb7, 0x83, 0xc3, 0x28, 0xc6, 0x91, 0x5c, 0x43, 0x40, 0x50, 0x64, 0xae,
+                0x56, 0xbc, 0x89, 0xe6, 0x4d, 0x15, 0x78, 0xe4, 0xd3, 0xa3, 0x4b, 0xb9, 0x55, 0x91,
+                0xea, 0xf1, 0xd3, 0xda, 0x02, 0xa4, 0x54, 0x9f, 0xa8, 0x0d, 0xb0, 0xff, 0x7c, 0xb0,
+                0x39, 0x93, 0xb6, 0x8a, 0xe1, 0x5a, 0x30, 0xe8, 0x79, 0x49, 0xaa, 0x08, 0x0e, 0x94,
+                0xab, 0xde, 0x68, 0x89, 0x8c, 0x33, 0x92, 0xa2, 0x17, 0xd6, 0x49, 0x61, 0x6b, 0xbe,
+                0x73, 0x9b, 0x13, 0xd1, 0x4d, 0xf0, 0x3f, 0xf2, 0x76, 0x71, 0x48, 0x9b, 0xe0, 0xb4,
+                0xbe, 0xba, 0xaf, 0xa7, 0xd1, 0xe6, 0x39, 0xd5, 0xb3, 0xe9, 0x94, 0xff, 0xb6, 0xb7,
+                0xa2, 0x09, 0xf6, 0xad, 0xfe, 0x8d, 0x1e, 0x5c, 0xcf, 0x01, 0x0c, 0x19, 0x16, 0x8a,
+                0xeb, 0x18, 0xaa, 0x9d, 0x68, 0x7e, 0x24, 0xad, 0xc0, 0xb1, 0x13, 0x5c, 0x70, 0xc9,
+                0x70, 0xe0, 0x90, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ],
+            cv_net: [
+                0x72, 0xd8, 0x2a, 0xd6, 0x89, 0xd2, 0x9f, 0x9b, 0x18, 0x9d, 0x5b, 0x44, 0x78, 0x9f,
+                0x55, 0xfe, 0x1e, 0x9b, 0xab, 0x78, 0x8f, 0xf8, 0x7e, 0xbe, 0x9f, 0xc8, 0x59, 0x50,
+                0x4f, 0xb2, 0x3c, 0x8a,
+            ],
+            rho: [
+                0x57, 0x87, 0x18, 0x97, 0x6d, 0xa3, 0xdc, 0xb4, 0x30, 0x32, 0x71, 0x52, 0x20, 0x72,
+                0xd0, 0x28, 0x44, 0x22, 0x13, 0x50, 0x86, 0x4e, 0xed, 0x56, 0x3d, 0xab, 0x30, 0x22,
+                0x7f, 0x28, 0x4b, 0x2e,
+            ],
+            cmx: [
+                0x89, 0xe6, 0xa2, 0xb9, 0x70, 0x84, 0xe3, 0xd3, 0x34, 0x4f, 0xee, 0xb4, 0x64, 0x65,
+                0x05, 0x72, 0x51, 0xb1, 0x9d, 0xa0, 0xce, 0xdf, 0x79, 0x71, 0x94, 0xc5, 0x97, 0xf9,
+                0xf7, 0x7e, 0xf2, 0x1f,
+            ],
+            esk: [
+                0xe4, 0x00, 0x13, 0x04, 0x47, 0xc1, 0xbd, 0x1a, 0x0c, 0x13, 0x02, 0xf5, 0x10, 0xe9,
+                0xeb, 0x09, 0xed, 0x76, 0xda, 0xbc, 0xfe, 0x2a, 0x69, 0x1c, 0xc4, 0x69, 0x2d, 0x0c,
+                0x1b, 0x30, 0x33, 0x01,
+            ],
+            ephemeral_key: [
+                0x27, 0xcb, 0x40, 0x68, 0x0f, 0xb1, 0xd9, 0x19, 0x64, 0x6e, 0x74, 0x20, 0xe6, 0xa8,
+                0xb5, 0x20, 0xe1, 0x9a, 0x17, 0x3f, 0x1e, 0x79, 0x4d, 0x2b, 0x49, 0x2b, 0xfa, 0xbb,
+                0x83, 0xce, 0x6c, 0xa0,
+            ],
+            shared_secret: [
+                0x1c, 0xd0, 0x66, 0x91, 0x6c, 0x19, 0xfa, 0x33, 0x69, 0xaa, 0x3c, 0x6a, 0x53, 0x76,
+                0x97, 0xf4, 0xb4, 0x26, 0x44, 0xda, 0x20, 0xca, 0x46, 0x79, 0x93, 0x2b, 0x7c, 0x90,
+                0x5f, 0x2d, 0x69, 0x00,
+            ],
+            k_enc: [
+                0xce, 0x9d, 0x22, 0x0d, 0x3a, 0xfe, 0xc6, 0x23, 0x21, 0xdd, 0xf1, 0x97, 0xa6, 0x36,
+                0xdc, 0xb3, 0x45, 0x58, 0x83, 0xb7, 0x35, 0x82, 0x8c, 0x65, 0xe7, 0x16, 0x6c, 0x15,
+                0xd8, 0xcc, 0xfc, 0xf9,
+            ],
+            p_enc: [
+                0x03, 0x11, 0x6e, 0x79, 0x94, 0x55, 0xae, 0xa1, 0x91, 0x8f, 0xbf, 0xd4, 0x7f, 0x8e,
+                0x6a, 0x5c, 0x62, 0xa7, 0x77, 0xd1, 0x7e, 0x62, 0x25, 0x8d, 0x65, 0xa1, 0x92, 0x15,
+                0x7c, 0xdf, 0x2e, 0xc3, 0x21, 0x40, 0x7f, 0x68, 0x2f, 0x5e, 0xec, 0x6a, 0x32, 0x97,
+                0xab, 0x20, 0xb7, 0x06, 0x1c, 0x62, 0x24, 0x57, 0x16, 0xa4, 0x96, 0x86, 0xaa, 0x36,
+                0x36, 0xbd, 0x37, 0x5b, 0xd3, 0x13, 0x6b, 0xee, 0x0b, 0xda, 0xab, 0xcf, 0xac, 0x88,
+                0x1b, 0xc7, 0x01, 0x81, 0x27, 0x21, 0xe6, 0xfb, 0x75, 0xaa, 0x07, 0x2d, 0x2d, 0x18,
+                0xff, 0x4f, 0x71, 0xfb, 0xfc, 0x34, 0xc7, 0x9b, 0x44, 0xe0, 0x9e, 0x42, 0x12, 0xac,
+                0x26, 0x53, 0xf6, 0xc4, 0x03, 0x64, 0x3e, 0x1c, 0x5b, 0x9a, 0xd1, 0x34, 0xd8, 0x9c,
+                0x68, 0x0b, 0x70, 0x72, 0x83, 0xaf, 0x54, 0x32, 0x6f, 0xc4, 0xf8, 0x4d, 0x6a, 0x58,
+                0x29, 0xa0, 0xad, 0x48, 0x30, 0x80, 0x6c, 0x05, 0x75, 0x84, 0x92, 0xcd, 0x6a, 0xc4,
+                0x6b, 0xa0, 0x1a, 0x2b, 0x37, 0x22, 0xb5, 0xe4, 0xcd, 0xaf, 0xbb, 0x3f, 0x36, 0x78,
+                0x5f, 0x42, 0x4a, 0xf0, 0x44, 0xda, 0xc5, 0xdb, 0x5f, 0x7d, 0xf8, 0x39, 0xeb, 0x63,
+                0xc0, 0xc1, 0x7d, 0x8b, 0x0c, 0x79, 0xdb, 0x86, 0x30, 0x94, 0x20, 0x15, 0xbe, 0x13,
+                0xf7, 0x9a, 0xf6, 0xf4, 0x3e, 0x5a, 0xb0, 0x77, 0x81, 0x14, 0x79, 0x8f, 0x44, 0x22,
+                0x58, 0xee, 0xdc, 0x43, 0x6f, 0xcc, 0x38, 0x6b, 0x36, 0xb5, 0x7e, 0x19, 0x17, 0xd7,
+                0x20, 0x17, 0x73, 0x66, 0xf4, 0x24, 0xb0, 0xa5, 0x4b, 0x0b, 0x60, 0xf4, 0xfb, 0x13,
+                0x58, 0xc2, 0x0a, 0xa4, 0x1d, 0xc5, 0x02, 0xe1, 0xdd, 0x8a, 0x16, 0x33, 0xf3, 0xd8,
+                0xe3, 0x27, 0x6b, 0x59, 0xe7, 0xd2, 0xc4, 0xe6, 0x24, 0xa6, 0xf5, 0x36, 0x95, 0xbc,
+                0xaf, 0x24, 0x7e, 0x36, 0x48, 0x3f, 0x13, 0xb2, 0x04, 0x42, 0x22, 0x37, 0xfc, 0x6a,
+                0xb3, 0xeb, 0xa0, 0x2f, 0xc4, 0x14, 0x2b, 0x42, 0x97, 0xeb, 0xb5, 0x68, 0x3d, 0xb8,
+                0xd2, 0x43, 0x19, 0x70, 0x6a, 0xd2, 0x6a, 0xaf, 0xd8, 0x1c, 0x53, 0xb7, 0x40, 0xf3,
+                0x45, 0x43, 0xa6, 0xb3, 0xe9, 0xf5, 0xbb, 0x7d, 0x5c, 0x49, 0xe8, 0xc3, 0x7f, 0x61,
+                0x49, 0x21, 0x25, 0x4f, 0x32, 0x12, 0x39, 0x4c, 0x79, 0x7d, 0x1c, 0xee, 0x78, 0x99,
+                0xb7, 0xb4, 0xb6, 0x5b, 0x59, 0xb7, 0x34, 0x2f, 0x92, 0x53, 0x1c, 0x1d, 0x59, 0xe1,
+                0x79, 0x70, 0xb7, 0x31, 0x74, 0x14, 0x43, 0x8c, 0xd8, 0x0b, 0xd0, 0xf9, 0xa6, 0x7c,
+                0x9b, 0x9e, 0x55, 0x2f, 0x01, 0x3c, 0x11, 0x5a, 0x95, 0x4f, 0x35, 0xe0, 0x61, 0x6c,
+                0x68, 0xd4, 0x31, 0x63, 0xd3, 0x34, 0xda, 0xc3, 0x82, 0x70, 0x33, 0xe5, 0xad, 0x84,
+                0x88, 0xbf, 0xd9, 0xc4, 0xbb, 0xbe, 0x8f, 0x59, 0x35, 0xc6, 0xc5, 0xea, 0x04, 0xc3,
+                0xad, 0x49, 0xc7, 0x47, 0xa9, 0xe7, 0x23, 0x1b, 0xcd, 0x7d, 0x16, 0x21, 0x5e, 0x6e,
+                0x80, 0x73, 0x7d, 0x6b, 0x54, 0xfe, 0xc8, 0xb8, 0x84, 0x02, 0xf0, 0x47, 0x52, 0x45,
+                0xe1, 0x74, 0xa7, 0x45, 0xb8, 0x31, 0xf8, 0xfe, 0x03, 0xa7, 0x6f, 0xb9, 0xce, 0xca,
+                0x4d, 0x22, 0xb7, 0x83, 0xc3, 0x28, 0xc6, 0x91, 0x5c, 0x43, 0x40, 0x50, 0x64, 0xae,
+                0x56, 0xbc, 0x89, 0xe6, 0x4d, 0x15, 0x78, 0xe4, 0xd3, 0xa3, 0x4b, 0xb9, 0x55, 0x91,
+                0xea, 0xf1, 0xd3, 0xda, 0x02, 0xa4, 0x54, 0x9f, 0xa8, 0x0d, 0xb0, 0xff, 0x7c, 0xb0,
+                0x39, 0x93, 0xb6, 0x8a, 0xe1, 0x5a, 0x30, 0xe8, 0x79, 0x49, 0xaa, 0x08, 0x0e, 0x94,
+                0xab, 0xde, 0x68, 0x89, 0x8c, 0x33, 0x92, 0xa2, 0x17, 0xd6, 0x49, 0x61, 0x6b, 0xbe,
+                0x73, 0x9b, 0x13, 0xd1, 0x4d, 0xf0, 0x3f, 0xf2, 0x76, 0x71, 0x48, 0x9b, 0xe0, 0xb4,
+                0xbe, 0xba, 0xaf, 0xa7, 0xd1, 0xe6, 0x39, 0xd5, 0xb3, 0xe9, 0x94, 0xff, 0xb6, 0xb7,
+                0xa2, 0x09, 0xf6, 0xad, 0xfe, 0x8d, 0x1e, 0x5c, 0xcf, 0x01, 0x0c, 0x19, 0x16, 0x8a,
+                0xeb, 0x18, 0xaa, 0x9d, 0x68, 0x7e, 0x24, 0xad, 0xc0, 0xb1, 0x13, 0x5c, 0x70, 0xc9,
+                0x70, 0xe0, 0x90, 0x3a,
+            ],
+            c_enc: [
+                0xb1, 0x69, 0x64, 0x77, 0xe6, 0x58, 0xb6, 0xf8, 0xe2, 0x4e, 0x02, 0x55, 0x52, 0xb4,
+                0x8d, 0xd4, 0x84, 0x58, 0xf2, 0xcd, 0x75, 0x70, 0xc0, 0xe8, 0xce, 0xc4, 0xed, 0x4c,
+                0xf7, 0x9b, 0xd5, 0xb6, 0x9e, 0xa8, 0x54, 0x12, 0x3b, 0x4e, 0xaf, 0x97, 0x8b, 0x14,
+                0x2e, 0xb3, 0xef, 0x53, 0xaa, 0xfc, 0x78, 0x90, 0xdd, 0xa2, 0x8a, 0xfa, 0x25, 0xf1,
+                0x45, 0xc8, 0xb9, 0x7f, 0x7b, 0x94, 0x50, 0xc1, 0xd5, 0xe0, 0xc3, 0x7d, 0xaf, 0x5e,
+                0xd4, 0xec, 0xd9, 0xb6, 0x3d, 0xbc, 0xd2, 0x15, 0x11, 0x23, 0x13, 0x9b, 0xbc, 0x2b,
+                0x65, 0x1a, 0x8f, 0x69, 0xcf, 0xbf, 0xb7, 0xcb, 0x60, 0x44, 0x78, 0xf3, 0xf2, 0x64,
+                0xd9, 0xdd, 0x75, 0xcf, 0x31, 0x9e, 0x3e, 0xcd, 0xf5, 0xb3, 0x34, 0x26, 0x54, 0x85,
+                0x7c, 0x52, 0xa1, 0xfc, 0x61, 0x40, 0x55, 0xa2, 0x46, 0xf5, 0x26, 0x3e, 0x85, 0x36,
+                0x83, 0xef, 0x54, 0x41, 0x3b, 0xac, 0x99, 0x1a, 0xe6, 0x35, 0x01, 0x50, 0xe1, 0x34,
+                0x52, 0xa3, 0xa6, 0x20, 0xc5, 0x3f, 0x80, 0xda, 0xcc, 0x7a, 0xf0, 0x59, 0x26, 0xd9,
+                0xc5, 0x9a, 0x94, 0xe4, 0x78, 0x9a, 0xcc, 0x68, 0xd8, 0x51, 0x05, 0x6b, 0x75, 0xa7,
+                0x4e, 0x2e, 0x1b, 0x38, 0xbf, 0xcb, 0x6d, 0xba, 0xab, 0x37, 0xa3, 0x8a, 0xe0, 0x2c,
+                0x9c, 0x35, 0x25, 0x9e, 0x52, 0x84, 0xe4, 0xfe, 0x83, 0xdd, 0xb2, 0x29, 0x24, 0xa1,
+                0xc4, 0x0a, 0xa2, 0x5e, 0xd1, 0xf5, 0xc0, 0x6d, 0xa1, 0x58, 0x31, 0xf0, 0x41, 0x50,
+                0xa3, 0x7c, 0x1b, 0xa3, 0xd1, 0x17, 0x04, 0x93, 0xca, 0x29, 0xf3, 0x43, 0x4a, 0xfa,
+                0x06, 0x9b, 0x46, 0xaf, 0xdc, 0x87, 0x0a, 0x29, 0x6f, 0xdc, 0x0e, 0xb6, 0x1b, 0x55,
+                0x70, 0x77, 0xa1, 0xda, 0x1f, 0xe8, 0x22, 0xb6, 0xce, 0x24, 0x7c, 0x8e, 0x19, 0x9f,
+                0xc4, 0x85, 0x14, 0x6f, 0x38, 0x4a, 0xcf, 0x5c, 0x52, 0x69, 0x7e, 0xfa, 0xcc, 0x5b,
+                0xfe, 0x42, 0x02, 0xe8, 0x5f, 0x06, 0x4b, 0xc8, 0xe1, 0x2e, 0xee, 0x39, 0x79, 0x6d,
+                0xfd, 0x13, 0x99, 0xb1, 0xc1, 0xe8, 0xc7, 0x4b, 0x5e, 0xc3, 0xc3, 0x1d, 0x2c, 0xfa,
+                0x44, 0x87, 0x02, 0x5c, 0xeb, 0x5d, 0xb3, 0x55, 0x9d, 0x4b, 0x7b, 0xac, 0x02, 0x73,
+                0xf1, 0x33, 0x51, 0xd2, 0xd1, 0x3c, 0xec, 0x0a, 0x44, 0x8c, 0x00, 0x11, 0x09, 0x45,
+                0x2c, 0x40, 0x92, 0xc8, 0x11, 0x91, 0xa0, 0xda, 0xa9, 0x79, 0xe2, 0x6a, 0x96, 0x24,
+                0xe4, 0x0c, 0xa4, 0xac, 0xcb, 0x63, 0x46, 0xaa, 0xe1, 0x88, 0xca, 0x09, 0x39, 0xdd,
+                0x9f, 0x6b, 0x6e, 0x45, 0xe4, 0x1b, 0xca, 0xeb, 0xdc, 0x1d, 0xa8, 0x01, 0xcc, 0xd4,
+                0xdc, 0x93, 0x32, 0x26, 0x6f, 0xb3, 0xeb, 0x23, 0x7b, 0x07, 0x72, 0x45, 0xa7, 0x91,
+                0xec, 0xb4, 0x0e, 0x5c, 0x40, 0x56, 0xad, 0xd6, 0xb1, 0xb5, 0xf7, 0xf8, 0xfa, 0x10,
+                0x4f, 0xba, 0x61, 0x3e, 0xd9, 0x29, 0xe1, 0xfa, 0xd2, 0x26, 0x47, 0x50, 0x35, 0xb6,
+                0x1a, 0x9f, 0x85, 0xaf, 0xba, 0xfb, 0x16, 0x6b, 0x24, 0xc2, 0x4d, 0x2c, 0x28, 0x93,
+                0x7b, 0x17, 0x70, 0xba, 0x26, 0x9c, 0x15, 0xeb, 0x2d, 0x9b, 0xdc, 0x2b, 0x83, 0xea,
+                0xd8, 0xa0, 0x1d, 0xdb, 0x11, 0x08, 0x3b, 0x13, 0xd6, 0x2d, 0x57, 0x2c, 0xf7, 0x8d,
+                0x5c, 0xba, 0x6f, 0x36, 0x52, 0xca, 0xc4, 0xd2, 0x4c, 0x71, 0xc5, 0x47, 0x27, 0x26,
+                0x24, 0xc0, 0x78, 0xe0, 0xb9, 0x69, 0x68, 0xfe, 0x09, 0xd8, 0x3e, 0xf7, 0x30, 0x20,
+                0x62, 0xbb, 0x5d, 0x3a, 0x2c, 0xcf, 0x73, 0x4e, 0x0f, 0xd3, 0x51, 0x01, 0xfd, 0x58,
+                0x64, 0x73, 0x3f, 0x44, 0xd0, 0x75, 0xc3, 0x8b, 0x73, 0xf6, 0xbf, 0xb8, 0xc3, 0x9c,
+                0x7b, 0x6b, 0x3d, 0xbc, 0xd1, 0x9a, 0x05, 0x89, 0x91, 0x86, 0x37, 0xf7, 0x5b, 0xbe,
+                0x40, 0x15, 0x7b, 0x80, 0xe5, 0x9e, 0x55, 0x58, 0x50, 0x28, 0xa5, 0xec, 0x20, 0x1e,
+                0x00, 0x8f, 0xf6, 0xf5, 0x12, 0xe2, 0x53, 0xcc, 0x9a, 0xcf, 0x62, 0x7d, 0x94, 0x35,
+                0xdb, 0x6b, 0x14, 0xb9, 0x82, 0x48, 0x79, 0xf4, 0xe4, 0x0a, 0x36, 0xd5, 0xec, 0x94,
+                0x2b, 0xff, 0x04, 0xfd, 0x90, 0xa6, 0xaf, 0x8c, 0x58, 0x1d, 0xf6, 0x09, 0xc4, 0x11,
+                0xf4, 0x76, 0x11, 0x41, 0xd4, 0xa6,
+            ],
+            ock: [
+                0xdc, 0xf9, 0x34, 0xcf, 0x6a, 0x64, 0x90, 0x3f, 0x2d, 0x99, 0xa3, 0x07, 0xe1, 0x55,
+                0xfb, 0x90, 0xe9, 0x7a, 0xc9, 0x0c, 0x38, 0x7f, 0x1b, 0xa5, 0xa6, 0xea, 0x43, 0xb5,
+                0x91, 0xb0, 0x5d, 0x69,
+            ],
+            op: [
+                0x3e, 0x5e, 0x46, 0xeb, 0x0f, 0xe8, 0xe6, 0xf0, 0xcf, 0x6a, 0xab, 0x2b, 0x41, 0xfb,
+                0xcf, 0xfb, 0xb2, 0x98, 0xf8, 0xd5, 0x34, 0xc8, 0xd9, 0xd3, 0x11, 0xe4, 0xc6, 0x10,
+                0x3a, 0x56, 0x6a, 0xaa, 0xe4, 0x00, 0x13, 0x04, 0x47, 0xc1, 0xbd, 0x1a, 0x0c, 0x13,
+                0x02, 0xf5, 0x10, 0xe9, 0xeb, 0x09, 0xed, 0x76, 0xda, 0xbc, 0xfe, 0x2a, 0x69, 0x1c,
+                0xc4, 0x69, 0x2d, 0x0c, 0x1b, 0x30, 0x33, 0x01,
+            ],
+            c_out: [
+                0x25, 0xf4, 0xbb, 0x9f, 0xb4, 0x45, 0x06, 0x78, 0x9c, 0xf5, 0x1d, 0xc3, 0xf6, 0x5f,
+                0x17, 0xaf, 0xee, 0xe0, 0x34, 0x92, 0x79, 0xc7, 0x89, 0x28, 0x9b, 0x03, 0xd3, 0x8c,
+                0x2e, 0x20, 0xd3, 0x12, 0x5d, 0xe7, 0xc5, 0x6e, 0x18, 0x29, 0x2d, 0xec, 0xc6, 0x41,
+                0x81, 0xa7, 0xe9, 0xa7, 0xbc, 0x12, 0xeb, 0x97, 0x85, 0xf0, 0xdd, 0x51, 0xd5, 0x88,
+                0x62, 0x00, 0xfb, 0x18, 0x7d, 0x2c, 0x16, 0x90, 0x65, 0xaf, 0x84, 0xcc, 0x02, 0x3d,
+                0x6d, 0x63, 0xce, 0x05, 0x83, 0x28, 0xe2, 0x47, 0xb5, 0x98,
+            ],
+            note_type: Some([
+                0x96, 0x86, 0xaa, 0x36, 0x36, 0xbd, 0x37, 0x5b, 0xd3, 0x13, 0x6b, 0xee, 0x0b, 0xda,
+                0xab, 0xcf, 0xac, 0x88, 0x1b, 0xc7, 0x01, 0x81, 0x27, 0x21, 0xe6, 0xfb, 0x75, 0xaa,
+                0x07, 0x2d, 0x2d, 0x18,
+            ]),
         },
     ]
 }
diff --git a/src/value.rs b/src/value.rs
index 5ece74af2..8525ab8fe 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -318,7 +318,7 @@ impl ValueCommitment {
             pallas::Scalar::from(abs_value)
         };
 
-        let V_zsa = note_type.0;
+        let V_zsa = note_type.cv_base();
 
         ValueCommitment(V_zsa * value + R * rcv.0)
     }

From 1420f84932e23fda0655570e3bde9e578a8f41ae Mon Sep 17 00:00:00 2001
From: Paul <3682187+PaulLaux@users.noreply.github.com>
Date: Mon, 19 Sep 2022 13:26:08 +0300
Subject: [PATCH 05/17] Zsa builder (#4)

+ Updated test bsk_consistent_with_bvk to verify mixed note types.
+ Added NoteType support to the builder and the bundle.
+ added split_flag to SpentInfo and as input to the Circuit (currently commented out)
+ added conditional cv_sum calculation (currently commented out)
+ added padding to actions
---
 .gitignore                 |   2 +
 benches/circuit.rs         |   9 ++-
 benches/note_decryption.rs |  17 ++++-
 src/action.rs              |   8 ++-
 src/builder.rs             | 133 +++++++++++++++++++++++++++++--------
 src/circuit.rs             |   4 +-
 src/note.rs                |   7 +-
 src/note/note_type.rs      |  33 +++++++--
 src/note_encryption.rs     |   9 +--
 src/tree.rs                |   2 +-
 src/value.rs               |  74 +++++++++++++++++----
 tests/builder.rs           |  17 ++++-
 12 files changed, 250 insertions(+), 65 deletions(-)

diff --git a/.gitignore b/.gitignore
index 57ee1a9ad..d7f36bd31 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,5 @@
 Cargo.lock
 .vscode
 .idea
+action-circuit-layout.png
+proptest-regressions/*.txt
diff --git a/benches/circuit.rs b/benches/circuit.rs
index 3140a90a4..6400513e2 100644
--- a/benches/circuit.rs
+++ b/benches/circuit.rs
@@ -6,6 +6,7 @@ use criterion::{BenchmarkId, Criterion};
 #[cfg(unix)]
 use pprof::criterion::{Output, PProfProfiler};
 
+use orchard::note::NoteType;
 use orchard::{
     builder::Builder,
     bundle::Flags,
@@ -32,7 +33,13 @@ fn criterion_benchmark(c: &mut Criterion) {
         );
         for _ in 0..num_recipients {
             builder
-                .add_recipient(None, recipient, NoteValue::from_raw(10), None)
+                .add_recipient(
+                    None,
+                    recipient,
+                    NoteValue::from_raw(10),
+                    NoteType::native(),
+                    None,
+                )
                 .unwrap();
         }
         let bundle: Bundle<_, i64> = builder.build(rng).unwrap();
diff --git a/benches/note_decryption.rs b/benches/note_decryption.rs
index 3ebbc6ed5..28e02de61 100644
--- a/benches/note_decryption.rs
+++ b/benches/note_decryption.rs
@@ -4,6 +4,7 @@ use orchard::{
     bundle::Flags,
     circuit::ProvingKey,
     keys::{FullViewingKey, PreparedIncomingViewingKey, Scope, SpendingKey},
+    note::NoteType,
     note_encryption::{CompactAction, OrchardDomain},
     value::NoteValue,
     Anchor, Bundle,
@@ -52,10 +53,22 @@ fn bench_note_decryption(c: &mut Criterion) {
         // The builder pads to two actions, and shuffles their order. Add two recipients
         // so the first action is always decryptable.
         builder
-            .add_recipient(None, recipient, NoteValue::from_raw(10), None)
+            .add_recipient(
+                None,
+                recipient,
+                NoteValue::from_raw(10),
+                NoteType::native(),
+                None,
+            )
             .unwrap();
         builder
-            .add_recipient(None, recipient, NoteValue::from_raw(10), None)
+            .add_recipient(
+                None,
+                recipient,
+                NoteValue::from_raw(10),
+                NoteType::native(),
+                None,
+            )
             .unwrap();
         let bundle: Bundle<_, i64> = builder.build(rng).unwrap();
         bundle
diff --git a/src/action.rs b/src/action.rs
index b6396ed91..b1eda4819 100644
--- a/src/action.rs
+++ b/src/action.rs
@@ -126,7 +126,7 @@ pub(crate) mod testing {
 
     use proptest::prelude::*;
 
-    use crate::note::NoteType;
+    use crate::note::note_type::testing::arb_note_type;
     use crate::{
         note::{
             commitment::ExtractedNoteCommitment, nullifier::testing::arb_nullifier,
@@ -147,12 +147,13 @@ pub(crate) mod testing {
             nf in arb_nullifier(),
             rk in arb_spendauth_verification_key(),
             note in arb_note(output_value),
+            note_type in arb_note_type()
         ) -> Action<()> {
             let cmx = ExtractedNoteCommitment::from(note.commitment());
             let cv_net = ValueCommitment::derive(
                 spend_value - output_value,
                 ValueCommitTrapdoor::zero(),
-                NoteType::native()
+                note_type
             );
             // FIXME: make a real one from the note.
             let encrypted_note = TransmittedNoteCiphertext {
@@ -179,12 +180,13 @@ pub(crate) mod testing {
             note in arb_note(output_value),
             rng_seed in prop::array::uniform32(prop::num::u8::ANY),
             fake_sighash in prop::array::uniform32(prop::num::u8::ANY),
+            note_type in arb_note_type()
         ) -> Action<redpallas::Signature<SpendAuth>> {
             let cmx = ExtractedNoteCommitment::from(note.commitment());
             let cv_net = ValueCommitment::derive(
                 spend_value - output_value,
                 ValueCommitTrapdoor::zero(),
-                NoteType::native()
+                note_type
             );
 
             // FIXME: make a real one from the note.
diff --git a/src/builder.rs b/src/builder.rs
index 1a7ccbec1..a3ba5ff84 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -2,6 +2,7 @@
 
 use core::fmt;
 use core::iter;
+use std::collections::HashMap;
 
 use ff::Field;
 use nonempty::NonEmpty;
@@ -57,13 +58,15 @@ impl From<value::OverflowError> for Error {
 }
 
 /// Information about a specific note to be spent in an [`Action`].
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct SpendInfo {
     pub(crate) dummy_sk: Option<SpendingKey>,
     pub(crate) fvk: FullViewingKey,
     pub(crate) scope: Scope,
     pub(crate) note: Note,
     pub(crate) merkle_path: MerklePath,
+    // a flag to indicate whether the value of the note will be counted in the `ValueSum` of the action.
+    pub(crate) split_flag: bool,
 }
 
 impl SpendInfo {
@@ -84,14 +87,15 @@ impl SpendInfo {
             scope,
             note,
             merkle_path,
+            split_flag: false,
         })
     }
 
     /// Defined in [Zcash Protocol Spec § 4.8.3: Dummy Notes (Orchard)][orcharddummynotes].
     ///
     /// [orcharddummynotes]: https://zips.z.cash/protocol/nu5.pdf#orcharddummynotes
-    fn dummy(rng: &mut impl RngCore) -> Self {
-        let (sk, fvk, note) = Note::dummy(rng, None);
+    fn dummy(note_type: NoteType, rng: &mut impl RngCore) -> Self {
+        let (sk, fvk, note) = Note::dummy(rng, None, note_type);
         let merkle_path = MerklePath::dummy(rng);
 
         SpendInfo {
@@ -102,16 +106,26 @@ impl SpendInfo {
             scope: Scope::External,
             note,
             merkle_path,
+            split_flag: false,
         }
     }
+
+    /// Duplicates the spend info and set the split flag to `true`.
+    fn create_split_spend(&self) -> Self {
+        let mut split_spend = SpendInfo::new(self.fvk.clone(), self.note, self.merkle_path.clone())
+            .expect("The spend info is valid");
+        split_spend.split_flag = true;
+        split_spend
+    }
 }
 
 /// Information about a specific recipient to receive funds in an [`Action`].
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct RecipientInfo {
     ovk: Option<OutgoingViewingKey>,
     recipient: Address,
     value: NoteValue,
+    note_type: NoteType,
     memo: Option<[u8; 512]>,
 }
 
@@ -127,6 +141,7 @@ impl RecipientInfo {
             ovk: None,
             recipient,
             value: NoteValue::zero(),
+            note_type: NoteType::native(),
             memo: None,
         }
     }
@@ -150,7 +165,17 @@ impl ActionInfo {
     }
 
     /// Returns the value sum for this action.
+    /// Split notes does not contribute to the value sum.
     fn value_sum(&self) -> ValueSum {
+        // TODO: Aurel, uncomment when circuit for split flag is implemented.
+        // let spent_value = self
+        //     .spend
+        //     .split_flag
+        //     .then(|| self.spend.note.value())
+        //     .unwrap_or_else(NoteValue::zero);
+        //
+        // spent_value - self.output.value
+
         self.spend.note.value() - self.output.value
     }
 
@@ -160,8 +185,15 @@ impl ActionInfo {
     ///
     /// [orchardsend]: https://zips.z.cash/protocol/nu5.pdf#orchardsend
     fn build(self, mut rng: impl RngCore) -> (Action<SigningMetadata>, Circuit) {
+        assert_eq!(
+            self.output.note_type,
+            self.spend.note.note_type(),
+            "spend and recipient note types must be equal"
+        );
+
         let v_net = self.value_sum();
-        let cv_net = ValueCommitment::derive(v_net, self.rcv, NoteType::native());
+        let note_type = self.output.note_type;
+        let cv_net = ValueCommitment::derive(v_net, self.rcv, note_type);
 
         let nf_old = self.spend.note.nullifier(&self.spend.fvk);
         let ak: SpendValidatingKey = self.spend.fvk.clone().into();
@@ -275,6 +307,7 @@ impl Builder {
             scope,
             note,
             merkle_path,
+            split_flag: false,
         });
 
         Ok(())
@@ -286,6 +319,7 @@ impl Builder {
         ovk: Option<OutgoingViewingKey>,
         recipient: Address,
         value: NoteValue,
+        note_type: NoteType,
         memo: Option<[u8; 512]>,
     ) -> Result<(), &'static str> {
         if !self.flags.outputs_enabled() {
@@ -296,6 +330,7 @@ impl Builder {
             ovk,
             recipient,
             value,
+            note_type,
             memo,
         });
 
@@ -332,23 +367,31 @@ impl Builder {
     /// The returned bundle will have no proof or signatures; these can be applied with
     /// [`Bundle::create_proof`] and [`Bundle::apply_signatures`] respectively.
     pub fn build<V: TryFrom<i64>>(
-        mut self,
+        self,
         mut rng: impl RngCore,
     ) -> Result<Bundle<InProgress<Unproven, Unauthorized>, V>, Error> {
+        let mut pre_actions: Vec<_> = Vec::new();
+
         // Pair up the spends and recipients, extending with dummy values as necessary.
-        let pre_actions: Vec<_> = {
-            let num_spends = self.spends.len();
-            let num_recipients = self.recipients.len();
+        for (note_type, (mut spends, mut recipients)) in partition(&self.spends, &self.recipients) {
+            let num_spends = spends.len();
+            let num_recipients = recipients.len();
             let num_actions = [num_spends, num_recipients, MIN_ACTIONS]
                 .iter()
                 .max()
                 .cloned()
                 .unwrap();
 
-            self.spends.extend(
-                iter::repeat_with(|| SpendInfo::dummy(&mut rng)).take(num_actions - num_spends),
+            // use the first spend to create split spend(s) or create a dummy if empty.
+            let dummy_spend = spends.first().map_or_else(
+                || SpendInfo::dummy(note_type, &mut rng),
+                |s| s.create_split_spend(),
             );
-            self.recipients.extend(
+
+            // Extend the spends and recipients with dummy values.
+            spends.extend(iter::repeat_with(|| dummy_spend.clone()).take(num_actions - num_spends));
+
+            recipients.extend(
                 iter::repeat_with(|| RecipientInfo::dummy(&mut rng))
                     .take(num_actions - num_recipients),
             );
@@ -356,15 +399,16 @@ impl Builder {
             // Shuffle the spends and recipients, so that learning the position of a
             // specific spent note or output note doesn't reveal anything on its own about
             // the meaning of that note in the transaction context.
-            self.spends.shuffle(&mut rng);
-            self.recipients.shuffle(&mut rng);
-
-            self.spends
-                .into_iter()
-                .zip(self.recipients.into_iter())
-                .map(|(spend, recipient)| ActionInfo::new(spend, recipient, &mut rng))
-                .collect()
-        };
+            spends.shuffle(&mut rng);
+            recipients.shuffle(&mut rng);
+
+            pre_actions.extend(
+                spends
+                    .into_iter()
+                    .zip(recipients.into_iter())
+                    .map(|(spend, recipient)| ActionInfo::new(spend, recipient, &mut rng)),
+            );
+        }
 
         // Move some things out of self that we will need.
         let flags = self.flags;
@@ -416,6 +460,30 @@ impl Builder {
     }
 }
 
+/// partition a list of spends and recipients by note types.
+fn partition(
+    spends: &[SpendInfo],
+    recipients: &[RecipientInfo],
+) -> HashMap<NoteType, (Vec<SpendInfo>, Vec<RecipientInfo>)> {
+    let mut hm = HashMap::new();
+
+    for s in spends.iter() {
+        hm.entry(s.note.note_type())
+            .or_insert((vec![], vec![]))
+            .0
+            .push(s.clone());
+    }
+
+    for r in recipients.iter() {
+        hm.entry(r.note_type)
+            .or_insert((vec![], vec![]))
+            .1
+            .push(r.clone())
+    }
+
+    hm
+}
+
 /// Marker trait representing bundle signatures in the process of being created.
 pub trait InProgressSignatures: fmt::Debug {
     /// The authorization type of an Orchard action in the process of being authorized.
@@ -680,6 +748,7 @@ pub mod testing {
     use proptest::collection::vec;
     use proptest::prelude::*;
 
+    use crate::note::NoteType;
     use crate::{
         address::testing::arb_address,
         bundle::{Authorized, Bundle, Flags},
@@ -707,7 +776,7 @@ pub mod testing {
         sk: SpendingKey,
         anchor: Anchor,
         notes: Vec<(Note, MerklePath)>,
-        recipient_amounts: Vec<(Address, NoteValue)>,
+        recipient_amounts: Vec<(Address, NoteValue, NoteType)>,
     }
 
     impl<R: RngCore + CryptoRng> ArbitraryBundleInputs<R> {
@@ -721,12 +790,12 @@ pub mod testing {
                 builder.add_spend(fvk.clone(), note, path).unwrap();
             }
 
-            for (addr, value) in self.recipient_amounts.into_iter() {
+            for (addr, value, note_type) in self.recipient_amounts.into_iter() {
                 let scope = fvk.scope_for_address(&addr).unwrap();
                 let ovk = fvk.to_ovk(scope);
 
                 builder
-                    .add_recipient(Some(ovk.clone()), addr, value, None)
+                    .add_recipient(Some(ovk.clone()), addr, value, note_type, None)
                     .unwrap();
             }
 
@@ -760,9 +829,11 @@ pub mod testing {
             recipient_amounts in vec(
                 arb_address().prop_flat_map(move |a| {
                     arb_positive_note_value(MAX_NOTE_VALUE / n_recipients as u64)
-                        .prop_map(move |v| (a, v))
+                        .prop_map(move |v| {
+                            (a,v, NoteType::native())
+                        })
                 }),
-                n_recipients as usize
+                n_recipients as usize,
             ),
             rng_seed in prop::array::uniform32(prop::num::u8::ANY)
         ) -> ArbitraryBundleInputs<StdRng> {
@@ -810,6 +881,8 @@ mod tests {
     use rand::rngs::OsRng;
 
     use super::Builder;
+    // use crate::keys::{IssuerAuthorizingKey, IssuerValidatingKey};
+    use crate::note::NoteType;
     use crate::{
         bundle::{Authorized, Bundle, Flags},
         circuit::ProvingKey,
@@ -834,7 +907,13 @@ mod tests {
         );
 
         builder
-            .add_recipient(None, recipient, NoteValue::from_raw(5000), None)
+            .add_recipient(
+                None,
+                recipient,
+                NoteValue::from_raw(5000),
+                NoteType::native(),
+                None,
+            )
             .unwrap();
         let balance: i64 = builder.value_balance().unwrap();
         assert_eq!(balance, -5000);
diff --git a/src/circuit.rs b/src/circuit.rs
index 0b271d750..97d5efda2 100644
--- a/src/circuit.rs
+++ b/src/circuit.rs
@@ -977,7 +977,7 @@ mod tests {
     };
 
     fn generate_circuit_instance<R: RngCore>(mut rng: R) -> (Circuit, Instance) {
-        let (_, fvk, spent_note) = Note::dummy(&mut rng, None);
+        let (_, fvk, spent_note) = Note::dummy(&mut rng, None, NoteType::native());
 
         let sender_address = spent_note.recipient();
         let nk = *fvk.nk();
@@ -987,7 +987,7 @@ mod tests {
         let alpha = pallas::Scalar::random(&mut rng);
         let rk = ak.randomize(&alpha);
 
-        let (_, _, output_note) = Note::dummy(&mut rng, Some(nf_old));
+        let (_, _, output_note) = Note::dummy(&mut rng, Some(nf_old), NoteType::native());
         let cmx = output_note.commitment().into();
 
         let value = spent_note.value() - output_note.value();
diff --git a/src/note.rs b/src/note.rs
index c2edf4988..04938cbe0 100644
--- a/src/note.rs
+++ b/src/note.rs
@@ -176,6 +176,7 @@ impl Note {
     pub(crate) fn dummy(
         rng: &mut impl RngCore,
         rho: Option<Nullifier>,
+        note_type: NoteType,
     ) -> (SpendingKey, FullViewingKey, Self) {
         let sk = SpendingKey::random(rng);
         let fvk: FullViewingKey = (&sk).into();
@@ -184,7 +185,7 @@ impl Note {
         let note = Note::new(
             recipient,
             NoteValue::zero(),
-            NoteType::native(),
+            note_type,
             rho.unwrap_or_else(|| Nullifier::dummy(rng)),
             rng,
         );
@@ -202,7 +203,7 @@ impl Note {
         self.value
     }
 
-    /// Returns the note type
+    /// Returns the note type of this note.
     pub fn note_type(&self) -> NoteType {
         self.note_type
     }
@@ -309,7 +310,7 @@ pub mod testing {
     }
 
     prop_compose! {
-        /// Generate an action without authorization data.
+        /// Generate an arbitrary note
         pub fn arb_note(value: NoteValue)(
             recipient in arb_address(),
             rho in arb_nullifier(),
diff --git a/src/note/note_type.rs b/src/note/note_type.rs
index 6075259e3..8ac04b00b 100644
--- a/src/note/note_type.rs
+++ b/src/note/note_type.rs
@@ -1,16 +1,18 @@
 use group::GroupEncoding;
 use halo2_proofs::arithmetic::CurveExt;
 use pasta_curves::pallas;
+use std::hash::{Hash, Hasher};
+
 use subtle::{Choice, ConstantTimeEq, CtOption};
 
 use crate::constants::fixed_bases::{VALUE_COMMITMENT_PERSONALIZATION, VALUE_COMMITMENT_V_BYTES};
 use crate::keys::IssuerValidatingKey;
 
 /// Note type identifier.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct NoteType(pub(crate) pallas::Point);
+#[derive(Clone, Copy, Debug, Eq)]
+pub struct NoteType(pallas::Point);
 
-const MAX_ASSET_DESCRIPTION_SIZE: usize = 512;
+pub const MAX_ASSET_DESCRIPTION_SIZE: usize = 512;
 
 // the hasher used to derive the assetID
 #[allow(non_snake_case)]
@@ -62,16 +64,29 @@ impl NoteType {
     }
 }
 
+impl Hash for NoteType {
+    fn hash<H: Hasher>(&self, h: &mut H) {
+        h.write(&self.to_bytes());
+        h.finish();
+    }
+}
+
+impl PartialEq for NoteType {
+    fn eq(&self, other: &Self) -> bool {
+        bool::from(self.0.ct_eq(&other.0))
+    }
+}
+
 /// Generators for property testing.
 #[cfg(any(test, feature = "test-dependencies"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "test-dependencies")))]
 pub mod testing {
+    use super::NoteType;
+
     use proptest::prelude::*;
 
     use crate::keys::{testing::arb_spending_key, IssuerAuthorizingKey, IssuerValidatingKey};
 
-    use super::NoteType;
-
     prop_compose! {
         /// Generate a uniformly distributed note type
         pub fn arb_note_type()(
@@ -89,4 +104,12 @@ pub mod testing {
             }
         }
     }
+
+    prop_compose! {
+        /// Generate the native note type
+        pub fn native_note_type()(_i in 0..10) -> NoteType {
+            // TODO: remove _i
+            NoteType::native()
+        }
+    }
 }
diff --git a/src/note_encryption.rs b/src/note_encryption.rs
index 5d955e2cb..57dd76589 100644
--- a/src/note_encryption.rs
+++ b/src/note_encryption.rs
@@ -409,6 +409,7 @@ mod tests {
         EphemeralKeyBytes,
     };
 
+    use super::{prf_ock_orchard, CompactAction, OrchardDomain, OrchardNoteEncryption};
     use crate::note::NoteType;
     use crate::{
         action::Action,
@@ -426,7 +427,6 @@ mod tests {
     };
 
     use super::{get_note_version, orchard_parse_note_plaintext_without_memo};
-    use super::{prf_ock_orchard, CompactAction, OrchardDomain, OrchardNoteEncryption};
 
     proptest! {
     #[test]
@@ -453,6 +453,7 @@ mod tests {
         // Check.
         assert_eq!(parsed_note, note);
         assert_eq!(parsed_recipient, note.recipient());
+
         if parsed_note.note_type().is_native().into() {
             assert_eq!(parsed_version, 0x02);
             assert_eq!(&parsed_memo, memo);
@@ -508,17 +509,13 @@ mod tests {
             assert_eq!(ock.as_ref(), tv.ock);
 
             let recipient = Address::from_parts(d, pk_d);
-<<<<<<< HEAD
-            let note = Note::from_parts(recipient, value, NoteType::native(), rho, rseed).unwrap();
-=======
 
             let note_type = match tv.note_type {
                 None => NoteType::native(),
                 Some(type_bytes) => NoteType::from_bytes(&type_bytes).unwrap(),
             };
 
-            let note = Note::from_parts(recipient, value, note_type, rho, rseed);
->>>>>>> ZSA note encryption in Orchard crate (#3)
+            let note = Note::from_parts(recipient, value, note_type, rho, rseed).unwrap();
             assert_eq!(ExtractedNoteCommitment::from(note.commitment()), cmx);
 
             let action = Action::from_parts(
diff --git a/src/tree.rs b/src/tree.rs
index c2854200b..7e9601312 100644
--- a/src/tree.rs
+++ b/src/tree.rs
@@ -77,7 +77,7 @@ impl Anchor {
 
 /// The Merkle path from a leaf of the note commitment tree
 /// to its anchor.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct MerklePath {
     position: u32,
     auth_path: [MerkleHashOrchard; MERKLE_DEPTH_ORCHARD],
diff --git a/src/value.rs b/src/value.rs
index 8525ab8fe..ce5d6c94f 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -40,6 +40,7 @@
 use core::fmt::{self, Debug};
 use core::iter::Sum;
 use core::ops::{Add, RangeInclusive, Sub};
+use std::ops::Neg;
 
 use bitvec::{array::BitArray, order::Lsb0};
 use ff::{Field, PrimeField};
@@ -189,6 +190,18 @@ impl Add for ValueSum {
     }
 }
 
+impl Neg for ValueSum {
+    type Output = Option<ValueSum>;
+
+    #[allow(clippy::suspicious_arithmetic_impl)]
+    fn neg(self) -> Self::Output {
+        self.0
+            .checked_neg()
+            .filter(|v| VALUE_SUM_RANGE.contains(v))
+            .map(ValueSum)
+    }
+}
+
 impl<'a> Sum<&'a ValueSum> for Result<ValueSum, OverflowError> {
     fn sum<I: Iterator<Item = &'a ValueSum>>(iter: I) -> Self {
         iter.fold(Ok(ValueSum(0)), |acc, v| (acc? + *v).ok_or(OverflowError))
@@ -423,7 +436,8 @@ pub mod testing {
 
 #[cfg(test)]
 mod tests {
-    use crate::note::note_type::testing::arb_note_type;
+    use crate::note::note_type::testing::{arb_note_type, native_note_type};
+
     use crate::note::NoteType;
     use proptest::prelude::*;
 
@@ -433,43 +447,77 @@ mod tests {
     };
     use crate::primitives::redpallas;
 
-    fn _bsk_consistent_with_bvk(values: &[(ValueSum, ValueCommitTrapdoor)], note_type: NoteType) {
-        let value_balance = values
+    fn _bsk_consistent_with_bvk(
+        native_values: &[(ValueSum, ValueCommitTrapdoor, NoteType)],
+        arb_values: &[(ValueSum, ValueCommitTrapdoor, NoteType)],
+        neg_trapdoors: &[ValueCommitTrapdoor],
+    ) {
+        // for each arb value, create a negative value with a different trapdoor
+        let neg_arb_values: Vec<_> = arb_values
+            .iter()
+            .cloned()
+            .zip(neg_trapdoors.iter().cloned())
+            .map(|((value, _, note_type), rcv)| ((-value).unwrap(), rcv, note_type))
+            .collect();
+
+        let native_value_balance = native_values
             .iter()
-            .map(|(value, _)| value)
+            .map(|(value, _, _)| value)
             .sum::<Result<ValueSum, OverflowError>>()
             .expect("we generate values that won't overflow");
 
+        let values = [native_values, arb_values, &neg_arb_values].concat();
+
         let bsk = values
             .iter()
-            .map(|(_, rcv)| rcv)
+            .map(|(_, rcv, _)| rcv)
             .sum::<ValueCommitTrapdoor>()
             .into_bsk();
 
         let bvk = (values
             .iter()
-            .map(|(value, rcv)| ValueCommitment::derive(*value, *rcv, note_type))
+            .map(|(value, rcv, note_type)| ValueCommitment::derive(*value, *rcv, *note_type))
             .sum::<ValueCommitment>()
-            - ValueCommitment::derive(value_balance, ValueCommitTrapdoor::zero(), note_type))
+            - ValueCommitment::derive(
+                native_value_balance,
+                ValueCommitTrapdoor::zero(),
+                NoteType::native(),
+            ))
         .into_bvk();
 
         assert_eq!(redpallas::VerificationKey::from(&bsk), bvk);
     }
 
+    proptest! {
+        #[test]
+        fn bsk_consistent_with_bvk_native_only(
+            native_values in (1usize..10).prop_flat_map(|n_values|
+                arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
+                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), native_note_type()), n_values)
+                )
+            ),
+        ) {
+            // Test with native note type (zec) only
+            _bsk_consistent_with_bvk(&native_values, &[], &[]);
+        }
+    }
+
     proptest! {
         #[test]
         fn bsk_consistent_with_bvk(
-            values in (1usize..10).prop_flat_map(|n_values|
+            native_values in (1usize..10).prop_flat_map(|n_values|
                 arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
-                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor()), n_values)
+                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), native_note_type()), n_values)
                 )
             ),
-            arb_note_type in arb_note_type(),
+            (arb_values,neg_trapdoors) in (1usize..10).prop_flat_map(|n_values|
+                (arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
+                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), arb_note_type()), n_values)
+                ), prop::collection::vec(arb_trapdoor(), n_values))
+            ),
         ) {
             // Test with native note type (zec)
-            _bsk_consistent_with_bvk(&values, NoteType::native());
-            // Test with arbitrary note type
-            _bsk_consistent_with_bvk(&values, arb_note_type);
+             _bsk_consistent_with_bvk(&native_values, &arb_values, &neg_trapdoors);
         }
     }
 }
diff --git a/tests/builder.rs b/tests/builder.rs
index f9b0f2717..428ebf81c 100644
--- a/tests/builder.rs
+++ b/tests/builder.rs
@@ -1,4 +1,5 @@
 use incrementalmerkletree::{bridgetree::BridgeTree, Hashable, Tree};
+use orchard::note::NoteType;
 use orchard::{
     builder::Builder,
     bundle::{Authorized, Flags},
@@ -43,7 +44,13 @@ fn bundle_chain() {
 
         let mut builder = Builder::new(Flags::from_parts(false, true), anchor);
         assert_eq!(
-            builder.add_recipient(None, recipient, NoteValue::from_raw(5000), None),
+            builder.add_recipient(
+                None,
+                recipient,
+                NoteValue::from_raw(5000),
+                NoteType::native(),
+                None
+            ),
             Ok(())
         );
         let unauthorized = builder.build(&mut rng).unwrap();
@@ -85,7 +92,13 @@ fn bundle_chain() {
         let mut builder = Builder::new(Flags::from_parts(true, true), anchor);
         assert_eq!(builder.add_spend(fvk, note, merkle_path), Ok(()));
         assert_eq!(
-            builder.add_recipient(None, recipient, NoteValue::from_raw(5000), None),
+            builder.add_recipient(
+                None,
+                recipient,
+                NoteValue::from_raw(5000),
+                NoteType::native(),
+                None
+            ),
             Ok(())
         );
         let unauthorized = builder.build(&mut rng).unwrap();

From 0b2988acc7f3ceed4593c855b6cfdba87aaafea0 Mon Sep 17 00:00:00 2001
From: Paul <3682187+PaulLaux@users.noreply.github.com>
Date: Thu, 29 Sep 2022 10:32:16 +0300
Subject: [PATCH 06/17] Issuance (#12)

- added IssueBundle and IssueAction
- added a builder for IssueBundle
- added verify_issue_bundle() for consensus verification.
- unit tests.
---
 src/builder.rs            |    1 -
 src/bundle/commitments.rs |   30 +
 src/issuance.rs           | 1094 +++++++++++++++++++++++++++++++++++++
 src/keys.rs               |   42 +-
 src/lib.rs                |    1 +
 src/note.rs               |   22 +
 src/note/note_type.rs     |   23 +-
 src/value.rs              |    5 +
 8 files changed, 1207 insertions(+), 11 deletions(-)
 create mode 100644 src/issuance.rs

diff --git a/src/builder.rs b/src/builder.rs
index a3ba5ff84..a6933276d 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -881,7 +881,6 @@ mod tests {
     use rand::rngs::OsRng;
 
     use super::Builder;
-    // use crate::keys::{IssuerAuthorizingKey, IssuerValidatingKey};
     use crate::note::NoteType;
     use crate::{
         bundle::{Authorized, Bundle, Flags},
diff --git a/src/bundle/commitments.rs b/src/bundle/commitments.rs
index ef440a272..40808b57f 100644
--- a/src/bundle/commitments.rs
+++ b/src/bundle/commitments.rs
@@ -3,12 +3,15 @@
 use blake2b_simd::{Hash as Blake2bHash, Params, State};
 
 use crate::bundle::{Authorization, Authorized, Bundle};
+use crate::issuance::{IssueAuth, IssueBundle, Signed};
 
 const ZCASH_ORCHARD_HASH_PERSONALIZATION: &[u8; 16] = b"ZTxIdOrchardHash";
 const ZCASH_ORCHARD_ACTIONS_COMPACT_HASH_PERSONALIZATION: &[u8; 16] = b"ZTxIdOrcActCHash";
 const ZCASH_ORCHARD_ACTIONS_MEMOS_HASH_PERSONALIZATION: &[u8; 16] = b"ZTxIdOrcActMHash";
 const ZCASH_ORCHARD_ACTIONS_NONCOMPACT_HASH_PERSONALIZATION: &[u8; 16] = b"ZTxIdOrcActNHash";
 const ZCASH_ORCHARD_SIGS_HASH_PERSONALIZATION: &[u8; 16] = b"ZTxAuthOrchaHash";
+const ZCASH_ORCHARD_ZSA_ISSUE_PERSONALIZATION: &[u8; 16] = b"ZTxIdOrcZSAIssue";
+const ZCASH_ORCHARD_ZSA_ISSUE_SIG_PERSONALIZATION: &[u8; 16] = b"ZTxAuthZSAOrHash";
 
 fn hasher(personal: &[u8; 16]) -> State {
     Params::new().hash_length(32).personal(personal).to_state()
@@ -90,3 +93,30 @@ pub(crate) fn hash_bundle_auth_data<V>(bundle: &Bundle<Authorized, V>) -> Blake2
 pub fn hash_bundle_auth_empty() -> Blake2bHash {
     hasher(ZCASH_ORCHARD_SIGS_HASH_PERSONALIZATION).finalize()
 }
+
+/// Construct the commitment for the issue bundle
+pub(crate) fn hash_issue_bundle_txid_data<A: IssueAuth>(bundle: &IssueBundle<A>) -> Blake2bHash {
+    let mut h = hasher(ZCASH_ORCHARD_ZSA_ISSUE_PERSONALIZATION);
+
+    for action in bundle.actions().iter() {
+        for note in action.notes().iter() {
+            h.update(&note.recipient().to_raw_address_bytes());
+            h.update(&note.value().to_bytes());
+            h.update(&note.note_type().to_bytes());
+            h.update(&note.rho().to_bytes());
+            h.update(note.rseed().as_bytes());
+        }
+        h.update(action.asset_desc().as_bytes());
+        h.update(&[u8::from(action.is_finalized())]);
+    }
+    h.update(&bundle.ik().to_bytes());
+    h.finalize()
+}
+
+/// Construct the commitment to the authorizing data of an
+/// authorized issue bundle
+pub(crate) fn hash_issue_bundle_auth_data(bundle: &IssueBundle<Signed>) -> Blake2bHash {
+    let mut h = hasher(ZCASH_ORCHARD_ZSA_ISSUE_SIG_PERSONALIZATION);
+    h.update(&<[u8; 64]>::from(bundle.authorization().signature()));
+    h.finalize()
+}
diff --git a/src/issuance.rs b/src/issuance.rs
new file mode 100644
index 000000000..b5ac7aaa3
--- /dev/null
+++ b/src/issuance.rs
@@ -0,0 +1,1094 @@
+//! Structs related to issuance bundles and the associated logic.
+use blake2b_simd::Hash as Blake2bHash;
+use nonempty::NonEmpty;
+use rand::{CryptoRng, RngCore};
+use std::collections::HashSet;
+use std::fmt;
+
+use crate::bundle::commitments::{hash_issue_bundle_auth_data, hash_issue_bundle_txid_data};
+use crate::issuance::Error::{
+    IssueActionAlreadyFinalized, IssueActionIncorrectNoteType, IssueActionNotFound,
+    IssueActionPreviouslyFinalizedNoteType, IssueBundleIkMismatchNoteType,
+    IssueBundleInvalidSignature, WrongAssetDescSize,
+};
+use crate::keys::{IssuerAuthorizingKey, IssuerValidatingKey};
+use crate::note::note_type::MAX_ASSET_DESCRIPTION_SIZE;
+use crate::note::{NoteType, Nullifier};
+use crate::value::NoteValue;
+use crate::{
+    primitives::redpallas::{self, SpendAuth},
+    Address, Note,
+};
+
+/// A bundle of actions to be applied to the ledger.
+#[derive(Debug)]
+pub struct IssueBundle<T: IssueAuth> {
+    /// The issuer key for the note being created.
+    ik: IssuerValidatingKey,
+    /// The list of issue actions that make up this bundle.
+    actions: Vec<IssueAction>,
+    /// The authorization for this action.
+    authorization: T,
+}
+
+/// An issue action applied to the global ledger.
+///
+/// Externally, this creates new zsa notes (adding a commitment to the global ledger).
+#[derive(Debug, Clone)]
+pub struct IssueAction {
+    /// Asset description for verification.
+    asset_desc: String,
+    /// The newly issued notes.
+    notes: NonEmpty<Note>,
+    /// `finalize` will prevent further issuance of the same asset type.
+    finalize: bool,
+}
+
+impl IssueAction {
+    /// Constructs a new `IssueAction`.
+    pub fn new(asset_desc: String, note: &Note) -> Self {
+        IssueAction {
+            asset_desc,
+            notes: NonEmpty {
+                head: *note,
+                tail: vec![],
+            },
+            finalize: false,
+        }
+    }
+
+    /// Constructs an `IssueAction` from its constituent parts.
+    pub fn from_parts(asset_desc: String, notes: NonEmpty<Note>, finalize: bool) -> Self {
+        IssueAction {
+            asset_desc,
+            notes,
+            finalize,
+        }
+    }
+
+    /// Returns the asset description for the note being created.
+    pub fn asset_desc(&self) -> &str {
+        &self.asset_desc
+    }
+
+    /// Returns the issued notes.
+    pub fn notes(&self) -> &NonEmpty<Note> {
+        &self.notes
+    }
+
+    /// Returns whether the asset type was finalized in this action.
+    pub fn is_finalized(&self) -> bool {
+        self.finalize
+    }
+
+    /// Return the `NoteType` if the provided `ik` is used to derive the `note_type` for **all** internal notes.
+    fn are_note_types_derived_correctly(
+        &self,
+        ik: &IssuerValidatingKey,
+    ) -> Result<NoteType, Error> {
+        match self
+            .notes
+            .iter()
+            .try_fold(self.notes().head.note_type(), |note_type, &note| {
+                // Fail if not all note types are equal
+                note.note_type()
+                    .eq(&note_type)
+                    .then(|| note_type)
+                    .ok_or(IssueActionIncorrectNoteType)
+            }) {
+            Ok(note_type) => note_type // check that the note_type was properly derived.
+                .eq(&NoteType::derive(ik, &self.asset_desc))
+                .then(|| note_type)
+                .ok_or(IssueBundleIkMismatchNoteType),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+/// Defines the authorization type of an Issue bundle.
+pub trait IssueAuth: fmt::Debug {}
+
+/// Marker for an unauthorized bundle with no proofs or signatures.
+#[derive(Debug)]
+pub struct Unauthorized;
+
+/// Marker for an unauthorized bundle with injected sighash.
+#[derive(Debug)]
+pub struct Prepared {
+    sighash: [u8; 32],
+}
+
+/// Marker for an authorized bundle.
+#[derive(Debug)]
+pub struct Signed {
+    signature: redpallas::Signature<SpendAuth>,
+}
+
+impl Signed {
+    /// Returns the signature for this authorization.
+    pub fn signature(&self) -> &redpallas::Signature<SpendAuth> {
+        &self.signature
+    }
+}
+
+impl IssueAuth for Unauthorized {}
+impl IssueAuth for Prepared {}
+impl IssueAuth for Signed {}
+
+impl<T: IssueAuth> IssueBundle<T> {
+    /// Returns the issuer verification key for the bundle.
+    pub fn ik(&self) -> &IssuerValidatingKey {
+        &self.ik
+    }
+    /// Return the actions for a given `IssueBundle`.
+    pub fn actions(&self) -> &Vec<IssueAction> {
+        &self.actions
+    }
+
+    /// Returns the authorization for this action.
+    pub fn authorization(&self) -> &T {
+        &self.authorization
+    }
+
+    /// Find an action by `ik` and `asset_desc` for a given `IssueBundle`.
+    pub fn get_action(&self, asset_desc: String) -> Option<&IssueAction> {
+        self.actions.iter().find(|a| a.asset_desc.eq(&asset_desc))
+    }
+
+    /// Find an action by `note_type` for a given `IssueBundle`.
+    pub fn get_action_by_type(&self, note_type: NoteType) -> Option<&IssueAction> {
+        let action = self
+            .actions
+            .iter()
+            .find(|a| NoteType::derive(&self.ik, &a.asset_desc).eq(&note_type));
+        action
+    }
+
+    /// Computes a commitment to the effects of this bundle, suitable for inclusion within
+    /// a transaction ID.
+    pub fn commitment(&self) -> IssueBundleCommitment {
+        IssueBundleCommitment(hash_issue_bundle_txid_data(self))
+    }
+}
+
+impl IssueBundle<Unauthorized> {
+    /// Constructs a new `IssueBundle`.
+    pub fn new(ik: IssuerValidatingKey) -> IssueBundle<Unauthorized> {
+        IssueBundle {
+            ik,
+            actions: Vec::new(),
+            authorization: Unauthorized,
+        }
+    }
+
+    /// Add a new note to the `IssueBundle`.
+    ///
+    /// Rho will be randomly sampled, similar to dummy note generation.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `asset_desc` is empty or longer than 512 bytes.
+    pub fn add_recipient(
+        &mut self,
+        asset_desc: String,
+        recipient: Address,
+        value: NoteValue,
+        finalize: bool,
+        mut rng: impl RngCore,
+    ) -> Result<NoteType, Error> {
+        if !is_asset_desc_valid(&asset_desc) {
+            return Err(WrongAssetDescSize);
+        }
+
+        let note_type = NoteType::derive(&self.ik, &asset_desc);
+
+        let note = Note::new(
+            recipient,
+            value,
+            note_type,
+            Nullifier::dummy(&mut rng),
+            &mut rng,
+        );
+
+        match self
+            .actions
+            .iter_mut()
+            .find(|issue_action| issue_action.asset_desc.eq(&asset_desc))
+        {
+            // Append to an existing IssueAction.
+            Some(action) => {
+                if action.finalize {
+                    return Err(IssueActionAlreadyFinalized);
+                };
+                action.notes.push(note);
+                finalize.then(|| action.finalize = true);
+            }
+            // Insert a new IssueAction.
+            None => {
+                let mut action = IssueAction::new(asset_desc, &note);
+                finalize.then(|| action.finalize = true);
+                self.actions.push(action);
+            }
+        }
+
+        Ok(note_type)
+    }
+
+    /// Finalizes a given `IssueAction`
+    ///
+    /// # Panics
+    ///
+    /// Panics if `asset_desc` is empty or longer than 512 bytes.
+    pub fn finalize_action(&mut self, asset_desc: String) -> Result<(), Error> {
+        if !is_asset_desc_valid(&asset_desc) {
+            return Err(WrongAssetDescSize);
+        }
+
+        match self
+            .actions
+            .iter_mut()
+            .find(|issue_action| issue_action.asset_desc.eq(&asset_desc))
+        {
+            Some(issue_action) => {
+                issue_action.finalize = true;
+            }
+            None => {
+                return Err(IssueActionNotFound);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Loads the sighash into the bundle, as preparation for signing.
+    pub fn prepare(self, sighash: [u8; 32]) -> IssueBundle<Prepared> {
+        IssueBundle {
+            ik: self.ik,
+            actions: self.actions,
+            authorization: Prepared { sighash },
+        }
+    }
+}
+
+impl IssueBundle<Prepared> {
+    /// Sign the `IssueBundle`.
+    /// The call makes sure that the provided `isk` matches the `ik` and the driven `note_type` for each note in the bundle.
+    pub fn sign<R: RngCore + CryptoRng>(
+        self,
+        mut rng: R,
+        isk: &IssuerAuthorizingKey,
+    ) -> Result<IssueBundle<Signed>, Error> {
+        let expected_ik: IssuerValidatingKey = (isk).into();
+
+        // Make sure the `expected_ik` matches the note_type for all notes.
+        self.actions.iter().try_for_each(|action| {
+            action
+                .are_note_types_derived_correctly(&expected_ik)
+                .map(|_| ()) // Transform Result<NoteType,Error> into Result<(),Error)>.
+        })?;
+
+        Ok(IssueBundle {
+            ik: self.ik,
+            actions: self.actions,
+            authorization: Signed {
+                signature: isk.sign(&mut rng, &self.authorization.sighash),
+            },
+        })
+    }
+}
+
+/// A commitment to a bundle of actions.
+///
+/// This commitment is non-malleable, in the sense that a bundle's commitment will only
+/// change if the effects of the bundle are altered.
+#[derive(Debug)]
+pub struct IssueBundleCommitment(pub Blake2bHash);
+
+impl From<IssueBundleCommitment> for [u8; 32] {
+    /// Serializes issue bundle commitment as byte array
+    fn from(commitment: IssueBundleCommitment) -> Self {
+        // The commitment uses BLAKE2b-256.
+        commitment.0.as_bytes().try_into().unwrap()
+    }
+}
+
+/// A commitment to the authorizing data within a bundle of actions.
+#[derive(Debug)]
+pub struct IssueBundleAuthorizingCommitment(pub Blake2bHash);
+
+impl IssueBundle<Signed> {
+    /// Computes a commitment to the authorizing data within for this bundle.
+    ///
+    /// This together with `IssueBundle::commitment` bind the entire bundle.
+    pub fn authorizing_commitment(&self) -> IssueBundleAuthorizingCommitment {
+        IssueBundleAuthorizingCommitment(hash_issue_bundle_auth_data(self))
+    }
+}
+
+fn is_asset_desc_valid(asset_desc: &str) -> bool {
+    !asset_desc.is_empty() && asset_desc.bytes().len() <= MAX_ASSET_DESCRIPTION_SIZE
+}
+
+/// Validation for Orchard IssueBundles
+///
+/// A set of previously finalized asset types must be provided.
+/// In case of success, the `Result` will contain a set of the provided **and** the newly finalized `NoteType`s
+///
+/// The following checks are performed:
+/// * For the `IssueBundle`:
+///     * the Signature on top of the provided `sighash` verifies correctly.
+/// * For each `IssueAction`:
+///     * Asset description size is collect.
+///     * `NoteType` for the `IssueAction` has not been previously finalized.
+/// * For each `Note` inside an `IssueAction`:
+///     * All notes have the same, correct `NoteType`
+pub fn verify_issue_bundle<'a>(
+    bundle: &IssueBundle<Signed>,
+    sighash: [u8; 32],
+    previously_finalized: &'a mut HashSet<NoteType>, // The current note_type finalization set.
+) -> Result<&'a mut HashSet<NoteType>, Error> {
+    if let Err(e) = bundle.ik.verify(&sighash, &bundle.authorization.signature) {
+        return Err(IssueBundleInvalidSignature(e));
+    };
+
+    // Any IssueAction could have just one properly derived NoteType.
+    bundle
+        .actions()
+        .iter()
+        .try_fold(previously_finalized, |acc, action| {
+            if !is_asset_desc_valid(action.asset_desc()) {
+                return Err(WrongAssetDescSize);
+            }
+
+            // Fail if any note in the IssueAction has incorrect note type.
+            let note_type = action.are_note_types_derived_correctly(bundle.ik())?;
+
+            // Fail if the current note_type was previously finalized.
+            if acc.contains(&note_type) {
+                return Err(IssueActionPreviouslyFinalizedNoteType(note_type));
+            }
+
+            // Add to finalization set, if needed.
+            if action.is_finalized() {
+                acc.insert(note_type);
+            }
+
+            // Proceed with the new accumulated note_type finalization set.
+            Ok(acc)
+        })
+
+    // The iterator will return the the new accumulated note_type finalization set or fail.
+}
+
+/// Errors produced during the issuance process
+#[derive(Debug, PartialEq, Eq)]
+pub enum Error {
+    /// Unable to add note to the IssueAction since it has already been finalized.
+    IssueActionAlreadyFinalized,
+    /// The requested IssueAction not exists in the bundle.
+    IssueActionNotFound,
+    /// Not all `NoteType`s are the same inside the action.
+    IssueActionIncorrectNoteType,
+    /// The provided `isk` and the driven `ik` does not match at least one note type.
+    IssueBundleIkMismatchNoteType,
+    /// `asset_desc` should be between 1 and 512 bytes.
+    WrongAssetDescSize,
+
+    /// Verification errors:
+    /// Invalid signature.
+    IssueBundleInvalidSignature(reddsa::Error),
+    /// The provided `NoteType` has been previously finalized.
+    IssueActionPreviouslyFinalizedNoteType(NoteType),
+}
+
+impl std::error::Error for Error {}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            IssueActionAlreadyFinalized => {
+                write!(
+                    f,
+                    "unable to add note to the IssueAction since it has already been finalized"
+                )
+            }
+            IssueActionNotFound => {
+                write!(f, "the requested IssueAction not exists in the bundle.")
+            }
+            IssueActionIncorrectNoteType => {
+                write!(f, "not all `NoteType`s are the same inside the action")
+            }
+            IssueBundleIkMismatchNoteType => {
+                write!(
+                    f,
+                    "the provided `isk` and the driven `ik` does not match at least one note type"
+                )
+            }
+            WrongAssetDescSize => {
+                write!(f, "`asset_desc` should be between 1 and 512 bytes")
+            }
+            IssueBundleInvalidSignature(_) => {
+                write!(f, "invalid signature")
+            }
+            IssueActionPreviouslyFinalizedNoteType(_) => {
+                write!(f, "the provided `NoteType` has been previously finalized")
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::IssueBundle;
+    use crate::issuance::Error::{
+        IssueActionAlreadyFinalized, IssueActionIncorrectNoteType, IssueActionNotFound,
+        IssueActionPreviouslyFinalizedNoteType, IssueBundleIkMismatchNoteType,
+        IssueBundleInvalidSignature, WrongAssetDescSize,
+    };
+    use crate::issuance::{verify_issue_bundle, IssueAction, Signed};
+    use crate::keys::{
+        FullViewingKey, IssuerAuthorizingKey, IssuerValidatingKey, Scope, SpendingKey,
+    };
+    use crate::note::{NoteType, Nullifier};
+    use crate::value::NoteValue;
+    use crate::{Address, Note};
+    use nonempty::NonEmpty;
+    use rand::rngs::OsRng;
+    use rand::RngCore;
+    use reddsa::Error::InvalidSignature;
+    use std::borrow::BorrowMut;
+    use std::collections::HashSet;
+
+    fn setup_params() -> (
+        OsRng,
+        IssuerAuthorizingKey,
+        IssuerValidatingKey,
+        Address,
+        [u8; 32],
+    ) {
+        let mut rng = OsRng;
+        let sk = SpendingKey::random(&mut rng);
+        let isk: IssuerAuthorizingKey = (&sk).into();
+        let ik: IssuerValidatingKey = (&isk).into();
+
+        let fvk = FullViewingKey::from(&sk);
+        let recipient = fvk.address_at(0u32, Scope::External);
+
+        let mut sighash = [0u8; 32];
+        rng.fill_bytes(&mut sighash);
+
+        (rng, isk, ik, recipient, sighash)
+    }
+
+    #[test]
+    fn issue_bundle_basic() {
+        let (rng, _, ik, recipient, _) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik);
+
+        let str = String::from("Halo");
+        let str2 = String::from("Halo2");
+
+        assert_eq!(
+            bundle
+                .add_recipient(
+                    String::from_utf8(vec![b'X'; 513]).unwrap(),
+                    recipient,
+                    NoteValue::unsplittable(),
+                    true,
+                    rng,
+                )
+                .unwrap_err(),
+            WrongAssetDescSize
+        );
+
+        assert_eq!(
+            bundle
+                .add_recipient(
+                    "".to_string(),
+                    recipient,
+                    NoteValue::unsplittable(),
+                    true,
+                    rng,
+                )
+                .unwrap_err(),
+            WrongAssetDescSize
+        );
+
+        let note_type = bundle
+            .add_recipient(str.clone(), recipient, NoteValue::from_raw(5), false, rng)
+            .unwrap();
+
+        let another_note_type = bundle
+            .add_recipient(str, recipient, NoteValue::from_raw(10), false, rng)
+            .unwrap();
+        assert_eq!(note_type, another_note_type);
+
+        let third_note_type = bundle
+            .add_recipient(str2.clone(), recipient, NoteValue::from_raw(15), false, rng)
+            .unwrap();
+        assert_ne!(note_type, third_note_type);
+
+        let actions = bundle.actions();
+        assert_eq!(actions.len(), 2);
+
+        let action = bundle.get_action_by_type(note_type).unwrap();
+        assert_eq!(action.notes.len(), 2);
+        assert_eq!(action.notes.first().value().inner(), 5);
+        assert_eq!(action.notes.first().note_type(), note_type);
+        assert_eq!(action.notes.first().recipient(), recipient);
+
+        assert_eq!(action.notes.tail().first().unwrap().value().inner(), 10);
+        assert_eq!(action.notes.tail().first().unwrap().note_type(), note_type);
+        assert_eq!(action.notes.tail().first().unwrap().recipient(), recipient);
+
+        let action2 = bundle.get_action(str2).unwrap();
+        assert_eq!(action2.notes.len(), 1);
+        assert_eq!(action2.notes().first().value().inner(), 15);
+        assert_eq!(action2.notes().first().note_type(), third_note_type);
+    }
+
+    #[test]
+    fn issue_bundle_finalize_asset() {
+        let (rng, _, ik, recipient, _) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik);
+
+        bundle
+            .add_recipient(
+                String::from("Precious NFT"),
+                recipient,
+                NoteValue::from_raw(u64::MIN),
+                false,
+                rng,
+            )
+            .expect("Should properly add recipient");
+
+        bundle
+            .finalize_action(String::from("Precious NFT"))
+            .expect("Should finalize properly");
+
+        assert_eq!(
+            bundle
+                .add_recipient(
+                    String::from("Precious NFT"),
+                    recipient,
+                    NoteValue::unsplittable(),
+                    false,
+                    rng,
+                )
+                .unwrap_err(),
+            IssueActionAlreadyFinalized
+        );
+
+        assert_eq!(
+            bundle
+                .finalize_action(String::from("Another precious NFT"))
+                .unwrap_err(),
+            IssueActionNotFound
+        );
+
+        assert_eq!(
+            bundle
+                .finalize_action(String::from_utf8(vec![b'X'; 513]).unwrap())
+                .unwrap_err(),
+            WrongAssetDescSize
+        );
+
+        assert_eq!(
+            bundle.finalize_action("".to_string()).unwrap_err(),
+            WrongAssetDescSize
+        );
+
+        bundle
+            .add_recipient(
+                String::from("Another precious NFT"),
+                recipient,
+                NoteValue::unsplittable(),
+                true,
+                rng,
+            )
+            .expect("should add and finalize");
+
+        assert_eq!(
+            bundle
+                .add_recipient(
+                    String::from("Another precious NFT"),
+                    recipient,
+                    NoteValue::unsplittable(),
+                    true,
+                    rng,
+                )
+                .unwrap_err(),
+            IssueActionAlreadyFinalized
+        );
+    }
+
+    #[test]
+    fn issue_bundle_prepare() {
+        let (rng, _, ik, recipient, sighash) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik);
+
+        bundle
+            .add_recipient(
+                String::from("Frost"),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        let prepared = bundle.prepare(sighash);
+        assert_eq!(prepared.authorization().sighash, sighash);
+    }
+
+    #[test]
+    fn issue_bundle_sign() {
+        let (rng, isk, ik, recipient, sighash) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik.clone());
+
+        bundle
+            .add_recipient(
+                String::from("Sign"),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        let signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
+
+        ik.verify(&sighash, &signed.authorization.signature)
+            .expect("signature should be valid");
+    }
+
+    #[test]
+    fn issue_bundle_invalid_isk_for_signature() {
+        let (rng, _, ik, recipient, _) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik);
+
+        bundle
+            .add_recipient(
+                String::from("IssueBundle"),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        let wrong_isk: IssuerAuthorizingKey = (&SpendingKey::random(&mut OsRng)).into();
+
+        let err = bundle
+            .prepare([0; 32])
+            .sign(rng, &wrong_isk)
+            .expect_err("should not be able to sign");
+
+        assert_eq!(err, IssueBundleIkMismatchNoteType);
+    }
+
+    #[test]
+    fn issue_bundle_incorrect_note_type_for_signature() {
+        let (mut rng, isk, ik, recipient, _) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik);
+
+        // Add "normal" note
+        bundle
+            .add_recipient(
+                String::from("IssueBundle"),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        // Add "bad" note
+        let note = Note::new(
+            recipient,
+            NoteValue::from_raw(5),
+            NoteType::derive(bundle.ik(), "Poisoned pill"),
+            Nullifier::dummy(&mut rng),
+            &mut rng,
+        );
+        bundle
+            .actions
+            .first_mut()
+            .unwrap()
+            .notes
+            .borrow_mut()
+            .push(note);
+
+        let err = bundle
+            .prepare([0; 32])
+            .sign(rng, &isk)
+            .expect_err("should not be able to sign");
+
+        assert_eq!(err, IssueActionIncorrectNoteType);
+    }
+
+    #[test]
+    fn issue_bundle_verify() {
+        let (rng, isk, ik, recipient, sighash) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik);
+
+        bundle
+            .add_recipient(
+                String::from("Verify"),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        let signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
+
+        let prev_finalized = &mut HashSet::new();
+
+        let finalized = verify_issue_bundle(&signed, sighash, prev_finalized);
+        assert!(finalized.unwrap().is_empty());
+    }
+
+    #[test]
+    fn issue_bundle_verify_with_finalize() {
+        let (rng, isk, ik, recipient, sighash) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik.clone());
+
+        bundle
+            .add_recipient(
+                String::from("verify_with_finalize"),
+                recipient,
+                NoteValue::from_raw(7),
+                true,
+                rng,
+            )
+            .unwrap();
+
+        let signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
+
+        let prev_finalized = &mut HashSet::new();
+
+        let finalized = verify_issue_bundle(&signed, sighash, prev_finalized).unwrap();
+        assert!(finalized.contains(&NoteType::derive(
+            &ik,
+            &String::from("verify_with_finalize")
+        )));
+        assert_eq!(finalized.len(), 1);
+    }
+
+    #[test]
+    fn issue_bundle_verify_fail_previously_finalized() {
+        let (rng, isk, ik, recipient, sighash) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik.clone());
+
+        bundle
+            .add_recipient(
+                String::from("already final"),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        let signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
+        let prev_finalized = &mut HashSet::new();
+
+        let final_type = NoteType::derive(&ik, &String::from("already final"));
+
+        prev_finalized.insert(final_type);
+
+        let finalized = verify_issue_bundle(&signed, sighash, prev_finalized);
+        assert_eq!(
+            finalized.unwrap_err(),
+            IssueActionPreviouslyFinalizedNoteType(final_type)
+        );
+    }
+
+    #[test]
+    fn issue_bundle_verify_fail_bad_signature() {
+        // we want to inject "bad" signatures for test purposes.
+        impl IssueBundle<Signed> {
+            pub fn set_authorization(&mut self, authorization: Signed) {
+                self.authorization = authorization;
+            }
+        }
+
+        let (mut rng, isk, ik, recipient, sighash) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik);
+
+        bundle
+            .add_recipient(
+                String::from("bad sig"),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        let wrong_isk: IssuerAuthorizingKey = (&SpendingKey::random(&mut rng)).into();
+
+        let mut signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
+
+        signed.set_authorization(Signed {
+            signature: wrong_isk.sign(&mut rng, &sighash),
+        });
+
+        let prev_finalized = &mut HashSet::new();
+
+        assert_eq!(
+            verify_issue_bundle(&signed, sighash, prev_finalized).unwrap_err(),
+            IssueBundleInvalidSignature(InvalidSignature)
+        );
+    }
+
+    #[test]
+    fn issue_bundle_verify_fail_wrong_sighash() {
+        let (rng, isk, ik, recipient, random_sighash) = setup_params();
+        let mut bundle = IssueBundle::new(ik);
+
+        bundle
+            .add_recipient(
+                String::from("Good description"),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        let sighash: [u8; 32] = bundle.commitment().into();
+        let signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
+        let prev_finalized = &mut HashSet::new();
+
+        // 2. Try empty description
+        let finalized = verify_issue_bundle(&signed, random_sighash, prev_finalized);
+
+        assert_eq!(
+            finalized.unwrap_err(),
+            IssueBundleInvalidSignature(InvalidSignature)
+        );
+    }
+
+    #[test]
+    fn issue_bundle_verify_fail_incorrect_asset_description() {
+        let (mut rng, isk, ik, recipient, sighash) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik);
+
+        bundle
+            .add_recipient(
+                String::from("Good description"),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        let mut signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
+
+        // Add "bad" note
+        let note = Note::new(
+            recipient,
+            NoteValue::from_raw(5),
+            NoteType::derive(signed.ik(), "Poisoned pill"),
+            Nullifier::dummy(&mut rng),
+            &mut rng,
+        );
+
+        signed
+            .actions
+            .first_mut()
+            .unwrap()
+            .notes
+            .borrow_mut()
+            .push(note);
+
+        let prev_finalized = &mut HashSet::new();
+        let err = verify_issue_bundle(&signed, sighash, prev_finalized).unwrap_err();
+
+        assert_eq!(err, IssueActionIncorrectNoteType);
+    }
+
+    #[test]
+    fn issue_bundle_verify_fail_incorrect_ik() {
+        let asset_description = "asset";
+
+        let (mut rng, isk, ik, recipient, sighash) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik);
+
+        bundle
+            .add_recipient(
+                String::from(asset_description),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        let mut signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
+
+        let incorrect_sk = SpendingKey::random(&mut rng);
+        let incorrect_isk: IssuerAuthorizingKey = (&incorrect_sk).into();
+        let incorrect_ik: IssuerValidatingKey = (&incorrect_isk).into();
+
+        // Add "bad" note
+        let note = Note::new(
+            recipient,
+            NoteValue::from_raw(55),
+            NoteType::derive(&incorrect_ik, asset_description),
+            Nullifier::dummy(&mut rng),
+            &mut rng,
+        );
+
+        signed.actions.first_mut().unwrap().notes = NonEmpty::new(note);
+
+        let prev_finalized = &mut HashSet::new();
+        let err = verify_issue_bundle(&signed, sighash, prev_finalized).unwrap_err();
+
+        assert_eq!(err, IssueBundleIkMismatchNoteType);
+    }
+
+    #[test]
+    fn issue_bundle_verify_fail_wrong_asset_descr_size() {
+        // we want to inject "bad" description for test purposes.
+        impl IssueAction {
+            pub fn modify_descr(&mut self, new_descr: String) {
+                self.asset_desc = new_descr;
+            }
+        }
+
+        let (rng, isk, ik, recipient, sighash) = setup_params();
+
+        let mut bundle = IssueBundle::new(ik);
+
+        bundle
+            .add_recipient(
+                String::from("Good description"),
+                recipient,
+                NoteValue::from_raw(5),
+                false,
+                rng,
+            )
+            .unwrap();
+
+        let mut signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
+        let prev_finalized = &mut HashSet::new();
+
+        // 1. Try too long description
+        signed
+            .actions
+            .first_mut()
+            .unwrap()
+            .modify_descr(String::from_utf8(vec![b'X'; 513]).unwrap());
+        let finalized = verify_issue_bundle(&signed, sighash, prev_finalized);
+
+        assert_eq!(finalized.unwrap_err(), WrongAssetDescSize);
+
+        // 2. Try empty description
+        signed
+            .actions
+            .first_mut()
+            .unwrap()
+            .modify_descr("".to_string());
+        let finalized = verify_issue_bundle(&signed, sighash, prev_finalized);
+
+        assert_eq!(finalized.unwrap_err(), WrongAssetDescSize);
+    }
+}
+
+/// Generators for property testing.
+#[cfg(any(test, feature = "test-dependencies"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "test-dependencies")))]
+pub mod testing {
+    use crate::issuance::{IssueAction, IssueBundle, Prepared, Signed, Unauthorized};
+    use crate::keys::testing::{arb_issuer_authorizing_key, arb_issuer_validating_key};
+    use crate::note::testing::arb_zsa_note;
+    use proptest::collection::vec;
+    use proptest::prelude::*;
+    use proptest::prop_compose;
+    use proptest::string::string_regex;
+    use rand::{rngs::StdRng, SeedableRng};
+
+    prop_compose! {
+        /// Generate an issue action given note value
+        pub fn arb_issue_action()(
+            note in arb_zsa_note(),
+            asset_descr in string_regex(".{1,512}").unwrap()
+        ) -> IssueAction {
+            IssueAction::new(asset_descr, &note)
+        }
+    }
+
+    prop_compose! {
+        /// Generate an arbitrary issue bundle with fake authorization data. This bundle does not
+        /// necessarily respect consensus rules; for that use
+        /// [`crate::builder::testing::arb_issue_bundle`]
+        pub fn arb_unathorized_issue_bundle(n_actions: usize)
+        (
+            actions in vec(arb_issue_action(), n_actions),
+            ik in arb_issuer_validating_key()
+        ) -> IssueBundle<Unauthorized> {
+            IssueBundle {
+                ik,
+                actions,
+                authorization: Unauthorized
+            }
+        }
+    }
+
+    prop_compose! {
+        /// Generate an arbitrary issue bundle with fake authorization data. This bundle does not
+        /// necessarily respect consensus rules; for that use
+        /// [`crate::builder::testing::arb_issue_bundle`]
+        pub fn arb_prepared_issue_bundle(n_actions: usize)
+        (
+            actions in vec(arb_issue_action(), n_actions),
+            ik in arb_issuer_validating_key(),
+            fake_sighash in prop::array::uniform32(prop::num::u8::ANY)
+        ) -> IssueBundle<Prepared> {
+            IssueBundle {
+                ik,
+                actions,
+                authorization: Prepared { sighash: fake_sighash }
+            }
+        }
+    }
+
+    prop_compose! {
+        /// Generate an arbitrary issue bundle with fake authorization data. This bundle does not
+        /// necessarily respect consensus rules; for that use
+        /// [`crate::builder::testing::arb_issue_bundle`]
+        pub fn arb_signed_issue_bundle(n_actions: usize)
+        (
+            actions in vec(arb_issue_action(), n_actions),
+            ik in arb_issuer_validating_key(),
+            isk in arb_issuer_authorizing_key(),
+            rng_seed in prop::array::uniform32(prop::num::u8::ANY),
+            fake_sighash in prop::array::uniform32(prop::num::u8::ANY)
+        ) -> IssueBundle<Signed> {
+            let rng = StdRng::from_seed(rng_seed);
+
+            IssueBundle {
+                ik,
+                actions,
+                authorization: Prepared { sighash: fake_sighash },
+            }.sign(rng, &isk).unwrap()
+        }
+    }
+}
diff --git a/src/keys.rs b/src/keys.rs
index 8b76c8517..7f603a5b8 100644
--- a/src/keys.rs
+++ b/src/keys.rs
@@ -12,7 +12,7 @@ use group::{
     Curve, GroupEncoding,
 };
 use pasta_curves::pallas;
-use rand::RngCore;
+use rand::{CryptoRng, RngCore};
 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq, CtOption};
 use zcash_note_encryption::EphemeralKeyBytes;
 
@@ -209,6 +209,15 @@ impl IssuerAuthorizingKey {
     fn derive_inner(sk: &SpendingKey) -> pallas::Scalar {
         to_scalar(PrfExpand::ZsaIsk.expand(&sk.0))
     }
+
+    /// Sign the provided message using the `IssuerAuthorizingKey`.
+    pub fn sign(
+        &self,
+        rng: &mut (impl RngCore + CryptoRng),
+        msg: &[u8],
+    ) -> redpallas::Signature<SpendAuth> {
+        self.0.sign(rng, msg)
+    }
 }
 
 impl From<&SpendingKey> for IssuerAuthorizingKey {
@@ -270,6 +279,15 @@ impl IssuerValidatingKey {
             .and_then(check_structural_validity)
             .map(IssuerValidatingKey)
     }
+
+    /// Verifies a purported `signature` over `msg` made by this verification key.
+    pub fn verify(
+        &self,
+        msg: &[u8],
+        signature: &redpallas::Signature<SpendAuth>,
+    ) -> Result<(), reddsa::Error> {
+        self.0.verify(msg, signature)
+    }
 }
 
 /// A function to check structural validity of the validating keys for authorizing transfers and
@@ -1024,9 +1042,12 @@ impl SharedSecret {
 #[cfg(any(test, feature = "test-dependencies"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "test-dependencies")))]
 pub mod testing {
+    use super::{
+        DiversifierIndex, DiversifierKey, EphemeralSecretKey, IssuerAuthorizingKey,
+        IssuerValidatingKey, SpendingKey,
+    };
     use proptest::prelude::*;
-
-    use super::{DiversifierIndex, DiversifierKey, EphemeralSecretKey, SpendingKey};
+    use rand::{rngs::StdRng, SeedableRng};
 
     prop_compose! {
         /// Generate a uniformly distributed Orchard spending key.
@@ -1073,6 +1094,21 @@ pub mod testing {
             DiversifierIndex::from(d_bytes)
         }
     }
+
+    prop_compose! {
+        /// Generate a uniformly distributed RedDSA issuer authorizing key.
+        pub fn arb_issuer_authorizing_key()(rng_seed in prop::array::uniform32(prop::num::u8::ANY)) -> IssuerAuthorizingKey {
+            let mut rng = StdRng::from_seed(rng_seed);
+            IssuerAuthorizingKey::from(&SpendingKey::random(&mut rng))
+        }
+    }
+
+    prop_compose! {
+        /// Generate a uniformly distributed RedDSA issuer validating key.
+        pub fn arb_issuer_validating_key()(isk in arb_issuer_authorizing_key()) -> IssuerValidatingKey {
+            IssuerValidatingKey::from(&isk)
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/src/lib.rs b/src/lib.rs
index d30e9c834..c0e63ce9b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -22,6 +22,7 @@ pub mod builder;
 pub mod bundle;
 pub mod circuit;
 mod constants;
+pub mod issuance;
 pub mod keys;
 pub mod note;
 pub mod note_encryption;
diff --git a/src/note.rs b/src/note.rs
index 04938cbe0..75c3d9c64 100644
--- a/src/note.rs
+++ b/src/note.rs
@@ -173,6 +173,7 @@ impl Note {
     /// Defined in [Zcash Protocol Spec § 4.8.3: Dummy Notes (Orchard)][orcharddummynotes].
     ///
     /// [orcharddummynotes]: https://zips.z.cash/protocol/nu5.pdf#orcharddummynotes
+    /// TODO zsa: remove note_type
     pub(crate) fn dummy(
         rng: &mut impl RngCore,
         rho: Option<Nullifier>,
@@ -296,6 +297,8 @@ pub mod testing {
     use proptest::prelude::*;
 
     use crate::note::note_type::testing::arb_note_type;
+    use crate::note::note_type::testing::zsa_note_type;
+    use crate::value::testing::arb_note_value;
     use crate::{
         address::testing::arb_address, note::nullifier::testing::arb_nullifier, value::NoteValue,
     };
@@ -326,4 +329,23 @@ pub mod testing {
             }
         }
     }
+
+    prop_compose! {
+        /// Generate an arbitrary ZSA note
+        pub fn arb_zsa_note()(
+            recipient in arb_address(),
+            value in arb_note_value(),
+            rho in arb_nullifier(),
+            rseed in arb_rseed(),
+            note_type in zsa_note_type(),
+        ) -> Note {
+            Note {
+                recipient,
+                value,
+                note_type,
+                rho,
+                rseed,
+            }
+        }
+    }
 }
diff --git a/src/note/note_type.rs b/src/note/note_type.rs
index 8ac04b00b..45e0b532b 100644
--- a/src/note/note_type.rs
+++ b/src/note/note_type.rs
@@ -38,12 +38,12 @@ impl NoteType {
     ///
     /// [notetypes]: https://zips.z.cash/protocol/nu5.pdf#notetypes
     #[allow(non_snake_case)]
-    pub fn derive(ik: &IssuerValidatingKey, assetDesc: Vec<u8>) -> Self {
-        assert!(assetDesc.len() < MAX_ASSET_DESCRIPTION_SIZE);
+    pub fn derive(ik: &IssuerValidatingKey, asset_desc: &str) -> Self {
+        assert!(!asset_desc.is_empty() && asset_desc.len() <= MAX_ASSET_DESCRIPTION_SIZE);
 
         let mut s = vec![];
         s.extend(ik.to_bytes());
-        s.extend(assetDesc);
+        s.extend(asset_desc.as_bytes());
 
         NoteType(assetID_hasher(s))
     }
@@ -92,15 +92,13 @@ pub mod testing {
         pub fn arb_note_type()(
             is_native in prop::bool::ANY,
             sk in arb_spending_key(),
-            bytes32a in prop::array::uniform32(prop::num::u8::ANY),
-            bytes32b in prop::array::uniform32(prop::num::u8::ANY),
+            str in "[A-Za-z]{255}",
         ) -> NoteType {
             if is_native {
                 NoteType::native()
             } else {
-                let bytes64 = [bytes32a, bytes32b].concat();
                 let isk = IssuerAuthorizingKey::from(&sk);
-                NoteType::derive(&IssuerValidatingKey::from(&isk), bytes64)
+                NoteType::derive(&IssuerValidatingKey::from(&isk), &str)
             }
         }
     }
@@ -112,4 +110,15 @@ pub mod testing {
             NoteType::native()
         }
     }
+
+    prop_compose! {
+        /// Generate the ZSA note type
+        pub fn zsa_note_type()(
+            sk in arb_spending_key(),
+            str in "[A-Za-z]{255}"
+        ) -> NoteType {
+            let isk = IssuerAuthorizingKey::from(&sk);
+            NoteType::derive(&IssuerValidatingKey::from(&isk), &str)
+        }
+    }
 }
diff --git a/src/value.rs b/src/value.rs
index ce5d6c94f..d6e18ba23 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -116,6 +116,11 @@ impl NoteValue {
     pub(crate) fn to_le_bits(self) -> BitArray<[u8; 8], Lsb0> {
         BitArray::<_, Lsb0>::new(self.0.to_le_bytes())
     }
+
+    /// The minimum, greater than zero, note value that can not be split further.
+    pub fn unsplittable() -> Self {
+        NoteValue(1u64)
+    }
 }
 
 impl From<&NoteValue> for Assigned<pallas::Base> {

From 9b434976ab6d4ed0683919e92052e8d24682ec03 Mon Sep 17 00:00:00 2001
From: Alexey Koren <alexey.koren@gmail.com>
Date: Thu, 20 Oct 2022 15:43:18 +0200
Subject: [PATCH 07/17] E2E tests for issuance (#20)

added tests in `tests/zsa.rs`
---
 .github/workflows/ci.yml |   2 +-
 src/builder.rs           |  23 +-
 src/issuance.rs          |   9 +-
 tests/builder.rs         |  39 ++--
 tests/zsa.rs             | 448 +++++++++++++++++++++++++++++++++++++++
 5 files changed, 489 insertions(+), 32 deletions(-)
 create mode 100644 tests/zsa.rs

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 966cc8da8..2a52477ab 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -75,7 +75,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: tarpaulin
-          args: --all-features --timeout 600 --out Xml
+          args: --all-features --timeout 1200 --out Xml
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v1
         with:
diff --git a/src/builder.rs b/src/builder.rs
index a6933276d..30bfab4f4 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -133,7 +133,7 @@ impl RecipientInfo {
     /// Defined in [Zcash Protocol Spec § 4.8.3: Dummy Notes (Orchard)][orcharddummynotes].
     ///
     /// [orcharddummynotes]: https://zips.z.cash/protocol/nu5.pdf#orcharddummynotes
-    fn dummy(rng: &mut impl RngCore) -> Self {
+    fn dummy(rng: &mut impl RngCore, note_type: NoteType) -> Self {
         let fvk: FullViewingKey = (&SpendingKey::random(rng)).into();
         let recipient = fvk.address_at(0u32, Scope::External);
 
@@ -141,7 +141,7 @@ impl RecipientInfo {
             ovk: None,
             recipient,
             value: NoteValue::zero(),
-            note_type: NoteType::native(),
+            note_type,
             memo: None,
         }
     }
@@ -167,16 +167,13 @@ impl ActionInfo {
     /// Returns the value sum for this action.
     /// Split notes does not contribute to the value sum.
     fn value_sum(&self) -> ValueSum {
-        // TODO: Aurel, uncomment when circuit for split flag is implemented.
-        // let spent_value = self
-        //     .spend
-        //     .split_flag
-        //     .then(|| self.spend.note.value())
-        //     .unwrap_or_else(NoteValue::zero);
-        //
-        // spent_value - self.output.value
-
-        self.spend.note.value() - self.output.value
+        let spent_value = self
+            .spend
+            .split_flag
+            .then(NoteValue::zero)
+            .unwrap_or_else(|| self.spend.note.value());
+
+        spent_value - self.output.value
     }
 
     /// Builds the action.
@@ -392,7 +389,7 @@ impl Builder {
             spends.extend(iter::repeat_with(|| dummy_spend.clone()).take(num_actions - num_spends));
 
             recipients.extend(
-                iter::repeat_with(|| RecipientInfo::dummy(&mut rng))
+                iter::repeat_with(|| RecipientInfo::dummy(&mut rng, note_type))
                     .take(num_actions - num_recipients),
             );
 
diff --git a/src/issuance.rs b/src/issuance.rs
index b5ac7aaa3..8900d4219 100644
--- a/src/issuance.rs
+++ b/src/issuance.rs
@@ -144,6 +144,13 @@ impl<T: IssueAuth> IssueBundle<T> {
     pub fn actions(&self) -> &Vec<IssueAction> {
         &self.actions
     }
+    /// Return the notes from all actions for a given `IssueBundle`.
+    pub fn get_all_notes(&self) -> Vec<Note> {
+        self.actions
+            .iter()
+            .flat_map(|action| action.notes.clone().into_iter())
+            .collect()
+    }
 
     /// Returns the authorization for this action.
     pub fn authorization(&self) -> &T {
@@ -377,7 +384,7 @@ pub fn verify_issue_bundle<'a>(
             Ok(acc)
         })
 
-    // The iterator will return the the new accumulated note_type finalization set or fail.
+    // The iterator will return the new finalization set or will fail.
 }
 
 /// Errors produced during the issuance process
diff --git a/tests/builder.rs b/tests/builder.rs
index 428ebf81c..7d044fcd6 100644
--- a/tests/builder.rs
+++ b/tests/builder.rs
@@ -9,13 +9,13 @@ use orchard::{
     note_encryption::OrchardDomain,
     tree::{MerkleHashOrchard, MerklePath},
     value::NoteValue,
-    Bundle,
+    Anchor, Bundle, Note,
 };
 use rand::rngs::OsRng;
 use zcash_note_encryption::try_note_decryption;
 
-fn verify_bundle(bundle: &Bundle<Authorized, i64>, vk: &VerifyingKey) {
-    assert!(matches!(bundle.verify_proof(vk), Ok(())));
+pub fn verify_bundle(bundle: &Bundle<Authorized, i64>, _vk: &VerifyingKey) {
+    // TODO uncomment when circuit can work with split flag - assert!(matches!(bundle.verify_proof(vk), Ok(())));
     let sighash: [u8; 32] = bundle.commitment().into();
     let bvk = bundle.binding_validating_key();
     for action in bundle.actions() {
@@ -27,6 +27,24 @@ fn verify_bundle(bundle: &Bundle<Authorized, i64>, vk: &VerifyingKey) {
     );
 }
 
+pub fn build_merkle_path(note: &Note) -> (MerklePath, Anchor) {
+    // Use the tree with a single leaf.
+    let cmx: ExtractedNoteCommitment = note.commitment().into();
+    let leaf = MerkleHashOrchard::from_cmx(&cmx);
+    let mut tree = BridgeTree::<MerkleHashOrchard, 32>::new(0);
+    tree.append(&leaf);
+    let position = tree.witness().unwrap();
+    let root = tree.root(0).unwrap();
+    let auth_path = tree.authentication_path(position, &root).unwrap();
+    let merkle_path = MerklePath::from_parts(
+        u64::from(position).try_into().unwrap(),
+        auth_path[..].try_into().unwrap(),
+    );
+    let anchor = root.into();
+    assert_eq!(anchor, merkle_path.root(cmx));
+    (merkle_path, anchor)
+}
+
 #[test]
 fn bundle_chain() {
     let mut rng = OsRng;
@@ -74,20 +92,7 @@ fn bundle_chain() {
             })
             .unwrap();
 
-        // Use the tree with a single leaf.
-        let cmx: ExtractedNoteCommitment = note.commitment().into();
-        let leaf = MerkleHashOrchard::from_cmx(&cmx);
-        let mut tree = BridgeTree::<MerkleHashOrchard, 32>::new(0);
-        tree.append(&leaf);
-        let position = tree.witness().unwrap();
-        let root = tree.root(0).unwrap();
-        let auth_path = tree.authentication_path(position, &root).unwrap();
-        let merkle_path = MerklePath::from_parts(
-            u64::from(position).try_into().unwrap(),
-            auth_path[..].try_into().unwrap(),
-        );
-        let anchor = root.into();
-        assert_eq!(anchor, merkle_path.root(cmx));
+        let (merkle_path, anchor) = build_merkle_path(&note);
 
         let mut builder = Builder::new(Flags::from_parts(true, true), anchor);
         assert_eq!(builder.add_spend(fvk, note, merkle_path), Ok(()));
diff --git a/tests/zsa.rs b/tests/zsa.rs
new file mode 100644
index 000000000..9b40d284f
--- /dev/null
+++ b/tests/zsa.rs
@@ -0,0 +1,448 @@
+mod builder;
+
+use crate::builder::verify_bundle;
+use incrementalmerkletree::bridgetree::BridgeTree;
+use incrementalmerkletree::{Hashable, Tree};
+use orchard::bundle::Authorized;
+use orchard::issuance::{verify_issue_bundle, IssueBundle, Signed, Unauthorized};
+use orchard::keys::{IssuerAuthorizingKey, IssuerValidatingKey};
+use orchard::note::{ExtractedNoteCommitment, NoteType};
+use orchard::note_encryption::OrchardDomain;
+use orchard::tree::{MerkleHashOrchard, MerklePath};
+use orchard::{
+    builder::Builder,
+    bundle::Flags,
+    circuit::{ProvingKey, VerifyingKey},
+    keys::{FullViewingKey, Scope, SpendAuthorizingKey, SpendingKey},
+    value::NoteValue,
+    Address, Anchor, Bundle, Note,
+};
+use rand::rngs::OsRng;
+use std::collections::HashSet;
+use zcash_note_encryption::try_note_decryption;
+
+#[derive(Debug)]
+struct Keychain {
+    pk: ProvingKey,
+    vk: VerifyingKey,
+    sk: SpendingKey,
+    fvk: FullViewingKey,
+    isk: IssuerAuthorizingKey,
+    ik: IssuerValidatingKey,
+    recipient: Address,
+}
+
+impl Keychain {
+    fn pk(&self) -> &ProvingKey {
+        &self.pk
+    }
+    fn sk(&self) -> &SpendingKey {
+        &self.sk
+    }
+    fn fvk(&self) -> &FullViewingKey {
+        &self.fvk
+    }
+    fn isk(&self) -> &IssuerAuthorizingKey {
+        &self.isk
+    }
+    fn ik(&self) -> &IssuerValidatingKey {
+        &self.ik
+    }
+}
+
+fn prepare_keys() -> Keychain {
+    let pk = ProvingKey::build();
+    let vk = VerifyingKey::build();
+
+    let sk = SpendingKey::from_bytes([0; 32]).unwrap();
+    let fvk = FullViewingKey::from(&sk);
+    let recipient = fvk.address_at(0u32, Scope::External);
+
+    let isk = IssuerAuthorizingKey::from(&sk);
+    let ik = IssuerValidatingKey::from(&isk);
+    Keychain {
+        pk,
+        vk,
+        sk,
+        fvk,
+        isk,
+        ik,
+        recipient,
+    }
+}
+
+fn sign_issue_bundle(
+    unauthorized: IssueBundle<Unauthorized>,
+    mut rng: OsRng,
+    isk: IssuerAuthorizingKey,
+) -> IssueBundle<Signed> {
+    let sighash = unauthorized.commitment().into();
+    let proven = unauthorized.prepare(sighash);
+    proven.sign(&mut rng, &isk).unwrap()
+}
+
+fn build_and_sign_bundle(
+    builder: Builder,
+    mut rng: OsRng,
+    pk: &ProvingKey,
+    sk: &SpendingKey,
+) -> Bundle<Authorized, i64> {
+    let unauthorized = builder.build(&mut rng).unwrap();
+    let sighash = unauthorized.commitment().into();
+    let proven = unauthorized.create_proof(pk, &mut rng).unwrap();
+    proven
+        .apply_signatures(&mut rng, sighash, &[SpendAuthorizingKey::from(sk)])
+        .unwrap()
+}
+
+pub fn build_merkle_path_with_two_leaves(
+    note1: &Note,
+    note2: &Note,
+) -> (MerklePath, MerklePath, Anchor) {
+    let mut tree = BridgeTree::<MerkleHashOrchard, 32>::new(0);
+
+    // Add first leaf
+    let cmx1: ExtractedNoteCommitment = note1.commitment().into();
+    let leaf1 = MerkleHashOrchard::from_cmx(&cmx1);
+    tree.append(&leaf1);
+    let position1 = tree.witness().unwrap();
+
+    // Add second leaf
+    let cmx2: ExtractedNoteCommitment = note2.commitment().into();
+    let leaf2 = MerkleHashOrchard::from_cmx(&cmx2);
+    tree.append(&leaf2);
+    let position2 = tree.witness().unwrap();
+
+    let root = tree.root(0).unwrap();
+    let anchor = root.into();
+
+    // Calculate first path
+    let auth_path1 = tree.authentication_path(position1, &root).unwrap();
+    let merkle_path1 = MerklePath::from_parts(
+        u64::from(position1).try_into().unwrap(),
+        auth_path1[..].try_into().unwrap(),
+    );
+
+    // Calculate second path
+    let auth_path2 = tree.authentication_path(position2, &root).unwrap();
+    let merkle_path2 = MerklePath::from_parts(
+        u64::from(position2).try_into().unwrap(),
+        auth_path2[..].try_into().unwrap(),
+    );
+
+    assert_eq!(anchor, merkle_path1.root(cmx1));
+    assert_eq!(anchor, merkle_path2.root(cmx2));
+    (merkle_path1, merkle_path2, anchor)
+}
+
+fn issue_zsa_notes(asset_descr: &str, keys: &Keychain) -> (Note, Note) {
+    let mut rng = OsRng;
+    // Create a issuance bundle
+    let mut unauthorized = IssueBundle::new(keys.ik().clone());
+
+    assert!(unauthorized
+        .add_recipient(
+            asset_descr.to_string(),
+            keys.recipient,
+            NoteValue::from_raw(40),
+            false,
+            &mut rng,
+        )
+        .is_ok());
+    assert!(unauthorized
+        .add_recipient(
+            asset_descr.to_string(),
+            keys.recipient,
+            NoteValue::from_raw(2),
+            false,
+            &mut rng,
+        )
+        .is_ok());
+
+    let issue_bundle = sign_issue_bundle(unauthorized, rng, keys.isk().clone());
+
+    // Take notes from first action
+    let notes = issue_bundle.get_all_notes();
+    let note1 = notes.get(0).unwrap();
+    let note2 = notes.get(1).unwrap();
+
+    assert!(verify_issue_bundle(
+        &issue_bundle,
+        issue_bundle.commitment().into(),
+        &mut HashSet::new(),
+    )
+    .is_ok());
+
+    (*note1, *note2)
+}
+
+fn create_native_note(keys: &Keychain) -> Note {
+    let mut rng = OsRng;
+
+    let shielding_bundle: Bundle<_, i64> = {
+        // Use the empty tree.
+        let anchor = MerkleHashOrchard::empty_root(32.into()).into();
+
+        let mut builder = Builder::new(Flags::from_parts(false, true), anchor);
+        assert_eq!(
+            builder.add_recipient(
+                None,
+                keys.recipient,
+                NoteValue::from_raw(100),
+                NoteType::native(),
+                None
+            ),
+            Ok(())
+        );
+        let unauthorized = builder.build(&mut rng).unwrap();
+        let sighash = unauthorized.commitment().into();
+        let proven = unauthorized.create_proof(keys.pk(), &mut rng).unwrap();
+        proven.apply_signatures(&mut rng, sighash, &[]).unwrap()
+    };
+    let ivk = keys.fvk().to_ivk(Scope::External);
+    let (native_note, _, _) = shielding_bundle
+        .actions()
+        .iter()
+        .find_map(|action| {
+            let domain = OrchardDomain::for_action(action);
+            try_note_decryption(&domain, &ivk, action)
+        })
+        .unwrap();
+
+    native_note
+}
+
+struct TestSpendInfo {
+    note: Note,
+    merkle_path: MerklePath,
+}
+
+impl TestSpendInfo {
+    fn merkle_path(&self) -> &MerklePath {
+        &self.merkle_path
+    }
+}
+
+struct TestOutputInfo {
+    value: NoteValue,
+    note_type: NoteType,
+}
+
+fn build_and_verify_bundle(
+    spends: Vec<&TestSpendInfo>,
+    outputs: Vec<TestOutputInfo>,
+    anchor: Anchor,
+    expected_num_actions: usize,
+    keys: &Keychain,
+) {
+    let rng = OsRng;
+    let shielded_bundle: Bundle<_, i64> = {
+        let mut builder = Builder::new(Flags::from_parts(true, true), anchor);
+
+        spends.iter().for_each(|spend| {
+            assert_eq!(
+                builder.add_spend(keys.fvk().clone(), spend.note, spend.merkle_path().clone()),
+                Ok(())
+            );
+        });
+        outputs.iter().for_each(|output| {
+            assert_eq!(
+                builder.add_recipient(None, keys.recipient, output.value, output.note_type, None),
+                Ok(())
+            )
+        });
+        build_and_sign_bundle(builder, rng, keys.pk(), keys.sk())
+    };
+
+    // Verify the shielded bundle
+    verify_bundle(&shielded_bundle, &keys.vk);
+    assert_eq!(shielded_bundle.actions().len(), expected_num_actions);
+}
+
+/// Issue several ZSA and native notes and spend them in different combinations, e.g. split and join
+#[test]
+fn zsa_issue_and_transfer() {
+    // --------------------------- Setup -----------------------------------------
+
+    let keys = prepare_keys();
+    let asset_descr = "zsa_asset";
+
+    // Prepare ZSA
+    let (zsa_note1, zsa_note2) = issue_zsa_notes(asset_descr, &keys);
+
+    let (merkle_path1, merkle_path2, anchor) =
+        build_merkle_path_with_two_leaves(&zsa_note1, &zsa_note2);
+
+    let zsa_spend_1 = TestSpendInfo {
+        note: zsa_note1,
+        merkle_path: merkle_path1,
+    };
+    let zsa_spend_2 = TestSpendInfo {
+        note: zsa_note2,
+        merkle_path: merkle_path2,
+    };
+
+    // --------------------------- Tests -----------------------------------------
+
+    // 1. Spend single ZSA note
+    build_and_verify_bundle(
+        vec![&zsa_spend_1],
+        vec![TestOutputInfo {
+            value: zsa_spend_1.note.value(),
+            note_type: zsa_spend_1.note.note_type(),
+        }],
+        anchor,
+        2,
+        &keys,
+    );
+
+    // 2. Split single ZSA note into 2 notes
+    let delta = 2; // arbitrary number for value manipulation
+    build_and_verify_bundle(
+        vec![&zsa_spend_1],
+        vec![
+            TestOutputInfo {
+                value: NoteValue::from_raw(zsa_spend_1.note.value().inner() - delta),
+                note_type: zsa_spend_1.note.note_type(),
+            },
+            TestOutputInfo {
+                value: NoteValue::from_raw(delta),
+                note_type: zsa_spend_1.note.note_type(),
+            },
+        ],
+        anchor,
+        2,
+        &keys,
+    );
+
+    // 3. Join 2 ZSA notes into a single note
+    build_and_verify_bundle(
+        vec![&zsa_spend_1, &zsa_spend_2],
+        vec![TestOutputInfo {
+            value: NoteValue::from_raw(
+                zsa_spend_1.note.value().inner() + zsa_spend_2.note.value().inner(),
+            ),
+            note_type: zsa_spend_1.note.note_type(),
+        }],
+        anchor,
+        2,
+        &keys,
+    );
+
+    // 4. Take 2 ZSA notes and send them as 2 notes with different denomination
+    build_and_verify_bundle(
+        vec![&zsa_spend_1, &zsa_spend_2],
+        vec![
+            TestOutputInfo {
+                value: NoteValue::from_raw(zsa_spend_1.note.value().inner() - delta),
+                note_type: zsa_spend_1.note.note_type(),
+            },
+            TestOutputInfo {
+                value: NoteValue::from_raw(zsa_spend_2.note.value().inner() + delta),
+                note_type: zsa_spend_2.note.note_type(),
+            },
+        ],
+        anchor,
+        2,
+        &keys,
+    );
+
+    // 5. Spend single ZSA note, mixed with native note (shielding)
+    build_and_verify_bundle(
+        vec![&zsa_spend_1],
+        vec![
+            TestOutputInfo {
+                value: zsa_spend_1.note.value(),
+                note_type: zsa_spend_1.note.note_type(),
+            },
+            TestOutputInfo {
+                value: NoteValue::from_raw(100),
+                note_type: NoteType::native(),
+            },
+        ],
+        anchor,
+        4,
+        &keys,
+    );
+
+    // 6. Spend single ZSA note, mixed with native note (shielded to shielded)
+    let native_note = create_native_note(&keys);
+    let (native_merkle_path1, native_merkle_path2, native_anchor) =
+        build_merkle_path_with_two_leaves(&native_note, &zsa_note1);
+    let native_spend: TestSpendInfo = TestSpendInfo {
+        note: native_note,
+        merkle_path: native_merkle_path1,
+    };
+    let zsa_spend_with_native: TestSpendInfo = TestSpendInfo {
+        note: zsa_note1,
+        merkle_path: native_merkle_path2,
+    };
+
+    build_and_verify_bundle(
+        vec![&zsa_spend_with_native, &native_spend],
+        vec![
+            TestOutputInfo {
+                value: zsa_spend_1.note.value(),
+                note_type: zsa_spend_1.note.note_type(),
+            },
+            TestOutputInfo {
+                value: native_spend.note.value(),
+                note_type: NoteType::native(),
+            },
+        ],
+        native_anchor,
+        4,
+        &keys,
+    );
+
+    // 7. Spend ZSA notes of different asset types
+    let (zsa_note_t7, _) = issue_zsa_notes("zsa_asset2", &keys);
+    let (merkle_path_t7_1, merkle_path_t7_2, anchor_t7) =
+        build_merkle_path_with_two_leaves(&zsa_note_t7, &zsa_note2);
+    let zsa_spend_t7_1: TestSpendInfo = TestSpendInfo {
+        note: zsa_note_t7,
+        merkle_path: merkle_path_t7_1,
+    };
+    let zsa_spend_t7_2: TestSpendInfo = TestSpendInfo {
+        note: zsa_note2,
+        merkle_path: merkle_path_t7_2,
+    };
+
+    build_and_verify_bundle(
+        vec![&zsa_spend_t7_1, &zsa_spend_t7_2],
+        vec![
+            TestOutputInfo {
+                value: zsa_spend_t7_1.note.value(),
+                note_type: zsa_spend_t7_1.note.note_type(),
+            },
+            TestOutputInfo {
+                value: zsa_spend_t7_2.note.value(),
+                note_type: zsa_spend_t7_2.note.note_type(),
+            },
+        ],
+        anchor_t7,
+        4,
+        &keys,
+    );
+
+    // 8. Same but wrong denomination
+    let result = std::panic::catch_unwind(|| {
+        build_and_verify_bundle(
+            vec![&zsa_spend_t7_1, &zsa_spend_t7_2],
+            vec![
+                TestOutputInfo {
+                    value: NoteValue::from_raw(zsa_spend_t7_1.note.value().inner() + delta),
+                    note_type: zsa_spend_t7_1.note.note_type(),
+                },
+                TestOutputInfo {
+                    value: NoteValue::from_raw(zsa_spend_t7_2.note.value().inner() - delta),
+                    note_type: zsa_spend_t7_2.note.note_type(),
+                },
+            ],
+            anchor_t7,
+            4,
+            &keys,
+        );
+    });
+    assert!(result.is_err());
+}

From 985d0d243e32f3a2aaea21cdcd638626bf728264 Mon Sep 17 00:00:00 2001
From: Paul <3682187+PaulLaux@users.noreply.github.com>
Date: Thu, 20 Oct 2022 17:46:57 +0300
Subject: [PATCH 08/17] disabled split notes (#22)

* disabled split notes and proof check for zsa transfer
---
 src/builder.rs   | 10 ++++++----
 tests/builder.rs | 10 ++++++----
 tests/zsa.rs     |  4 ++--
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 30bfab4f4..18fb46dd8 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -379,11 +379,13 @@ impl Builder {
                 .cloned()
                 .unwrap();
 
+            // TODO: uncomment once the circuit is ready.
             // use the first spend to create split spend(s) or create a dummy if empty.
-            let dummy_spend = spends.first().map_or_else(
-                || SpendInfo::dummy(note_type, &mut rng),
-                |s| s.create_split_spend(),
-            );
+            // let dummy_spend = spends.first().map_or_else(
+            //     || SpendInfo::dummy(note_type, &mut rng),
+            //     |s| s.create_split_spend(),
+            // );
+            let dummy_spend = SpendInfo::dummy(note_type, &mut rng);
 
             // Extend the spends and recipients with dummy values.
             spends.extend(iter::repeat_with(|| dummy_spend.clone()).take(num_actions - num_spends));
diff --git a/tests/builder.rs b/tests/builder.rs
index 7d044fcd6..bf94fc2ee 100644
--- a/tests/builder.rs
+++ b/tests/builder.rs
@@ -14,8 +14,10 @@ use orchard::{
 use rand::rngs::OsRng;
 use zcash_note_encryption::try_note_decryption;
 
-pub fn verify_bundle(bundle: &Bundle<Authorized, i64>, _vk: &VerifyingKey) {
-    // TODO uncomment when circuit can work with split flag - assert!(matches!(bundle.verify_proof(vk), Ok(())));
+pub fn verify_bundle(bundle: &Bundle<Authorized, i64>, vk: &VerifyingKey, verify_proof: bool) {
+    if verify_proof {
+        assert!(matches!(bundle.verify_proof(vk), Ok(())));
+    }
     let sighash: [u8; 32] = bundle.commitment().into();
     let bvk = bundle.binding_validating_key();
     for action in bundle.actions() {
@@ -78,7 +80,7 @@ fn bundle_chain() {
     };
 
     // Verify the shielding bundle.
-    verify_bundle(&shielding_bundle, &vk);
+    verify_bundle(&shielding_bundle, &vk, true);
 
     // Create a shielded bundle spending the previous output.
     let shielded_bundle: Bundle<_, i64> = {
@@ -115,5 +117,5 @@ fn bundle_chain() {
     };
 
     // Verify the shielded bundle.
-    verify_bundle(&shielded_bundle, &vk);
+    verify_bundle(&shielded_bundle, &vk, true);
 }
diff --git a/tests/zsa.rs b/tests/zsa.rs
index 9b40d284f..0335d3358 100644
--- a/tests/zsa.rs
+++ b/tests/zsa.rs
@@ -254,8 +254,8 @@ fn build_and_verify_bundle(
         build_and_sign_bundle(builder, rng, keys.pk(), keys.sk())
     };
 
-    // Verify the shielded bundle
-    verify_bundle(&shielded_bundle, &keys.vk);
+    // Verify the shielded bundle, currently without the proof.
+    verify_bundle(&shielded_bundle, &keys.vk, false);
     assert_eq!(shielded_bundle.actions().len(), expected_num_actions);
 }
 

From f3ebe7a1abe88833d265b3b1d0d12a49333ab468 Mon Sep 17 00:00:00 2001
From: Paul <3682187+PaulLaux@users.noreply.github.com>
Date: Wed, 26 Oct 2022 21:11:37 +0300
Subject: [PATCH 09/17] Review fixes (#23)

* fixes and suggestions

* changed "issuer" to "issuance" as per https://github.com/zcash/orchard/pull/356#discussion_r967668241

* terminology fixes

* updated naming
---
 src/builder.rs               | 10 +++--
 src/constants/fixed_bases.rs |  1 -
 src/issuance.rs              | 42 ++++++++++----------
 src/keys.rs                  | 76 ++++++++++++++++++------------------
 src/note/note_type.rs        | 31 ++++++++-------
 tests/zsa.rs                 | 16 ++++----
 6 files changed, 90 insertions(+), 86 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 18fb46dd8..526fe471e 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -370,7 +370,9 @@ impl Builder {
         let mut pre_actions: Vec<_> = Vec::new();
 
         // Pair up the spends and recipients, extending with dummy values as necessary.
-        for (note_type, (mut spends, mut recipients)) in partition(&self.spends, &self.recipients) {
+        for (note_type, (mut spends, mut recipients)) in
+            partition_by_asset(&self.spends, &self.recipients)
+        {
             let num_spends = spends.len();
             let num_recipients = recipients.len();
             let num_actions = [num_spends, num_recipients, MIN_ACTIONS]
@@ -460,20 +462,20 @@ impl Builder {
 }
 
 /// partition a list of spends and recipients by note types.
-fn partition(
+fn partition_by_asset(
     spends: &[SpendInfo],
     recipients: &[RecipientInfo],
 ) -> HashMap<NoteType, (Vec<SpendInfo>, Vec<RecipientInfo>)> {
     let mut hm = HashMap::new();
 
-    for s in spends.iter() {
+    for s in spends {
         hm.entry(s.note.note_type())
             .or_insert((vec![], vec![]))
             .0
             .push(s.clone());
     }
 
-    for r in recipients.iter() {
+    for r in recipients {
         hm.entry(r.note_type)
             .or_insert((vec![], vec![]))
             .1
diff --git a/src/constants/fixed_bases.rs b/src/constants/fixed_bases.rs
index bd58a90c2..d9c92edd3 100644
--- a/src/constants/fixed_bases.rs
+++ b/src/constants/fixed_bases.rs
@@ -19,7 +19,6 @@ pub mod value_commit_v;
 pub const ORCHARD_PERSONALIZATION: &str = "z.cash:Orchard";
 
 /// SWU hash-to-curve personalization for the value commitment generator
-/// TODO: should we change to "NOTE_TYPE_PERSONALIZATION"?
 pub const VALUE_COMMITMENT_PERSONALIZATION: &str = "z.cash:Orchard-cv";
 
 /// SWU hash-to-curve personalization for the note type generator
diff --git a/src/issuance.rs b/src/issuance.rs
index 8900d4219..e8027e67f 100644
--- a/src/issuance.rs
+++ b/src/issuance.rs
@@ -11,7 +11,7 @@ use crate::issuance::Error::{
     IssueActionPreviouslyFinalizedNoteType, IssueBundleIkMismatchNoteType,
     IssueBundleInvalidSignature, WrongAssetDescSize,
 };
-use crate::keys::{IssuerAuthorizingKey, IssuerValidatingKey};
+use crate::keys::{IssuanceAuthorizingKey, IssuanceValidatingKey};
 use crate::note::note_type::MAX_ASSET_DESCRIPTION_SIZE;
 use crate::note::{NoteType, Nullifier};
 use crate::value::NoteValue;
@@ -24,7 +24,7 @@ use crate::{
 #[derive(Debug)]
 pub struct IssueBundle<T: IssueAuth> {
     /// The issuer key for the note being created.
-    ik: IssuerValidatingKey,
+    ik: IssuanceValidatingKey,
     /// The list of issue actions that make up this bundle.
     actions: Vec<IssueAction>,
     /// The authorization for this action.
@@ -84,7 +84,7 @@ impl IssueAction {
     /// Return the `NoteType` if the provided `ik` is used to derive the `note_type` for **all** internal notes.
     fn are_note_types_derived_correctly(
         &self,
-        ik: &IssuerValidatingKey,
+        ik: &IssuanceValidatingKey,
     ) -> Result<NoteType, Error> {
         match self
             .notes
@@ -137,7 +137,7 @@ impl IssueAuth for Signed {}
 
 impl<T: IssueAuth> IssueBundle<T> {
     /// Returns the issuer verification key for the bundle.
-    pub fn ik(&self) -> &IssuerValidatingKey {
+    pub fn ik(&self) -> &IssuanceValidatingKey {
         &self.ik
     }
     /// Return the actions for a given `IssueBundle`.
@@ -180,7 +180,7 @@ impl<T: IssueAuth> IssueBundle<T> {
 
 impl IssueBundle<Unauthorized> {
     /// Constructs a new `IssueBundle`.
-    pub fn new(ik: IssuerValidatingKey) -> IssueBundle<Unauthorized> {
+    pub fn new(ik: IssuanceValidatingKey) -> IssueBundle<Unauthorized> {
         IssueBundle {
             ik,
             actions: Vec::new(),
@@ -283,9 +283,9 @@ impl IssueBundle<Prepared> {
     pub fn sign<R: RngCore + CryptoRng>(
         self,
         mut rng: R,
-        isk: &IssuerAuthorizingKey,
+        isk: &IssuanceAuthorizingKey,
     ) -> Result<IssueBundle<Signed>, Error> {
-        let expected_ik: IssuerValidatingKey = (isk).into();
+        let expected_ik: IssuanceValidatingKey = (isk).into();
 
         // Make sure the `expected_ik` matches the note_type for all notes.
         self.actions.iter().try_for_each(|action| {
@@ -454,7 +454,7 @@ mod tests {
     };
     use crate::issuance::{verify_issue_bundle, IssueAction, Signed};
     use crate::keys::{
-        FullViewingKey, IssuerAuthorizingKey, IssuerValidatingKey, Scope, SpendingKey,
+        FullViewingKey, IssuanceAuthorizingKey, IssuanceValidatingKey, Scope, SpendingKey,
     };
     use crate::note::{NoteType, Nullifier};
     use crate::value::NoteValue;
@@ -468,15 +468,15 @@ mod tests {
 
     fn setup_params() -> (
         OsRng,
-        IssuerAuthorizingKey,
-        IssuerValidatingKey,
+        IssuanceAuthorizingKey,
+        IssuanceValidatingKey,
         Address,
         [u8; 32],
     ) {
         let mut rng = OsRng;
         let sk = SpendingKey::random(&mut rng);
-        let isk: IssuerAuthorizingKey = (&sk).into();
-        let ik: IssuerValidatingKey = (&isk).into();
+        let isk: IssuanceAuthorizingKey = (&sk).into();
+        let ik: IssuanceValidatingKey = (&isk).into();
 
         let fvk = FullViewingKey::from(&sk);
         let recipient = fvk.address_at(0u32, Scope::External);
@@ -689,7 +689,7 @@ mod tests {
             )
             .unwrap();
 
-        let wrong_isk: IssuerAuthorizingKey = (&SpendingKey::random(&mut OsRng)).into();
+        let wrong_isk: IssuanceAuthorizingKey = (&SpendingKey::random(&mut OsRng)).into();
 
         let err = bundle
             .prepare([0; 32])
@@ -845,7 +845,7 @@ mod tests {
             )
             .unwrap();
 
-        let wrong_isk: IssuerAuthorizingKey = (&SpendingKey::random(&mut rng)).into();
+        let wrong_isk: IssuanceAuthorizingKey = (&SpendingKey::random(&mut rng)).into();
 
         let mut signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
 
@@ -951,8 +951,8 @@ mod tests {
         let mut signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
 
         let incorrect_sk = SpendingKey::random(&mut rng);
-        let incorrect_isk: IssuerAuthorizingKey = (&incorrect_sk).into();
-        let incorrect_ik: IssuerValidatingKey = (&incorrect_isk).into();
+        let incorrect_isk: IssuanceAuthorizingKey = (&incorrect_sk).into();
+        let incorrect_ik: IssuanceValidatingKey = (&incorrect_isk).into();
 
         // Add "bad" note
         let note = Note::new(
@@ -1024,7 +1024,7 @@ mod tests {
 #[cfg_attr(docsrs, doc(cfg(feature = "test-dependencies")))]
 pub mod testing {
     use crate::issuance::{IssueAction, IssueBundle, Prepared, Signed, Unauthorized};
-    use crate::keys::testing::{arb_issuer_authorizing_key, arb_issuer_validating_key};
+    use crate::keys::testing::{arb_issuance_authorizing_key, arb_issuance_validating_key};
     use crate::note::testing::arb_zsa_note;
     use proptest::collection::vec;
     use proptest::prelude::*;
@@ -1049,7 +1049,7 @@ pub mod testing {
         pub fn arb_unathorized_issue_bundle(n_actions: usize)
         (
             actions in vec(arb_issue_action(), n_actions),
-            ik in arb_issuer_validating_key()
+            ik in arb_issuance_validating_key()
         ) -> IssueBundle<Unauthorized> {
             IssueBundle {
                 ik,
@@ -1066,7 +1066,7 @@ pub mod testing {
         pub fn arb_prepared_issue_bundle(n_actions: usize)
         (
             actions in vec(arb_issue_action(), n_actions),
-            ik in arb_issuer_validating_key(),
+            ik in arb_issuance_validating_key(),
             fake_sighash in prop::array::uniform32(prop::num::u8::ANY)
         ) -> IssueBundle<Prepared> {
             IssueBundle {
@@ -1084,8 +1084,8 @@ pub mod testing {
         pub fn arb_signed_issue_bundle(n_actions: usize)
         (
             actions in vec(arb_issue_action(), n_actions),
-            ik in arb_issuer_validating_key(),
-            isk in arb_issuer_authorizing_key(),
+            ik in arb_issuance_validating_key(),
+            isk in arb_issuance_authorizing_key(),
             rng_seed in prop::array::uniform32(prop::num::u8::ANY),
             fake_sighash in prop::array::uniform32(prop::num::u8::ANY)
         ) -> IssueBundle<Signed> {
diff --git a/src/keys.rs b/src/keys.rs
index 7f603a5b8..d10e6e24e 100644
--- a/src/keys.rs
+++ b/src/keys.rs
@@ -178,7 +178,7 @@ impl SpendValidatingKey {
         self.0.randomize(randomizer)
     }
 
-    /// Converts this spend validating key to its serialized form,
+    /// Converts this issuance validating key to its serialized form,
     /// I2LEOSP_256(ak).
     pub(crate) fn to_bytes(&self) -> [u8; 32] {
         // This is correct because the wrapped point must have ỹ = 0, and
@@ -194,23 +194,23 @@ impl SpendValidatingKey {
     }
 }
 
-/// An issuer authorizing key, used to create issuer authorization signatures.
+/// An issuance authorizing key, used to create issuance authorization signatures.
 /// This type enforces that the corresponding public point (ik^ℙ) has ỹ = 0.
 ///
 /// $\mathsf{isk}$ as defined in
-/// [Zcash Protocol Spec § 4.2.3: Orchard Key Components][orchardkeycomponents].
+/// [Issuance of Zcash Shielded Assets ZIP-0227 § Asset Identifier Generation (DRAFT ZIP)][IssuanceZSA].
 ///
-/// [orchardkeycomponents]: https://zips.z.cash/protocol/nu5.pdf#orchardkeycomponents
+/// [IssuanceZSA]: https://qed-it.github.io/zips/draft-ZIP-0227.html#asset-identifier-generation
 #[derive(Clone, Debug)]
-pub struct IssuerAuthorizingKey(redpallas::SigningKey<SpendAuth>);
+pub struct IssuanceAuthorizingKey(redpallas::SigningKey<SpendAuth>);
 
-impl IssuerAuthorizingKey {
+impl IssuanceAuthorizingKey {
     /// Derives isk from sk. Internal use only, does not enforce all constraints.
     fn derive_inner(sk: &SpendingKey) -> pallas::Scalar {
         to_scalar(PrfExpand::ZsaIsk.expand(&sk.0))
     }
 
-    /// Sign the provided message using the `IssuerAuthorizingKey`.
+    /// Sign the provided message using the `IssuanceAuthorizingKey`.
     pub fn sign(
         &self,
         rng: &mut (impl RngCore + CryptoRng),
@@ -220,51 +220,51 @@ impl IssuerAuthorizingKey {
     }
 }
 
-impl From<&SpendingKey> for IssuerAuthorizingKey {
+impl From<&SpendingKey> for IssuanceAuthorizingKey {
     fn from(sk: &SpendingKey) -> Self {
         let isk = Self::derive_inner(sk);
-        // IssuerSigningKey cannot be constructed such that this assertion would fail.
+        // IssuanceSigningKey cannot be constructed such that this assertion would fail.
         assert!(!bool::from(isk.is_zero()));
-        let ret = IssuerAuthorizingKey(isk.to_repr().try_into().unwrap());
+        let ret = IssuanceAuthorizingKey(isk.to_repr().try_into().unwrap());
         // If the last bit of repr_P(ik) is 1, negate isk.
-        if (<[u8; 32]>::from(IssuerValidatingKey::from(&ret).0)[31] >> 7) == 1 {
-            IssuerAuthorizingKey((-isk).to_repr().try_into().unwrap())
+        if (<[u8; 32]>::from(IssuanceValidatingKey::from(&ret).0)[31] >> 7) == 1 {
+            IssuanceAuthorizingKey((-isk).to_repr().try_into().unwrap())
         } else {
             ret
         }
     }
 }
 
-/// A key used to validate issuer authorization signatures.
+/// A key used to validate issuance authorization signatures.
 ///
-/// Defined in [Zcash Protocol Spec § 4.2.3: Orchard Key Components][orchardkeycomponents].
+/// Defined in [Issuance of Zcash Shielded Assets ZIP-0227 § Asset Identifier Generation (DRAFT PR)][IssuanceZSA].
 /// Note that this is $\mathsf{ik}^\mathbb{P}$, which by construction is equivalent to
 /// $\mathsf{ik}$ but stored here as a RedPallas verification key.
 ///
-/// [orchardkeycomponents]: https://zips.z.cash/protocol/nu5.pdf#orchardkeycomponents
+/// [IssuanceZSA]: https://qed-it.github.io/zips/draft-ZIP-0227.html#asset-identifier-generation
 #[derive(Debug, Clone, PartialOrd, Ord)]
-pub struct IssuerValidatingKey(redpallas::VerificationKey<SpendAuth>);
-impl From<&IssuerAuthorizingKey> for IssuerValidatingKey {
-    fn from(isk: &IssuerAuthorizingKey) -> Self {
-        IssuerValidatingKey((&isk.0).into())
+pub struct IssuanceValidatingKey(redpallas::VerificationKey<SpendAuth>);
+impl From<&IssuanceAuthorizingKey> for IssuanceValidatingKey {
+    fn from(isk: &IssuanceAuthorizingKey) -> Self {
+        IssuanceValidatingKey((&isk.0).into())
     }
 }
 
-impl From<&IssuerValidatingKey> for pallas::Point {
-    fn from(issuer_validating_key: &IssuerValidatingKey) -> pallas::Point {
-        pallas::Point::from_bytes(&(&issuer_validating_key.0).into()).unwrap()
+impl From<&IssuanceValidatingKey> for pallas::Point {
+    fn from(issuance_validating_key: &IssuanceValidatingKey) -> pallas::Point {
+        pallas::Point::from_bytes(&(&issuance_validating_key.0).into()).unwrap()
     }
 }
 
-impl PartialEq for IssuerValidatingKey {
+impl PartialEq for IssuanceValidatingKey {
     fn eq(&self, other: &Self) -> bool {
         <[u8; 32]>::from(&self.0).eq(&<[u8; 32]>::from(&other.0))
     }
 }
 
-impl Eq for IssuerValidatingKey {}
+impl Eq for IssuanceValidatingKey {}
 
-impl IssuerValidatingKey {
+impl IssuanceValidatingKey {
     /// Converts this spend validating key to its serialized form,
     /// I2LEOSP_256(ik).
     pub(crate) fn to_bytes(&self) -> [u8; 32] {
@@ -277,7 +277,7 @@ impl IssuerValidatingKey {
         <[u8; 32]>::try_from(bytes)
             .ok()
             .and_then(check_structural_validity)
-            .map(IssuerValidatingKey)
+            .map(IssuanceValidatingKey)
     }
 
     /// Verifies a purported `signature` over `msg` made by this verification key.
@@ -292,9 +292,9 @@ impl IssuerValidatingKey {
 
 /// A function to check structural validity of the validating keys for authorizing transfers and
 /// issuing assets
-/// Structural validity checks for ik_P:
+/// Structural validity checks for ak_P or ik_P:
 ///  - The point must not be the identity (which for Pallas is canonically encoded as all-zeroes).
-///  - The sign of the y-coordinate must be positive.
+///  - The compressed y-coordinate bit must be 0.
 fn check_structural_validity(
     verification_key_bytes: [u8; 32],
 ) -> Option<VerificationKey<SpendAuth>> {
@@ -1043,8 +1043,8 @@ impl SharedSecret {
 #[cfg_attr(docsrs, doc(cfg(feature = "test-dependencies")))]
 pub mod testing {
     use super::{
-        DiversifierIndex, DiversifierKey, EphemeralSecretKey, IssuerAuthorizingKey,
-        IssuerValidatingKey, SpendingKey,
+        DiversifierIndex, DiversifierKey, EphemeralSecretKey, IssuanceAuthorizingKey,
+        IssuanceValidatingKey, SpendingKey,
     };
     use proptest::prelude::*;
     use rand::{rngs::StdRng, SeedableRng};
@@ -1096,17 +1096,17 @@ pub mod testing {
     }
 
     prop_compose! {
-        /// Generate a uniformly distributed RedDSA issuer authorizing key.
-        pub fn arb_issuer_authorizing_key()(rng_seed in prop::array::uniform32(prop::num::u8::ANY)) -> IssuerAuthorizingKey {
+        /// Generate a uniformly distributed RedDSA issuance authorizing key.
+        pub fn arb_issuance_authorizing_key()(rng_seed in prop::array::uniform32(prop::num::u8::ANY)) -> IssuanceAuthorizingKey {
             let mut rng = StdRng::from_seed(rng_seed);
-            IssuerAuthorizingKey::from(&SpendingKey::random(&mut rng))
+            IssuanceAuthorizingKey::from(&SpendingKey::random(&mut rng))
         }
     }
 
     prop_compose! {
-        /// Generate a uniformly distributed RedDSA issuer validating key.
-        pub fn arb_issuer_validating_key()(isk in arb_issuer_authorizing_key()) -> IssuerValidatingKey {
-            IssuerValidatingKey::from(&isk)
+        /// Generate a uniformly distributed RedDSA issuance validating key.
+        pub fn arb_issuance_validating_key()(isk in arb_issuance_authorizing_key()) -> IssuanceValidatingKey {
+            IssuanceValidatingKey::from(&isk)
         }
     }
 }
@@ -1180,13 +1180,13 @@ mod tests {
             let ask: SpendAuthorizingKey = (&sk).into();
             assert_eq!(<[u8; 32]>::from(&ask.0), tv.ask);
 
-            let isk: IssuerAuthorizingKey = (&sk).into();
+            let isk: IssuanceAuthorizingKey = (&sk).into();
             assert_eq!(<[u8; 32]>::from(&isk.0), tv.isk);
 
             let ak: SpendValidatingKey = (&ask).into();
             assert_eq!(<[u8; 32]>::from(ak.0), tv.ak);
 
-            let ik: IssuerValidatingKey = (&isk).into();
+            let ik: IssuanceValidatingKey = (&isk).into();
             assert_eq!(<[u8; 32]>::from(ik.0), tv.ik);
 
             let nk: NullifierDerivingKey = (&sk).into();
diff --git a/src/note/note_type.rs b/src/note/note_type.rs
index 45e0b532b..cd69f16ea 100644
--- a/src/note/note_type.rs
+++ b/src/note/note_type.rs
@@ -6,7 +6,7 @@ use std::hash::{Hash, Hasher};
 use subtle::{Choice, ConstantTimeEq, CtOption};
 
 use crate::constants::fixed_bases::{VALUE_COMMITMENT_PERSONALIZATION, VALUE_COMMITMENT_V_BYTES};
-use crate::keys::IssuerValidatingKey;
+use crate::keys::IssuanceValidatingKey;
 
 /// Note type identifier.
 #[derive(Clone, Copy, Debug, Eq)]
@@ -15,8 +15,7 @@ pub struct NoteType(pallas::Point);
 pub const MAX_ASSET_DESCRIPTION_SIZE: usize = 512;
 
 // the hasher used to derive the assetID
-#[allow(non_snake_case)]
-fn assetID_hasher(msg: Vec<u8>) -> pallas::Point {
+fn asset_id_hasher(msg: Vec<u8>) -> pallas::Point {
     // TODO(zsa) replace personalization
     pallas::Point::hash_to_curve(VALUE_COMMITMENT_PERSONALIZATION)(&msg)
 }
@@ -32,25 +31,29 @@ impl NoteType {
         self.0.to_bytes()
     }
 
-    /// $DeriveNoteType$.
+    /// Note type derivation$.
     ///
-    /// Defined in [Zcash Protocol Spec § TBD: Note Types][notetypes].
+    /// Defined in [Transfer and Burn of Zcash Shielded Assets][notetypes].
     ///
-    /// [notetypes]: https://zips.z.cash/protocol/nu5.pdf#notetypes
+    /// [notetypes]: https://qed-it.github.io/zips/draft-ZIP-0226.html#asset-types
+    ///
+    /// # Panics
+    ///
+    /// Panics if `asset_desc` is empty or greater than `MAX_ASSET_DESCRIPTION_SIZE`.
     #[allow(non_snake_case)]
-    pub fn derive(ik: &IssuerValidatingKey, asset_desc: &str) -> Self {
+    pub fn derive(ik: &IssuanceValidatingKey, asset_desc: &str) -> Self {
         assert!(!asset_desc.is_empty() && asset_desc.len() <= MAX_ASSET_DESCRIPTION_SIZE);
 
         let mut s = vec![];
         s.extend(ik.to_bytes());
         s.extend(asset_desc.as_bytes());
 
-        NoteType(assetID_hasher(s))
+        NoteType(asset_id_hasher(s))
     }
 
     /// Note type for the "native" currency (zec), maintains backward compatibility with Orchard untyped notes.
     pub fn native() -> Self {
-        NoteType(assetID_hasher(VALUE_COMMITMENT_V_BYTES.to_vec()))
+        NoteType(asset_id_hasher(VALUE_COMMITMENT_V_BYTES.to_vec()))
     }
 
     /// The base point used in value commitments.
@@ -85,7 +88,7 @@ pub mod testing {
 
     use proptest::prelude::*;
 
-    use crate::keys::{testing::arb_spending_key, IssuerAuthorizingKey, IssuerValidatingKey};
+    use crate::keys::{testing::arb_spending_key, IssuanceAuthorizingKey, IssuanceValidatingKey};
 
     prop_compose! {
         /// Generate a uniformly distributed note type
@@ -97,8 +100,8 @@ pub mod testing {
             if is_native {
                 NoteType::native()
             } else {
-                let isk = IssuerAuthorizingKey::from(&sk);
-                NoteType::derive(&IssuerValidatingKey::from(&isk), &str)
+                let isk = IssuanceAuthorizingKey::from(&sk);
+                NoteType::derive(&IssuanceValidatingKey::from(&isk), &str)
             }
         }
     }
@@ -117,8 +120,8 @@ pub mod testing {
             sk in arb_spending_key(),
             str in "[A-Za-z]{255}"
         ) -> NoteType {
-            let isk = IssuerAuthorizingKey::from(&sk);
-            NoteType::derive(&IssuerValidatingKey::from(&isk), &str)
+            let isk = IssuanceAuthorizingKey::from(&sk);
+            NoteType::derive(&IssuanceValidatingKey::from(&isk), &str)
         }
     }
 }
diff --git a/tests/zsa.rs b/tests/zsa.rs
index 0335d3358..6dfff6dc0 100644
--- a/tests/zsa.rs
+++ b/tests/zsa.rs
@@ -5,7 +5,7 @@ use incrementalmerkletree::bridgetree::BridgeTree;
 use incrementalmerkletree::{Hashable, Tree};
 use orchard::bundle::Authorized;
 use orchard::issuance::{verify_issue_bundle, IssueBundle, Signed, Unauthorized};
-use orchard::keys::{IssuerAuthorizingKey, IssuerValidatingKey};
+use orchard::keys::{IssuanceAuthorizingKey, IssuanceValidatingKey};
 use orchard::note::{ExtractedNoteCommitment, NoteType};
 use orchard::note_encryption::OrchardDomain;
 use orchard::tree::{MerkleHashOrchard, MerklePath};
@@ -27,8 +27,8 @@ struct Keychain {
     vk: VerifyingKey,
     sk: SpendingKey,
     fvk: FullViewingKey,
-    isk: IssuerAuthorizingKey,
-    ik: IssuerValidatingKey,
+    isk: IssuanceAuthorizingKey,
+    ik: IssuanceValidatingKey,
     recipient: Address,
 }
 
@@ -42,10 +42,10 @@ impl Keychain {
     fn fvk(&self) -> &FullViewingKey {
         &self.fvk
     }
-    fn isk(&self) -> &IssuerAuthorizingKey {
+    fn isk(&self) -> &IssuanceAuthorizingKey {
         &self.isk
     }
-    fn ik(&self) -> &IssuerValidatingKey {
+    fn ik(&self) -> &IssuanceValidatingKey {
         &self.ik
     }
 }
@@ -58,8 +58,8 @@ fn prepare_keys() -> Keychain {
     let fvk = FullViewingKey::from(&sk);
     let recipient = fvk.address_at(0u32, Scope::External);
 
-    let isk = IssuerAuthorizingKey::from(&sk);
-    let ik = IssuerValidatingKey::from(&isk);
+    let isk = IssuanceAuthorizingKey::from(&sk);
+    let ik = IssuanceValidatingKey::from(&isk);
     Keychain {
         pk,
         vk,
@@ -74,7 +74,7 @@ fn prepare_keys() -> Keychain {
 fn sign_issue_bundle(
     unauthorized: IssueBundle<Unauthorized>,
     mut rng: OsRng,
-    isk: IssuerAuthorizingKey,
+    isk: IssuanceAuthorizingKey,
 ) -> IssueBundle<Signed> {
     let sighash = unauthorized.commitment().into();
     let proven = unauthorized.prepare(sighash);

From 355b5691ea5faf70c7a4a07de0cafa5474a14c30 Mon Sep 17 00:00:00 2001
From: Paul <3682187+PaulLaux@users.noreply.github.com>
Date: Thu, 27 Oct 2022 19:23:15 +0300
Subject: [PATCH 10/17] Review fixes2 (#24)

* rename 2 note_type -> asset as per  https://github.com/zcash/orchard/pull/356#discussion_r967636009

* added a dedicated type for "IssuanceAuth"

* disabled codecov github action due to bad behavior.

* extracted "is_asset_desc_of_valid_size()" into asset_id.rs
---
 .github/workflows/ci.yml               |  51 +++++-----
 benches/circuit.rs                     |   4 +-
 benches/note_decryption.rs             |   6 +-
 src/action.rs                          |  10 +-
 src/builder.rs                         |  75 +++++++-------
 src/bundle.rs                          |   4 +-
 src/bundle/commitments.rs              |   2 +-
 src/circuit.rs                         |   8 +-
 src/constants/fixed_bases.rs           |   2 +-
 src/issuance.rs                        | 136 ++++++++++++-------------
 src/keys.rs                            |  18 ++--
 src/note.rs                            |  39 ++++---
 src/note/{note_type.rs => asset_id.rs} |  45 ++++----
 src/note/commitment.rs                 |   8 +-
 src/note_encryption.rs                 |  42 ++++----
 src/test_vectors/note_encryption.rs    |  42 ++++----
 src/value.rs                           |  26 ++---
 tests/builder.rs                       |   6 +-
 tests/zsa.rs                           |  40 ++++----
 19 files changed, 288 insertions(+), 276 deletions(-)
 rename src/note/{note_type.rs => asset_id.rs} (73%)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2a52477ab..e7b900029 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -55,31 +55,32 @@ jobs:
       - name: Test Orchard book
         run: mdbook test book/
 
-  codecov:
-    name: Code coverage
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      # Use stable for this to ensure that cargo-tarpaulin can be built.
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-      - name: Install cargo-tarpaulin
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-tarpaulin
-      - name: Generate coverage report
-        uses: actions-rs/cargo@v1
-        with:
-          command: tarpaulin
-          args: --all-features --timeout 1200 --out Xml
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v1
-        with:
-          token: ${{secrets.CODECOV_TOKEN}}
+#  disabled due to performance issues:
+#  codecov:
+#    name: Code coverage
+#    runs-on: ubuntu-latest
+#
+#    steps:
+#      - uses: actions/checkout@v2
+#      # Use stable for this to ensure that cargo-tarpaulin can be built.
+#      - uses: actions-rs/toolchain@v1
+#        with:
+#          toolchain: stable
+#          override: true
+#      - name: Install cargo-tarpaulin
+#        uses: actions-rs/cargo@v1
+#        with:
+#          command: install
+#          args: cargo-tarpaulin
+#      - name: Generate coverage report
+#        uses: actions-rs/cargo@v1
+#        with:
+#          command: tarpaulin
+#          args: --all-features --timeout 1200 --out Xml
+#      - name: Upload coverage to Codecov
+#        uses: codecov/codecov-action@v1
+#        with:
+#          token: ${{secrets.CODECOV_TOKEN}}
 
   doc-links:
     name: Intra-doc links
diff --git a/benches/circuit.rs b/benches/circuit.rs
index 6400513e2..e9bab616c 100644
--- a/benches/circuit.rs
+++ b/benches/circuit.rs
@@ -6,7 +6,7 @@ use criterion::{BenchmarkId, Criterion};
 #[cfg(unix)]
 use pprof::criterion::{Output, PProfProfiler};
 
-use orchard::note::NoteType;
+use orchard::note::AssetId;
 use orchard::{
     builder::Builder,
     bundle::Flags,
@@ -37,7 +37,7 @@ fn criterion_benchmark(c: &mut Criterion) {
                     None,
                     recipient,
                     NoteValue::from_raw(10),
-                    NoteType::native(),
+                    AssetId::native(),
                     None,
                 )
                 .unwrap();
diff --git a/benches/note_decryption.rs b/benches/note_decryption.rs
index 28e02de61..1417a2b6c 100644
--- a/benches/note_decryption.rs
+++ b/benches/note_decryption.rs
@@ -4,7 +4,7 @@ use orchard::{
     bundle::Flags,
     circuit::ProvingKey,
     keys::{FullViewingKey, PreparedIncomingViewingKey, Scope, SpendingKey},
-    note::NoteType,
+    note::AssetId,
     note_encryption::{CompactAction, OrchardDomain},
     value::NoteValue,
     Anchor, Bundle,
@@ -57,7 +57,7 @@ fn bench_note_decryption(c: &mut Criterion) {
                 None,
                 recipient,
                 NoteValue::from_raw(10),
-                NoteType::native(),
+                AssetId::native(),
                 None,
             )
             .unwrap();
@@ -66,7 +66,7 @@ fn bench_note_decryption(c: &mut Criterion) {
                 None,
                 recipient,
                 NoteValue::from_raw(10),
-                NoteType::native(),
+                AssetId::native(),
                 None,
             )
             .unwrap();
diff --git a/src/action.rs b/src/action.rs
index b1eda4819..94fe4f3f4 100644
--- a/src/action.rs
+++ b/src/action.rs
@@ -126,7 +126,7 @@ pub(crate) mod testing {
 
     use proptest::prelude::*;
 
-    use crate::note::note_type::testing::arb_note_type;
+    use crate::note::asset_id::testing::arb_asset_id;
     use crate::{
         note::{
             commitment::ExtractedNoteCommitment, nullifier::testing::arb_nullifier,
@@ -147,13 +147,13 @@ pub(crate) mod testing {
             nf in arb_nullifier(),
             rk in arb_spendauth_verification_key(),
             note in arb_note(output_value),
-            note_type in arb_note_type()
+            asset in arb_asset_id()
         ) -> Action<()> {
             let cmx = ExtractedNoteCommitment::from(note.commitment());
             let cv_net = ValueCommitment::derive(
                 spend_value - output_value,
                 ValueCommitTrapdoor::zero(),
-                note_type
+                asset
             );
             // FIXME: make a real one from the note.
             let encrypted_note = TransmittedNoteCiphertext {
@@ -180,13 +180,13 @@ pub(crate) mod testing {
             note in arb_note(output_value),
             rng_seed in prop::array::uniform32(prop::num::u8::ANY),
             fake_sighash in prop::array::uniform32(prop::num::u8::ANY),
-            note_type in arb_note_type()
+            asset in arb_asset_id()
         ) -> Action<redpallas::Signature<SpendAuth>> {
             let cmx = ExtractedNoteCommitment::from(note.commitment());
             let cv_net = ValueCommitment::derive(
                 spend_value - output_value,
                 ValueCommitTrapdoor::zero(),
-                note_type
+                asset
             );
 
             // FIXME: make a real one from the note.
diff --git a/src/builder.rs b/src/builder.rs
index 526fe471e..5c6147022 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -9,7 +9,7 @@ use nonempty::NonEmpty;
 use pasta_curves::pallas;
 use rand::{prelude::SliceRandom, CryptoRng, RngCore};
 
-use crate::note::NoteType;
+use crate::note::AssetId;
 use crate::{
     action::Action,
     address::Address,
@@ -94,8 +94,8 @@ impl SpendInfo {
     /// Defined in [Zcash Protocol Spec § 4.8.3: Dummy Notes (Orchard)][orcharddummynotes].
     ///
     /// [orcharddummynotes]: https://zips.z.cash/protocol/nu5.pdf#orcharddummynotes
-    fn dummy(note_type: NoteType, rng: &mut impl RngCore) -> Self {
-        let (sk, fvk, note) = Note::dummy(rng, None, note_type);
+    fn dummy(asset: AssetId, rng: &mut impl RngCore) -> Self {
+        let (sk, fvk, note) = Note::dummy(rng, None, asset);
         let merkle_path = MerklePath::dummy(rng);
 
         SpendInfo {
@@ -110,7 +110,7 @@ impl SpendInfo {
         }
     }
 
-    /// Duplicates the spend info and set the split flag to `true`.
+    /// Return a copy of this note with the split flag set to `true`.
     fn create_split_spend(&self) -> Self {
         let mut split_spend = SpendInfo::new(self.fvk.clone(), self.note, self.merkle_path.clone())
             .expect("The spend info is valid");
@@ -125,7 +125,7 @@ struct RecipientInfo {
     ovk: Option<OutgoingViewingKey>,
     recipient: Address,
     value: NoteValue,
-    note_type: NoteType,
+    asset: AssetId,
     memo: Option<[u8; 512]>,
 }
 
@@ -133,7 +133,7 @@ impl RecipientInfo {
     /// Defined in [Zcash Protocol Spec § 4.8.3: Dummy Notes (Orchard)][orcharddummynotes].
     ///
     /// [orcharddummynotes]: https://zips.z.cash/protocol/nu5.pdf#orcharddummynotes
-    fn dummy(rng: &mut impl RngCore, note_type: NoteType) -> Self {
+    fn dummy(rng: &mut impl RngCore, asset: AssetId) -> Self {
         let fvk: FullViewingKey = (&SpendingKey::random(rng)).into();
         let recipient = fvk.address_at(0u32, Scope::External);
 
@@ -141,7 +141,7 @@ impl RecipientInfo {
             ovk: None,
             recipient,
             value: NoteValue::zero(),
-            note_type,
+            asset,
             memo: None,
         }
     }
@@ -165,13 +165,13 @@ impl ActionInfo {
     }
 
     /// Returns the value sum for this action.
-    /// Split notes does not contribute to the value sum.
+    /// Split notes do not contribute to the value sum.
     fn value_sum(&self) -> ValueSum {
-        let spent_value = self
-            .spend
-            .split_flag
-            .then(NoteValue::zero)
-            .unwrap_or_else(|| self.spend.note.value());
+        let spent_value = if self.spend.split_flag {
+            NoteValue::zero()
+        } else {
+            self.spend.note.value()
+        };
 
         spent_value - self.output.value
     }
@@ -181,27 +181,30 @@ impl ActionInfo {
     /// Defined in [Zcash Protocol Spec § 4.7.3: Sending Notes (Orchard)][orchardsend].
     ///
     /// [orchardsend]: https://zips.z.cash/protocol/nu5.pdf#orchardsend
+    ///
+    /// # Panics
+    ///
+    /// Panics if the asset types of the spent and output notes do not match.
     fn build(self, mut rng: impl RngCore) -> (Action<SigningMetadata>, Circuit) {
         assert_eq!(
-            self.output.note_type,
-            self.spend.note.note_type(),
+            self.spend.note.asset(),
+            self.output.asset,
             "spend and recipient note types must be equal"
         );
 
         let v_net = self.value_sum();
-        let note_type = self.output.note_type;
-        let cv_net = ValueCommitment::derive(v_net, self.rcv, note_type);
+        let asset = self.output.asset;
+        let cv_net = ValueCommitment::derive(v_net, self.rcv, asset);
 
         let nf_old = self.spend.note.nullifier(&self.spend.fvk);
         let ak: SpendValidatingKey = self.spend.fvk.clone().into();
         let alpha = pallas::Scalar::random(&mut rng);
         let rk = ak.randomize(&alpha);
-        let note_type = self.spend.note.note_type();
 
         let note = Note::new(
             self.output.recipient,
             self.output.value,
-            note_type,
+            self.output.asset,
             nf_old,
             &mut rng,
         );
@@ -316,7 +319,7 @@ impl Builder {
         ovk: Option<OutgoingViewingKey>,
         recipient: Address,
         value: NoteValue,
-        note_type: NoteType,
+        asset: AssetId,
         memo: Option<[u8; 512]>,
     ) -> Result<(), &'static str> {
         if !self.flags.outputs_enabled() {
@@ -327,7 +330,7 @@ impl Builder {
             ovk,
             recipient,
             value,
-            note_type,
+            asset,
             memo,
         });
 
@@ -370,7 +373,7 @@ impl Builder {
         let mut pre_actions: Vec<_> = Vec::new();
 
         // Pair up the spends and recipients, extending with dummy values as necessary.
-        for (note_type, (mut spends, mut recipients)) in
+        for (asset, (mut spends, mut recipients)) in
             partition_by_asset(&self.spends, &self.recipients)
         {
             let num_spends = spends.len();
@@ -384,16 +387,16 @@ impl Builder {
             // TODO: uncomment once the circuit is ready.
             // use the first spend to create split spend(s) or create a dummy if empty.
             // let dummy_spend = spends.first().map_or_else(
-            //     || SpendInfo::dummy(note_type, &mut rng),
+            //     || SpendInfo::dummy(asset, &mut rng),
             //     |s| s.create_split_spend(),
             // );
-            let dummy_spend = SpendInfo::dummy(note_type, &mut rng);
+            let dummy_spend = SpendInfo::dummy(asset, &mut rng);
 
             // Extend the spends and recipients with dummy values.
             spends.extend(iter::repeat_with(|| dummy_spend.clone()).take(num_actions - num_spends));
 
             recipients.extend(
-                iter::repeat_with(|| RecipientInfo::dummy(&mut rng, note_type))
+                iter::repeat_with(|| RecipientInfo::dummy(&mut rng, asset))
                     .take(num_actions - num_recipients),
             );
 
@@ -443,7 +446,7 @@ impl Builder {
             - ValueCommitment::derive(
                 value_balance,
                 ValueCommitTrapdoor::zero(),
-                NoteType::native(),
+                AssetId::native(),
             ))
         .into_bvk();
         assert_eq!(redpallas::VerificationKey::from(&bsk), bvk);
@@ -465,18 +468,18 @@ impl Builder {
 fn partition_by_asset(
     spends: &[SpendInfo],
     recipients: &[RecipientInfo],
-) -> HashMap<NoteType, (Vec<SpendInfo>, Vec<RecipientInfo>)> {
+) -> HashMap<AssetId, (Vec<SpendInfo>, Vec<RecipientInfo>)> {
     let mut hm = HashMap::new();
 
     for s in spends {
-        hm.entry(s.note.note_type())
+        hm.entry(s.note.asset())
             .or_insert((vec![], vec![]))
             .0
             .push(s.clone());
     }
 
     for r in recipients {
-        hm.entry(r.note_type)
+        hm.entry(r.asset)
             .or_insert((vec![], vec![]))
             .1
             .push(r.clone())
@@ -749,7 +752,7 @@ pub mod testing {
     use proptest::collection::vec;
     use proptest::prelude::*;
 
-    use crate::note::NoteType;
+    use crate::note::AssetId;
     use crate::{
         address::testing::arb_address,
         bundle::{Authorized, Bundle, Flags},
@@ -777,7 +780,7 @@ pub mod testing {
         sk: SpendingKey,
         anchor: Anchor,
         notes: Vec<(Note, MerklePath)>,
-        recipient_amounts: Vec<(Address, NoteValue, NoteType)>,
+        recipient_amounts: Vec<(Address, NoteValue, AssetId)>,
     }
 
     impl<R: RngCore + CryptoRng> ArbitraryBundleInputs<R> {
@@ -791,12 +794,12 @@ pub mod testing {
                 builder.add_spend(fvk.clone(), note, path).unwrap();
             }
 
-            for (addr, value, note_type) in self.recipient_amounts.into_iter() {
+            for (addr, value, asset) in self.recipient_amounts.into_iter() {
                 let scope = fvk.scope_for_address(&addr).unwrap();
                 let ovk = fvk.to_ovk(scope);
 
                 builder
-                    .add_recipient(Some(ovk.clone()), addr, value, note_type, None)
+                    .add_recipient(Some(ovk.clone()), addr, value, asset, None)
                     .unwrap();
             }
 
@@ -831,7 +834,7 @@ pub mod testing {
                 arb_address().prop_flat_map(move |a| {
                     arb_positive_note_value(MAX_NOTE_VALUE / n_recipients as u64)
                         .prop_map(move |v| {
-                            (a,v, NoteType::native())
+                            (a,v, AssetId::native())
                         })
                 }),
                 n_recipients as usize,
@@ -882,7 +885,7 @@ mod tests {
     use rand::rngs::OsRng;
 
     use super::Builder;
-    use crate::note::NoteType;
+    use crate::note::AssetId;
     use crate::{
         bundle::{Authorized, Bundle, Flags},
         circuit::ProvingKey,
@@ -911,7 +914,7 @@ mod tests {
                 None,
                 recipient,
                 NoteValue::from_raw(5000),
-                NoteType::native(),
+                AssetId::native(),
                 None,
             )
             .unwrap();
diff --git a/src/bundle.rs b/src/bundle.rs
index 4f4e1cb3f..6f7e0bce9 100644
--- a/src/bundle.rs
+++ b/src/bundle.rs
@@ -12,7 +12,7 @@ use memuse::DynamicUsage;
 use nonempty::NonEmpty;
 use zcash_note_encryption::{try_note_decryption, try_output_recovery_with_ovk};
 
-use crate::note::NoteType;
+use crate::note::AssetId;
 use crate::{
     action::Action,
     address::Address,
@@ -385,7 +385,7 @@ impl<T: Authorization, V: Copy + Into<i64>> Bundle<T, V> {
             - ValueCommitment::derive(
                 ValueSum::from_raw(self.value_balance.into()),
                 ValueCommitTrapdoor::zero(),
-                NoteType::native(),
+                AssetId::native(),
             ))
         .into_bvk()
     }
diff --git a/src/bundle/commitments.rs b/src/bundle/commitments.rs
index 40808b57f..285ba31f7 100644
--- a/src/bundle/commitments.rs
+++ b/src/bundle/commitments.rs
@@ -102,7 +102,7 @@ pub(crate) fn hash_issue_bundle_txid_data<A: IssueAuth>(bundle: &IssueBundle<A>)
         for note in action.notes().iter() {
             h.update(&note.recipient().to_raw_address_bytes());
             h.update(&note.value().to_bytes());
-            h.update(&note.note_type().to_bytes());
+            h.update(&note.asset().to_bytes());
             h.update(&note.rho().to_bytes());
             h.update(note.rseed().as_bytes());
         }
diff --git a/src/circuit.rs b/src/circuit.rs
index 97d5efda2..7797f563e 100644
--- a/src/circuit.rs
+++ b/src/circuit.rs
@@ -968,7 +968,7 @@ mod tests {
     use rand::{rngs::OsRng, RngCore};
 
     use super::{Circuit, Instance, Proof, ProvingKey, VerifyingKey, K};
-    use crate::note::NoteType;
+    use crate::note::AssetId;
     use crate::{
         keys::SpendValidatingKey,
         note::Note,
@@ -977,7 +977,7 @@ mod tests {
     };
 
     fn generate_circuit_instance<R: RngCore>(mut rng: R) -> (Circuit, Instance) {
-        let (_, fvk, spent_note) = Note::dummy(&mut rng, None, NoteType::native());
+        let (_, fvk, spent_note) = Note::dummy(&mut rng, None, AssetId::native());
 
         let sender_address = spent_note.recipient();
         let nk = *fvk.nk();
@@ -987,12 +987,12 @@ mod tests {
         let alpha = pallas::Scalar::random(&mut rng);
         let rk = ak.randomize(&alpha);
 
-        let (_, _, output_note) = Note::dummy(&mut rng, Some(nf_old), NoteType::native());
+        let (_, _, output_note) = Note::dummy(&mut rng, Some(nf_old), AssetId::native());
         let cmx = output_note.commitment().into();
 
         let value = spent_note.value() - output_note.value();
         let rcv = ValueCommitTrapdoor::random(&mut rng);
-        let cv_net = ValueCommitment::derive(value, rcv, NoteType::native());
+        let cv_net = ValueCommitment::derive(value, rcv, AssetId::native());
 
         let path = MerklePath::dummy(&mut rng);
         let anchor = path.root(spent_note.commitment().into());
diff --git a/src/constants/fixed_bases.rs b/src/constants/fixed_bases.rs
index d9c92edd3..4b5d1518e 100644
--- a/src/constants/fixed_bases.rs
+++ b/src/constants/fixed_bases.rs
@@ -22,7 +22,7 @@ pub const ORCHARD_PERSONALIZATION: &str = "z.cash:Orchard";
 pub const VALUE_COMMITMENT_PERSONALIZATION: &str = "z.cash:Orchard-cv";
 
 /// SWU hash-to-curve personalization for the note type generator
-// pub const NOTE_TYPE_PERSONALIZATION: &str = "z.cash:Orchard-NoteType";
+// pub const ASSET_ID_PERSONALIZATION: &str = "z.cash:Orchard-NoteType";
 
 /// SWU hash-to-curve value for the value commitment generator
 pub const VALUE_COMMITMENT_V_BYTES: [u8; 1] = *b"v";
diff --git a/src/issuance.rs b/src/issuance.rs
index e8027e67f..4fbcd8421 100644
--- a/src/issuance.rs
+++ b/src/issuance.rs
@@ -12,8 +12,8 @@ use crate::issuance::Error::{
     IssueBundleInvalidSignature, WrongAssetDescSize,
 };
 use crate::keys::{IssuanceAuthorizingKey, IssuanceValidatingKey};
-use crate::note::note_type::MAX_ASSET_DESCRIPTION_SIZE;
-use crate::note::{NoteType, Nullifier};
+use crate::note::asset_id::is_asset_desc_of_valid_size;
+use crate::note::{AssetId, Nullifier};
 use crate::value::NoteValue;
 use crate::{
     primitives::redpallas::{self, SpendAuth},
@@ -81,24 +81,24 @@ impl IssueAction {
         self.finalize
     }
 
-    /// Return the `NoteType` if the provided `ik` is used to derive the `note_type` for **all** internal notes.
-    fn are_note_types_derived_correctly(
+    /// Return the `AssetId` if the provided `ik` is used to derive the `asset_id` for **all** internal notes.
+    fn are_note_asset_ids_derived_correctly(
         &self,
         ik: &IssuanceValidatingKey,
-    ) -> Result<NoteType, Error> {
+    ) -> Result<AssetId, Error> {
         match self
             .notes
             .iter()
-            .try_fold(self.notes().head.note_type(), |note_type, &note| {
+            .try_fold(self.notes().head.asset(), |asset, &note| {
                 // Fail if not all note types are equal
-                note.note_type()
-                    .eq(&note_type)
-                    .then(|| note_type)
+                note.asset()
+                    .eq(&asset)
+                    .then(|| asset)
                     .ok_or(IssueActionIncorrectNoteType)
             }) {
-            Ok(note_type) => note_type // check that the note_type was properly derived.
-                .eq(&NoteType::derive(ik, &self.asset_desc))
-                .then(|| note_type)
+            Ok(asset) => asset // check that the asset was properly derived.
+                .eq(&AssetId::derive(ik, &self.asset_desc))
+                .then(|| asset)
                 .ok_or(IssueBundleIkMismatchNoteType),
             Err(e) => Err(e),
         }
@@ -162,12 +162,12 @@ impl<T: IssueAuth> IssueBundle<T> {
         self.actions.iter().find(|a| a.asset_desc.eq(&asset_desc))
     }
 
-    /// Find an action by `note_type` for a given `IssueBundle`.
-    pub fn get_action_by_type(&self, note_type: NoteType) -> Option<&IssueAction> {
+    /// Find an action by `asset` for a given `IssueBundle`.
+    pub fn get_action_by_type(&self, asset: AssetId) -> Option<&IssueAction> {
         let action = self
             .actions
             .iter()
-            .find(|a| NoteType::derive(&self.ik, &a.asset_desc).eq(&note_type));
+            .find(|a| AssetId::derive(&self.ik, &a.asset_desc).eq(&asset));
         action
     }
 
@@ -202,17 +202,17 @@ impl IssueBundle<Unauthorized> {
         value: NoteValue,
         finalize: bool,
         mut rng: impl RngCore,
-    ) -> Result<NoteType, Error> {
-        if !is_asset_desc_valid(&asset_desc) {
+    ) -> Result<AssetId, Error> {
+        if !is_asset_desc_of_valid_size(&asset_desc) {
             return Err(WrongAssetDescSize);
         }
 
-        let note_type = NoteType::derive(&self.ik, &asset_desc);
+        let asset = AssetId::derive(&self.ik, &asset_desc);
 
         let note = Note::new(
             recipient,
             value,
-            note_type,
+            asset,
             Nullifier::dummy(&mut rng),
             &mut rng,
         );
@@ -238,7 +238,7 @@ impl IssueBundle<Unauthorized> {
             }
         }
 
-        Ok(note_type)
+        Ok(asset)
     }
 
     /// Finalizes a given `IssueAction`
@@ -247,7 +247,7 @@ impl IssueBundle<Unauthorized> {
     ///
     /// Panics if `asset_desc` is empty or longer than 512 bytes.
     pub fn finalize_action(&mut self, asset_desc: String) -> Result<(), Error> {
-        if !is_asset_desc_valid(&asset_desc) {
+        if !is_asset_desc_of_valid_size(&asset_desc) {
             return Err(WrongAssetDescSize);
         }
 
@@ -279,7 +279,7 @@ impl IssueBundle<Unauthorized> {
 
 impl IssueBundle<Prepared> {
     /// Sign the `IssueBundle`.
-    /// The call makes sure that the provided `isk` matches the `ik` and the driven `note_type` for each note in the bundle.
+    /// The call makes sure that the provided `isk` matches the `ik` and the driven `asset` for each note in the bundle.
     pub fn sign<R: RngCore + CryptoRng>(
         self,
         mut rng: R,
@@ -287,10 +287,10 @@ impl IssueBundle<Prepared> {
     ) -> Result<IssueBundle<Signed>, Error> {
         let expected_ik: IssuanceValidatingKey = (isk).into();
 
-        // Make sure the `expected_ik` matches the note_type for all notes.
+        // Make sure the `expected_ik` matches the `asset` for all notes.
         self.actions.iter().try_for_each(|action| {
             action
-                .are_note_types_derived_correctly(&expected_ik)
+                .are_note_asset_ids_derived_correctly(&expected_ik)
                 .map(|_| ()) // Transform Result<NoteType,Error> into Result<(),Error)>.
         })?;
 
@@ -332,14 +332,10 @@ impl IssueBundle<Signed> {
     }
 }
 
-fn is_asset_desc_valid(asset_desc: &str) -> bool {
-    !asset_desc.is_empty() && asset_desc.bytes().len() <= MAX_ASSET_DESCRIPTION_SIZE
-}
-
 /// Validation for Orchard IssueBundles
 ///
 /// A set of previously finalized asset types must be provided.
-/// In case of success, the `Result` will contain a set of the provided **and** the newly finalized `NoteType`s
+/// In case of success, `finalized` will contain a set of the provided **and** the newly finalized `NoteType`s
 ///
 /// The following checks are performed:
 /// * For the `IssueBundle`:
@@ -348,43 +344,46 @@ fn is_asset_desc_valid(asset_desc: &str) -> bool {
 ///     * Asset description size is collect.
 ///     * `NoteType` for the `IssueAction` has not been previously finalized.
 /// * For each `Note` inside an `IssueAction`:
-///     * All notes have the same, correct `NoteType`
-pub fn verify_issue_bundle<'a>(
+///     * All notes have the same, correct `NoteType`.
+pub fn verify_issue_bundle(
     bundle: &IssueBundle<Signed>,
     sighash: [u8; 32],
-    previously_finalized: &'a mut HashSet<NoteType>, // The current note_type finalization set.
-) -> Result<&'a mut HashSet<NoteType>, Error> {
+    finalized: &mut HashSet<AssetId>, // The current finalization set.
+) -> Result<(), Error> {
     if let Err(e) = bundle.ik.verify(&sighash, &bundle.authorization.signature) {
         return Err(IssueBundleInvalidSignature(e));
     };
 
+    let currently_finalized: &mut HashSet<AssetId> = &mut HashSet::new();
+
     // Any IssueAction could have just one properly derived NoteType.
-    bundle
+    let res = bundle
         .actions()
         .iter()
-        .try_fold(previously_finalized, |acc, action| {
-            if !is_asset_desc_valid(action.asset_desc()) {
+        .try_fold(currently_finalized, |acc, action| {
+            if !is_asset_desc_of_valid_size(action.asset_desc()) {
                 return Err(WrongAssetDescSize);
             }
 
             // Fail if any note in the IssueAction has incorrect note type.
-            let note_type = action.are_note_types_derived_correctly(bundle.ik())?;
+            let asset = action.are_note_asset_ids_derived_correctly(bundle.ik())?;
 
-            // Fail if the current note_type was previously finalized.
-            if acc.contains(&note_type) {
-                return Err(IssueActionPreviouslyFinalizedNoteType(note_type));
+            // Fail if the current asset was previously finalized.
+            if finalized.contains(&asset) || acc.contains(&asset) {
+                return Err(IssueActionPreviouslyFinalizedNoteType(asset));
             }
 
             // Add to finalization set, if needed.
             if action.is_finalized() {
-                acc.insert(note_type);
+                acc.insert(asset);
             }
 
-            // Proceed with the new accumulated note_type finalization set.
+            // Proceed with the new asset finalization set.
             Ok(acc)
-        })
+        })?;
 
-    // The iterator will return the new finalization set or will fail.
+    finalized.extend(res.iter());
+    Ok(())
 }
 
 /// Errors produced during the issuance process
@@ -405,7 +404,7 @@ pub enum Error {
     /// Invalid signature.
     IssueBundleInvalidSignature(reddsa::Error),
     /// The provided `NoteType` has been previously finalized.
-    IssueActionPreviouslyFinalizedNoteType(NoteType),
+    IssueActionPreviouslyFinalizedNoteType(AssetId),
 }
 
 impl std::error::Error for Error {}
@@ -456,7 +455,7 @@ mod tests {
     use crate::keys::{
         FullViewingKey, IssuanceAuthorizingKey, IssuanceValidatingKey, Scope, SpendingKey,
     };
-    use crate::note::{NoteType, Nullifier};
+    use crate::note::{AssetId, Nullifier};
     use crate::value::NoteValue;
     use crate::{Address, Note};
     use nonempty::NonEmpty;
@@ -522,37 +521,37 @@ mod tests {
             WrongAssetDescSize
         );
 
-        let note_type = bundle
+        let asset = bundle
             .add_recipient(str.clone(), recipient, NoteValue::from_raw(5), false, rng)
             .unwrap();
 
-        let another_note_type = bundle
+        let another_asset = bundle
             .add_recipient(str, recipient, NoteValue::from_raw(10), false, rng)
             .unwrap();
-        assert_eq!(note_type, another_note_type);
+        assert_eq!(asset, another_asset);
 
-        let third_note_type = bundle
+        let third_asset = bundle
             .add_recipient(str2.clone(), recipient, NoteValue::from_raw(15), false, rng)
             .unwrap();
-        assert_ne!(note_type, third_note_type);
+        assert_ne!(asset, third_asset);
 
         let actions = bundle.actions();
         assert_eq!(actions.len(), 2);
 
-        let action = bundle.get_action_by_type(note_type).unwrap();
+        let action = bundle.get_action_by_type(asset).unwrap();
         assert_eq!(action.notes.len(), 2);
         assert_eq!(action.notes.first().value().inner(), 5);
-        assert_eq!(action.notes.first().note_type(), note_type);
+        assert_eq!(action.notes.first().asset(), asset);
         assert_eq!(action.notes.first().recipient(), recipient);
 
         assert_eq!(action.notes.tail().first().unwrap().value().inner(), 10);
-        assert_eq!(action.notes.tail().first().unwrap().note_type(), note_type);
+        assert_eq!(action.notes.tail().first().unwrap().asset(), asset);
         assert_eq!(action.notes.tail().first().unwrap().recipient(), recipient);
 
         let action2 = bundle.get_action(str2).unwrap();
         assert_eq!(action2.notes.len(), 1);
         assert_eq!(action2.notes().first().value().inner(), 15);
-        assert_eq!(action2.notes().first().note_type(), third_note_type);
+        assert_eq!(action2.notes().first().asset(), third_asset);
     }
 
     #[test]
@@ -700,7 +699,7 @@ mod tests {
     }
 
     #[test]
-    fn issue_bundle_incorrect_note_type_for_signature() {
+    fn issue_bundle_incorrect_asset_for_signature() {
         let (mut rng, isk, ik, recipient, _) = setup_params();
 
         let mut bundle = IssueBundle::new(ik);
@@ -720,7 +719,7 @@ mod tests {
         let note = Note::new(
             recipient,
             NoteValue::from_raw(5),
-            NoteType::derive(bundle.ik(), "Poisoned pill"),
+            AssetId::derive(bundle.ik(), "Poisoned pill"),
             Nullifier::dummy(&mut rng),
             &mut rng,
         );
@@ -760,8 +759,9 @@ mod tests {
 
         let prev_finalized = &mut HashSet::new();
 
-        let finalized = verify_issue_bundle(&signed, sighash, prev_finalized);
-        assert!(finalized.unwrap().is_empty());
+        let res = verify_issue_bundle(&signed, sighash, prev_finalized);
+        assert!(res.is_ok());
+        assert!(prev_finalized.is_empty());
     }
 
     #[test]
@@ -784,12 +784,12 @@ mod tests {
 
         let prev_finalized = &mut HashSet::new();
 
-        let finalized = verify_issue_bundle(&signed, sighash, prev_finalized).unwrap();
-        assert!(finalized.contains(&NoteType::derive(
-            &ik,
-            &String::from("verify_with_finalize")
-        )));
-        assert_eq!(finalized.len(), 1);
+        let res = verify_issue_bundle(&signed, sighash, prev_finalized);
+        assert!(res.is_ok());
+        assert!(
+            prev_finalized.contains(&AssetId::derive(&ik, &String::from("verify_with_finalize")))
+        );
+        assert_eq!(prev_finalized.len(), 1);
     }
 
     #[test]
@@ -811,7 +811,7 @@ mod tests {
         let signed = bundle.prepare(sighash).sign(rng, &isk).unwrap();
         let prev_finalized = &mut HashSet::new();
 
-        let final_type = NoteType::derive(&ik, &String::from("already final"));
+        let final_type = AssetId::derive(&ik, &String::from("already final"));
 
         prev_finalized.insert(final_type);
 
@@ -911,7 +911,7 @@ mod tests {
         let note = Note::new(
             recipient,
             NoteValue::from_raw(5),
-            NoteType::derive(signed.ik(), "Poisoned pill"),
+            AssetId::derive(signed.ik(), "Poisoned pill"),
             Nullifier::dummy(&mut rng),
             &mut rng,
         );
@@ -958,7 +958,7 @@ mod tests {
         let note = Note::new(
             recipient,
             NoteValue::from_raw(55),
-            NoteType::derive(&incorrect_ik, asset_description),
+            AssetId::derive(&incorrect_ik, asset_description),
             Nullifier::dummy(&mut rng),
             &mut rng,
         );
diff --git a/src/keys.rs b/src/keys.rs
index d10e6e24e..65d464147 100644
--- a/src/keys.rs
+++ b/src/keys.rs
@@ -194,6 +194,9 @@ impl SpendValidatingKey {
     }
 }
 
+/// We currently use `SpendAuth` as the `IssuanceAuth`.
+type IssuanceAuth = SpendAuth;
+
 /// An issuance authorizing key, used to create issuance authorization signatures.
 /// This type enforces that the corresponding public point (ik^ℙ) has ỹ = 0.
 ///
@@ -202,7 +205,7 @@ impl SpendValidatingKey {
 ///
 /// [IssuanceZSA]: https://qed-it.github.io/zips/draft-ZIP-0227.html#asset-identifier-generation
 #[derive(Clone, Debug)]
-pub struct IssuanceAuthorizingKey(redpallas::SigningKey<SpendAuth>);
+pub struct IssuanceAuthorizingKey(redpallas::SigningKey<IssuanceAuth>);
 
 impl IssuanceAuthorizingKey {
     /// Derives isk from sk. Internal use only, does not enforce all constraints.
@@ -215,7 +218,7 @@ impl IssuanceAuthorizingKey {
         &self,
         rng: &mut (impl RngCore + CryptoRng),
         msg: &[u8],
-    ) -> redpallas::Signature<SpendAuth> {
+    ) -> redpallas::Signature<IssuanceAuth> {
         self.0.sign(rng, msg)
     }
 }
@@ -223,7 +226,7 @@ impl IssuanceAuthorizingKey {
 impl From<&SpendingKey> for IssuanceAuthorizingKey {
     fn from(sk: &SpendingKey) -> Self {
         let isk = Self::derive_inner(sk);
-        // IssuanceSigningKey cannot be constructed such that this assertion would fail.
+        // IssuanceAuthorizingKey cannot be constructed such that this assertion would fail.
         assert!(!bool::from(isk.is_zero()));
         let ret = IssuanceAuthorizingKey(isk.to_repr().try_into().unwrap());
         // If the last bit of repr_P(ik) is 1, negate isk.
@@ -243,7 +246,8 @@ impl From<&SpendingKey> for IssuanceAuthorizingKey {
 ///
 /// [IssuanceZSA]: https://qed-it.github.io/zips/draft-ZIP-0227.html#asset-identifier-generation
 #[derive(Debug, Clone, PartialOrd, Ord)]
-pub struct IssuanceValidatingKey(redpallas::VerificationKey<SpendAuth>);
+pub struct IssuanceValidatingKey(VerificationKey<IssuanceAuth>);
+
 impl From<&IssuanceAuthorizingKey> for IssuanceValidatingKey {
     fn from(isk: &IssuanceAuthorizingKey) -> Self {
         IssuanceValidatingKey((&isk.0).into())
@@ -284,7 +288,7 @@ impl IssuanceValidatingKey {
     pub fn verify(
         &self,
         msg: &[u8],
-        signature: &redpallas::Signature<SpendAuth>,
+        signature: &redpallas::Signature<IssuanceAuth>,
     ) -> Result<(), reddsa::Error> {
         self.0.verify(msg, signature)
     }
@@ -1120,7 +1124,7 @@ mod tests {
         testing::{arb_diversifier_index, arb_diversifier_key, arb_esk, arb_spending_key},
         *,
     };
-    use crate::note::NoteType;
+    use crate::note::AssetId;
     use crate::{
         note::{ExtractedNoteCommitment, Nullifier, RandomSeed},
         value::NoteValue,
@@ -1212,7 +1216,7 @@ mod tests {
             let note = Note::from_parts(
                 addr,
                 NoteValue::from_raw(tv.note_v),
-                NoteType::native(),
+                AssetId::native(),
                 rho,
                 RandomSeed::from_bytes(tv.note_rseed, &rho).unwrap(),
             )
diff --git a/src/note.rs b/src/note.rs
index 75c3d9c64..3ac8560e1 100644
--- a/src/note.rs
+++ b/src/note.rs
@@ -19,8 +19,8 @@ pub use self::commitment::{ExtractedNoteCommitment, NoteCommitment};
 pub(crate) mod nullifier;
 pub use self::nullifier::Nullifier;
 
-pub(crate) mod note_type;
-pub use self::note_type::NoteType;
+pub(crate) mod asset_id;
+pub use self::asset_id::AssetId;
 
 /// The ZIP 212 seed randomness for a note.
 #[derive(Copy, Clone, Debug)]
@@ -93,8 +93,8 @@ pub struct Note {
     recipient: Address,
     /// The value of this note.
     value: NoteValue,
-    /// The type of this note.
-    note_type: NoteType,
+    /// The asset id of this note.
+    asset: AssetId,
     /// A unique creation ID for this note.
     ///
     /// This is set to the nullifier of the note that was spent in the [`Action`] that
@@ -134,14 +134,14 @@ impl Note {
     pub fn from_parts(
         recipient: Address,
         value: NoteValue,
-        note_type: NoteType,
+        asset: AssetId,
         rho: Nullifier,
         rseed: RandomSeed,
     ) -> CtOption<Self> {
         let note = Note {
             recipient,
             value,
-            note_type,
+            asset,
             rho,
             rseed,
         };
@@ -156,12 +156,12 @@ impl Note {
     pub(crate) fn new(
         recipient: Address,
         value: NoteValue,
-        note_type: NoteType,
+        asset: AssetId,
         rho: Nullifier,
         mut rng: impl RngCore,
     ) -> Self {
         loop {
-            let note = Note::from_parts(recipient, value, note_type, rho, RandomSeed::random(&mut rng, &rho));
+            let note = Note::from_parts(recipient, value, asset, rho, RandomSeed::random(&mut rng, &rho));
             if note.is_some().into() {
                 break note.unwrap();
             }
@@ -173,11 +173,10 @@ impl Note {
     /// Defined in [Zcash Protocol Spec § 4.8.3: Dummy Notes (Orchard)][orcharddummynotes].
     ///
     /// [orcharddummynotes]: https://zips.z.cash/protocol/nu5.pdf#orcharddummynotes
-    /// TODO zsa: remove note_type
     pub(crate) fn dummy(
         rng: &mut impl RngCore,
         rho: Option<Nullifier>,
-        note_type: NoteType,
+        asset: AssetId,
     ) -> (SpendingKey, FullViewingKey, Self) {
         let sk = SpendingKey::random(rng);
         let fvk: FullViewingKey = (&sk).into();
@@ -186,7 +185,7 @@ impl Note {
         let note = Note::new(
             recipient,
             NoteValue::zero(),
-            note_type,
+            asset,
             rho.unwrap_or_else(|| Nullifier::dummy(rng)),
             rng,
         );
@@ -205,8 +204,8 @@ impl Note {
     }
 
     /// Returns the note type of this note.
-    pub fn note_type(&self) -> NoteType {
-        self.note_type
+    pub fn asset(&self) -> AssetId {
+        self.asset
     }
 
     /// Returns the rseed value of this note.
@@ -250,7 +249,7 @@ impl Note {
             g_d.to_bytes(),
             self.recipient.pk_d().to_bytes(),
             self.value,
-            self.note_type,
+            self.asset,
             self.rho.0,
             self.rseed.psi(&self.rho),
             self.rseed.rcm(&self.rho),
@@ -296,8 +295,8 @@ impl fmt::Debug for TransmittedNoteCiphertext {
 pub mod testing {
     use proptest::prelude::*;
 
-    use crate::note::note_type::testing::arb_note_type;
-    use crate::note::note_type::testing::zsa_note_type;
+    use crate::note::asset_id::testing::arb_asset_id;
+    use crate::note::asset_id::testing::zsa_asset_id;
     use crate::value::testing::arb_note_value;
     use crate::{
         address::testing::arb_address, note::nullifier::testing::arb_nullifier, value::NoteValue,
@@ -318,12 +317,12 @@ pub mod testing {
             recipient in arb_address(),
             rho in arb_nullifier(),
             rseed in arb_rseed(),
-            note_type in arb_note_type(),
+            asset in arb_asset_id(),
         ) -> Note {
             Note {
                 recipient,
                 value,
-                note_type,
+                asset,
                 rho,
                 rseed,
             }
@@ -337,12 +336,12 @@ pub mod testing {
             value in arb_note_value(),
             rho in arb_nullifier(),
             rseed in arb_rseed(),
-            note_type in zsa_note_type(),
+            asset in zsa_asset_id(),
         ) -> Note {
             Note {
                 recipient,
                 value,
-                note_type,
+                asset,
                 rho,
                 rseed,
             }
diff --git a/src/note/note_type.rs b/src/note/asset_id.rs
similarity index 73%
rename from src/note/note_type.rs
rename to src/note/asset_id.rs
index cd69f16ea..6d9466e05 100644
--- a/src/note/note_type.rs
+++ b/src/note/asset_id.rs
@@ -10,7 +10,7 @@ use crate::keys::IssuanceValidatingKey;
 
 /// Note type identifier.
 #[derive(Clone, Copy, Debug, Eq)]
-pub struct NoteType(pallas::Point);
+pub struct AssetId(pallas::Point);
 
 pub const MAX_ASSET_DESCRIPTION_SIZE: usize = 512;
 
@@ -20,13 +20,13 @@ fn asset_id_hasher(msg: Vec<u8>) -> pallas::Point {
     pallas::Point::hash_to_curve(VALUE_COMMITMENT_PERSONALIZATION)(&msg)
 }
 
-impl NoteType {
-    /// Deserialize the note_type from a byte array.
+impl AssetId {
+    /// Deserialize the asset_id from a byte array.
     pub fn from_bytes(bytes: &[u8; 32]) -> CtOption<Self> {
-        pallas::Point::from_bytes(bytes).map(NoteType)
+        pallas::Point::from_bytes(bytes).map(AssetId)
     }
 
-    /// Serialize the note_type to its canonical byte representation.
+    /// Serialize the asset_id to its canonical byte representation.
     pub fn to_bytes(self) -> [u8; 32] {
         self.0.to_bytes()
     }
@@ -42,18 +42,18 @@ impl NoteType {
     /// Panics if `asset_desc` is empty or greater than `MAX_ASSET_DESCRIPTION_SIZE`.
     #[allow(non_snake_case)]
     pub fn derive(ik: &IssuanceValidatingKey, asset_desc: &str) -> Self {
-        assert!(!asset_desc.is_empty() && asset_desc.len() <= MAX_ASSET_DESCRIPTION_SIZE);
+        assert!(is_asset_desc_of_valid_size(asset_desc));
 
         let mut s = vec![];
         s.extend(ik.to_bytes());
         s.extend(asset_desc.as_bytes());
 
-        NoteType(asset_id_hasher(s))
+        AssetId(asset_id_hasher(s))
     }
 
     /// Note type for the "native" currency (zec), maintains backward compatibility with Orchard untyped notes.
     pub fn native() -> Self {
-        NoteType(asset_id_hasher(VALUE_COMMITMENT_V_BYTES.to_vec()))
+        AssetId(asset_id_hasher(VALUE_COMMITMENT_V_BYTES.to_vec()))
     }
 
     /// The base point used in value commitments.
@@ -67,14 +67,19 @@ impl NoteType {
     }
 }
 
-impl Hash for NoteType {
+impl Hash for AssetId {
     fn hash<H: Hasher>(&self, h: &mut H) {
         h.write(&self.to_bytes());
         h.finish();
     }
 }
 
-impl PartialEq for NoteType {
+/// Check that `asset_desc` is of valid size.
+pub fn is_asset_desc_of_valid_size(asset_desc: &str) -> bool {
+    !asset_desc.is_empty() && asset_desc.bytes().len() <= MAX_ASSET_DESCRIPTION_SIZE
+}
+
+impl PartialEq for AssetId {
     fn eq(&self, other: &Self) -> bool {
         bool::from(self.0.ct_eq(&other.0))
     }
@@ -84,7 +89,7 @@ impl PartialEq for NoteType {
 #[cfg(any(test, feature = "test-dependencies"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "test-dependencies")))]
 pub mod testing {
-    use super::NoteType;
+    use super::AssetId;
 
     use proptest::prelude::*;
 
@@ -92,36 +97,36 @@ pub mod testing {
 
     prop_compose! {
         /// Generate a uniformly distributed note type
-        pub fn arb_note_type()(
+        pub fn arb_asset_id()(
             is_native in prop::bool::ANY,
             sk in arb_spending_key(),
             str in "[A-Za-z]{255}",
-        ) -> NoteType {
+        ) -> AssetId {
             if is_native {
-                NoteType::native()
+                AssetId::native()
             } else {
                 let isk = IssuanceAuthorizingKey::from(&sk);
-                NoteType::derive(&IssuanceValidatingKey::from(&isk), &str)
+                AssetId::derive(&IssuanceValidatingKey::from(&isk), &str)
             }
         }
     }
 
     prop_compose! {
         /// Generate the native note type
-        pub fn native_note_type()(_i in 0..10) -> NoteType {
+        pub fn native_asset_id()(_i in 0..10) -> AssetId {
             // TODO: remove _i
-            NoteType::native()
+            AssetId::native()
         }
     }
 
     prop_compose! {
         /// Generate the ZSA note type
-        pub fn zsa_note_type()(
+        pub fn zsa_asset_id()(
             sk in arb_spending_key(),
             str in "[A-Za-z]{255}"
-        ) -> NoteType {
+        ) -> AssetId {
             let isk = IssuanceAuthorizingKey::from(&sk);
-            NoteType::derive(&IssuanceValidatingKey::from(&isk), &str)
+            AssetId::derive(&IssuanceValidatingKey::from(&isk), &str)
         }
     }
 }
diff --git a/src/note/commitment.rs b/src/note/commitment.rs
index 95dc92a2c..f4bc7247b 100644
--- a/src/note/commitment.rs
+++ b/src/note/commitment.rs
@@ -11,7 +11,7 @@ use crate::{
         fixed_bases::{NOTE_COMMITMENT_PERSONALIZATION, NOTE_ZSA_COMMITMENT_PERSONALIZATION},
         L_ORCHARD_BASE,
     },
-    note::note_type::NoteType,
+    note::asset_id::AssetId,
     spec::extract_p,
     value::NoteValue,
 };
@@ -45,7 +45,7 @@ impl NoteCommitment {
         g_d: [u8; 32],
         pk_d: [u8; 32],
         v: NoteValue,
-        note_type: NoteType,
+        asset: AssetId,
         rho: pallas::Base,
         psi: pallas::Base,
         rcm: NoteCommitTrapdoor,
@@ -64,13 +64,13 @@ impl NoteCommitment {
             .chain(psi_bits.iter().by_vals().take(L_ORCHARD_BASE));
 
         // TODO: make this constant-time.
-        if note_type.is_native().into() {
+        if asset.is_native().into() {
             // Commit to ZEC notes as per the Orchard protocol.
             Self::commit(NOTE_COMMITMENT_PERSONALIZATION, zec_note_bits, rcm)
         } else {
             // Commit to non-ZEC notes as per the ZSA protocol.
             // Append the note type to the Orchard note encoding.
-            let type_bits = BitArray::<_, Lsb0>::new(note_type.to_bytes());
+            let type_bits = BitArray::<_, Lsb0>::new(asset.to_bytes());
             let zsa_note_bits = zec_note_bits.chain(type_bits.iter().by_vals());
 
             // Commit in a different domain than Orchard notes.
diff --git a/src/note_encryption.rs b/src/note_encryption.rs
index 57dd76589..48456e261 100644
--- a/src/note_encryption.rs
+++ b/src/note_encryption.rs
@@ -9,7 +9,7 @@ use zcash_note_encryption::{
     OUT_PLAINTEXT_SIZE,
 };
 
-use crate::note::NoteType;
+use crate::note::AssetId;
 use crate::{
     action::Action,
     keys::{
@@ -72,7 +72,7 @@ where
 
     // Check note plaintext version
     // and parse the asset type accordingly.
-    let note_type = parse_version_and_asset_type(plaintext)?;
+    let asset = parse_version_and_asset_type(plaintext)?;
 
     // The unwraps below are guaranteed to succeed by the assertion above
     let diversifier = Diversifier::from_bytes(plaintext[1..12].try_into().unwrap());
@@ -86,19 +86,19 @@ where
 
     let recipient = Address::from_parts(diversifier, pk_d);
 
-    let note = Option::from(Note::from_parts(recipient, value, note_type, domain.rho, rseed))?;
+    let note = Option::from(Note::from_parts(recipient, value, asset, domain.rho, rseed))?;
     Some((note, recipient))
 }
 
-fn parse_version_and_asset_type(plaintext: &[u8]) -> Option<NoteType> {
+fn parse_version_and_asset_type(plaintext: &[u8]) -> Option<AssetId> {
     // TODO: make this constant-time?
     match plaintext[0] {
-        0x02 => Some(NoteType::native()),
+        0x02 => Some(AssetId::native()),
         0x03 if plaintext.len() >= COMPACT_ZSA_NOTE_SIZE => {
             let bytes = &plaintext[COMPACT_NOTE_SIZE..COMPACT_ZSA_NOTE_SIZE]
                 .try_into()
                 .unwrap();
-            NoteType::from_bytes(bytes).into()
+            AssetId::from_bytes(bytes).into()
         }
         _ => None,
     }
@@ -192,18 +192,18 @@ impl Domain for OrchardDomain {
         _: &Self::Recipient,
         memo: &Self::Memo,
     ) -> NotePlaintextBytes {
-        let is_native: bool = note.note_type().is_native().into();
+        let is_native: bool = note.asset().is_native().into();
 
         let mut np = [0; NOTE_PLAINTEXT_SIZE];
         np[0] = if is_native { 0x02 } else { 0x03 };
         np[1..12].copy_from_slice(note.recipient().diversifier().as_array());
         np[12..20].copy_from_slice(&note.value().to_bytes());
-        // todo: add note_type
+        // todo: add asset_id
         np[20..52].copy_from_slice(note.rseed().as_bytes());
         if is_native {
             np[52..].copy_from_slice(memo);
         } else {
-            let zsa_type = note.note_type().to_bytes();
+            let zsa_type = note.asset().to_bytes();
             np[52..84].copy_from_slice(&zsa_type);
             let short_memo = &memo[0..memo.len() - ZSA_TYPE_SIZE];
             np[84..].copy_from_slice(short_memo);
@@ -276,13 +276,13 @@ impl Domain for OrchardDomain {
 
     fn extract_memo(&self, plaintext: &NotePlaintextBytes) -> Self::Memo {
         let mut memo = [0; MEMO_SIZE];
-        match get_note_version(plaintext) {
+        match get_note_plaintext_version(plaintext) {
             0x02 => {
                 let full_memo = &plaintext.0[COMPACT_NOTE_SIZE..NOTE_PLAINTEXT_SIZE];
                 memo.copy_from_slice(full_memo);
             }
             0x03 => {
-                // ZSA note plaintext have a shorter memo.
+                // ZSA note plaintexts have a shorter memo.
                 let short_memo = &plaintext.0[COMPACT_ZSA_NOTE_SIZE..NOTE_PLAINTEXT_SIZE];
                 memo[..ZSA_MEMO_SIZE].copy_from_slice(short_memo);
             }
@@ -316,7 +316,7 @@ impl BatchDomain for OrchardDomain {
     }
 }
 
-fn get_note_version(plaintext: &NotePlaintextBytes) -> u8 {
+fn get_note_plaintext_version(plaintext: &NotePlaintextBytes) -> u8 {
     plaintext.0[0]
 }
 
@@ -410,7 +410,7 @@ mod tests {
     };
 
     use super::{prf_ock_orchard, CompactAction, OrchardDomain, OrchardNoteEncryption};
-    use crate::note::NoteType;
+    use crate::note::AssetId;
     use crate::{
         action::Action,
         keys::{
@@ -426,7 +426,7 @@ mod tests {
         Address, Note,
     };
 
-    use super::{get_note_version, orchard_parse_note_plaintext_without_memo};
+    use super::{get_note_plaintext_version, orchard_parse_note_plaintext_without_memo};
 
     proptest! {
     #[test]
@@ -440,7 +440,7 @@ mod tests {
 
         // Decode.
         let domain = OrchardDomain { rho: note.rho() };
-        let parsed_version = get_note_version(&plaintext);
+        let parsed_version = get_note_plaintext_version(&plaintext);
         let parsed_memo = domain.extract_memo(&plaintext);
 
         let (parsed_note, parsed_recipient) = orchard_parse_note_plaintext_without_memo(&domain, &plaintext.0,
@@ -454,7 +454,7 @@ mod tests {
         assert_eq!(parsed_note, note);
         assert_eq!(parsed_recipient, note.recipient());
 
-        if parsed_note.note_type().is_native().into() {
+        if parsed_note.asset().is_native().into() {
             assert_eq!(parsed_version, 0x02);
             assert_eq!(&parsed_memo, memo);
         } else {
@@ -510,12 +510,12 @@ mod tests {
 
             let recipient = Address::from_parts(d, pk_d);
 
-            let note_type = match tv.note_type {
-                None => NoteType::native(),
-                Some(type_bytes) => NoteType::from_bytes(&type_bytes).unwrap(),
+            let asset = match tv.asset {
+                None => AssetId::native(),
+                Some(type_bytes) => AssetId::from_bytes(&type_bytes).unwrap(),
             };
 
-            let note = Note::from_parts(recipient, value, note_type, rho, rseed).unwrap();
+            let note = Note::from_parts(recipient, value, asset, rho, rseed).unwrap();
             assert_eq!(ExtractedNoteCommitment::from(note.commitment()), cmx);
 
             let action = Action::from_parts(
@@ -554,7 +554,7 @@ mod tests {
                     assert_eq!(decrypted_note, note);
                     assert_eq!(decrypted_to, recipient);
                 }
-                None => assert!(tv.note_type.is_some(), "Compact note decryption failed"),
+                None => assert!(tv.asset.is_some(), "Compact note decryption failed"),
                 // Ignore that ZSA notes are not detected in compact decryption.
             }
 
diff --git a/src/test_vectors/note_encryption.rs b/src/test_vectors/note_encryption.rs
index 7d2b7c960..9501a79b1 100644
--- a/src/test_vectors/note_encryption.rs
+++ b/src/test_vectors/note_encryption.rs
@@ -20,7 +20,7 @@ pub(crate) struct TestVector {
     pub(crate) ock: [u8; 32],
     pub(crate) op: [u8; 64],
     pub(crate) c_out: [u8; 80],
-    pub(crate) note_type: Option<[u8; 32]>,
+    pub(crate) asset: Option<[u8; 32]>,
 }
 
 pub(crate) fn test_vectors() -> Vec<TestVector> {
@@ -233,7 +233,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x2d, 0xb5, 0x96, 0x9d, 0x8d, 0x2f, 0x32, 0x25, 0x91, 0x9c, 0xe3, 0x88, 0x26, 0x41,
                 0x5c, 0xc6, 0xb3, 0x38, 0x94, 0x4b, 0x48, 0x99, 0x54, 0x8b,
             ],
-            note_type: None,
+            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -443,7 +443,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x4d, 0xde, 0x70, 0x49, 0x48, 0x72, 0xb2, 0x20, 0x8a, 0x7c, 0x58, 0x02, 0xdf, 0xe9,
                 0xbd, 0x1c, 0xa1, 0x9b, 0xef, 0x4b, 0x37, 0xc6, 0x13, 0xb2,
             ],
-            note_type: None,
+            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -653,7 +653,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x0e, 0x01, 0x86, 0x45, 0x32, 0xa3, 0x57, 0x2c, 0x68, 0xaf, 0xe4, 0x0a, 0xc3, 0xc0,
                 0x95, 0x7b, 0x7a, 0xfc, 0x23, 0xfd, 0x5e, 0x05, 0x17, 0xaa,
             ],
-            note_type: None,
+            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -863,7 +863,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xd1, 0x4c, 0xf8, 0xe8, 0xe2, 0x8e, 0xa2, 0x5c, 0x18, 0x62, 0x7a, 0x84, 0xa2, 0xbe,
                 0x96, 0x1f, 0x44, 0x72, 0x67, 0x67, 0xe9, 0xf8, 0x43, 0x1b,
             ],
-            note_type: None,
+            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1073,7 +1073,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x2e, 0xe8, 0x86, 0x8b, 0x2d, 0xa0, 0x7d, 0xa2, 0x99, 0x2c, 0x6d, 0x9f, 0xb8, 0xbd,
                 0x59, 0x0b, 0x8d, 0xa0, 0x28, 0x11, 0xb5, 0x09, 0xe8, 0xc6,
             ],
-            note_type: None,
+            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1283,7 +1283,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x87, 0x01, 0x0c, 0x8d, 0x13, 0x5c, 0x32, 0xd5, 0x6e, 0xe2, 0x84, 0x68, 0x65, 0xa2,
                 0x61, 0xde, 0x14, 0x25, 0xd2, 0x3b, 0xcc, 0x51, 0xb8, 0xa0,
             ],
-            note_type: None,
+            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1493,7 +1493,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x5d, 0x1b, 0x04, 0x3e, 0xb1, 0x2a, 0x0e, 0xfa, 0xb5, 0x16, 0x09, 0x34, 0xbc, 0x75,
                 0x9e, 0x02, 0x01, 0xd8, 0x66, 0xad, 0xa7, 0x44, 0x35, 0x71,
             ],
-            note_type: None,
+            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1703,7 +1703,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x61, 0x33, 0x92, 0x59, 0x28, 0x3e, 0x3a, 0x95, 0x3c, 0x57, 0xdf, 0x3a, 0x48, 0xca,
                 0x82, 0x71, 0xfc, 0x5f, 0x26, 0x4d, 0x6f, 0x15, 0xb6, 0xb3,
             ],
-            note_type: None,
+            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1913,7 +1913,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x97, 0x4c, 0x26, 0xb5, 0x1b, 0x85, 0x9f, 0xab, 0xe0, 0x2e, 0xab, 0xae, 0x96, 0x8a,
                 0xab, 0x2e, 0x5e, 0x61, 0xef, 0xc2, 0xd4, 0x46, 0x2c, 0x1e,
             ],
-            note_type: None,
+            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -2123,7 +2123,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xba, 0xfe, 0x80, 0x4d, 0x46, 0x6e, 0xd0, 0x79, 0x82, 0x7f, 0xc1, 0x41, 0x91, 0xeb,
                 0xb5, 0x99, 0x17, 0x87, 0x49, 0xe9, 0xc4, 0x06, 0xaf, 0x26,
             ],
-            note_type: None,
+            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -2333,7 +2333,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x13, 0x51, 0xe2, 0x4b, 0x47, 0x02, 0x87, 0xd5, 0x83, 0xba, 0x69, 0x71, 0x18, 0xec,
                 0x07, 0xf6, 0x59, 0x2c, 0x4c, 0xd7, 0xcd, 0x6a, 0xc7, 0x7e,
             ],
-            note_type: Some([
+            asset: Some([
                 0xa9, 0x71, 0x5e, 0x65, 0xaf, 0x82, 0x67, 0x37, 0x3d, 0x34, 0x51, 0x67, 0x4f, 0xf0,
                 0x84, 0xef, 0xd9, 0x2c, 0xcf, 0x3b, 0xcc, 0x7a, 0xca, 0x14, 0x67, 0xb6, 0x32, 0x7e,
                 0x4f, 0x95, 0x22, 0xb2,
@@ -2547,7 +2547,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xe8, 0x27, 0xdd, 0x43, 0x89, 0xb8, 0x57, 0xd1, 0x6d, 0xb8, 0x24, 0xe7, 0x72, 0xba,
                 0x5a, 0xb5, 0xe2, 0x8d, 0xd6, 0xe9, 0x80, 0x82, 0x6b, 0xed,
             ],
-            note_type: Some([
+            asset: Some([
                 0xdf, 0xfd, 0x79, 0xa9, 0xde, 0xd0, 0x5e, 0x88, 0x89, 0x58, 0x19, 0x9e, 0xea, 0x45,
                 0x01, 0xe2, 0x99, 0x0a, 0x53, 0xa5, 0xcd, 0x2a, 0x46, 0xa4, 0x01, 0x57, 0x65, 0x88,
                 0xfd, 0x7d, 0x05, 0x8a,
@@ -2761,7 +2761,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xe7, 0xb9, 0x41, 0x0d, 0x6b, 0xe7, 0x59, 0x2a, 0xed, 0xa9, 0xf5, 0x2d, 0x56, 0xd8,
                 0xc9, 0xf9, 0x3a, 0x0b, 0xe3, 0x8c, 0xfc, 0x8d, 0xc2, 0x94,
             ],
-            note_type: Some([
+            asset: Some([
                 0xa6, 0x33, 0x05, 0x44, 0xe5, 0x46, 0x39, 0xb5, 0x41, 0x87, 0x01, 0xff, 0x4c, 0xc4,
                 0x5a, 0x31, 0xf6, 0x2e, 0xdd, 0x84, 0x3d, 0xbb, 0xdc, 0x5a, 0xa7, 0x27, 0xab, 0x79,
                 0xb4, 0x42, 0x68, 0x3c,
@@ -2975,7 +2975,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xb3, 0x76, 0xcf, 0x33, 0xc9, 0xff, 0x27, 0xa5, 0xaa, 0x01, 0x58, 0x24, 0xe6, 0x78,
                 0x6e, 0x16, 0xe3, 0x7b, 0x35, 0x5c, 0xf7, 0x54, 0x52, 0xdb,
             ],
-            note_type: Some([
+            asset: Some([
                 0x61, 0x16, 0xcf, 0xec, 0x26, 0x47, 0xcc, 0xaa, 0xe1, 0xc7, 0x4b, 0x41, 0x6f, 0x3e,
                 0x6a, 0xe8, 0xf7, 0xcc, 0x60, 0xea, 0xaf, 0x7b, 0x6a, 0x59, 0x0d, 0x51, 0x54, 0x41,
                 0x38, 0xe1, 0x73, 0x29,
@@ -3189,7 +3189,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x9a, 0xb5, 0xa7, 0xce, 0x77, 0x2b, 0x52, 0x2c, 0x4b, 0xaa, 0x12, 0x95, 0xd8, 0x8f,
                 0x15, 0xdc, 0x75, 0x1d, 0xdf, 0x7d, 0x20, 0x8d, 0xd5, 0x17,
             ],
-            note_type: Some([
+            asset: Some([
                 0x29, 0x8a, 0xc0, 0xaf, 0xdc, 0x52, 0x87, 0xd7, 0xad, 0x12, 0x4c, 0xd9, 0x40, 0x5a,
                 0x62, 0xcd, 0x1c, 0xa0, 0x8b, 0x28, 0x2e, 0xfe, 0xf7, 0xf9, 0x28, 0xdf, 0x76, 0xe2,
                 0x82, 0x1a, 0x41, 0x84,
@@ -3403,7 +3403,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x1e, 0x58, 0x7e, 0x43, 0xfd, 0xfc, 0x65, 0xfe, 0x52, 0xf1, 0xe0, 0xc6, 0xa0, 0x46,
                 0x46, 0x48, 0xcd, 0x1f, 0xc8, 0x9e, 0x80, 0xbd, 0x78, 0x0f,
             ],
-            note_type: Some([
+            asset: Some([
                 0xf9, 0x78, 0x1e, 0xbe, 0x31, 0x7a, 0x07, 0x10, 0xae, 0x54, 0x61, 0xe3, 0x4f, 0xe6,
                 0xf1, 0xb1, 0xaa, 0x9b, 0x4e, 0x67, 0xb1, 0x49, 0x10, 0x98, 0x48, 0x02, 0xc2, 0xa7,
                 0xe3, 0x81, 0x93, 0xbc,
@@ -3617,7 +3617,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x51, 0xa5, 0x38, 0x28, 0x0d, 0xaa, 0x94, 0x20, 0x3a, 0xb5, 0x02, 0xa8, 0x15, 0x09,
                 0xe4, 0x3a, 0x61, 0xa6, 0x98, 0x56, 0x57, 0xd9, 0xe8, 0x4e,
             ],
-            note_type: Some([
+            asset: Some([
                 0x76, 0xba, 0x24, 0x3f, 0x28, 0x42, 0xb7, 0xb5, 0xfc, 0x74, 0x6a, 0xe5, 0x1b, 0x0b,
                 0xc4, 0xbd, 0x4f, 0xc9, 0xfd, 0x83, 0x35, 0x65, 0xea, 0x85, 0x2b, 0x92, 0xb2, 0x24,
                 0xf6, 0x99, 0x03, 0x18,
@@ -3831,7 +3831,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xe2, 0x31, 0x31, 0xf4, 0xe7, 0x6b, 0xa7, 0x6b, 0x9d, 0x64, 0x66, 0x78, 0xd8, 0x53,
                 0xd1, 0xdc, 0xaf, 0x81, 0xb8, 0x0e, 0x2e, 0xfd, 0xf0, 0x60,
             ],
-            note_type: Some([
+            asset: Some([
                 0x64, 0xd0, 0x87, 0x40, 0x89, 0x86, 0xe7, 0x3d, 0x6e, 0x28, 0x4f, 0xea, 0x9a, 0x23,
                 0xc3, 0x93, 0x11, 0x78, 0x2f, 0x86, 0xca, 0xbf, 0xf9, 0x45, 0x5e, 0x4c, 0xf6, 0x99,
                 0xe5, 0xf5, 0xd4, 0xbc,
@@ -4045,7 +4045,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xd8, 0x15, 0xf7, 0x29, 0x8c, 0x1d, 0x59, 0x09, 0x1f, 0x1b, 0x38, 0x7a, 0x26, 0x46,
                 0xe7, 0xfe, 0x36, 0x3a, 0xde, 0x83, 0x63, 0xa9, 0x2a, 0xde,
             ],
-            note_type: Some([
+            asset: Some([
                 0xc3, 0xcc, 0x4f, 0x43, 0xfa, 0x01, 0x88, 0x52, 0x1b, 0xc6, 0x1b, 0x21, 0xdd, 0x04,
                 0xe3, 0x7a, 0x83, 0xec, 0xe6, 0x8c, 0xa7, 0xa2, 0xfa, 0x6c, 0x8f, 0x9e, 0x34, 0xa6,
                 0x29, 0x03, 0x35, 0xaa,
@@ -4259,7 +4259,7 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x62, 0x00, 0xfb, 0x18, 0x7d, 0x2c, 0x16, 0x90, 0x65, 0xaf, 0x84, 0xcc, 0x02, 0x3d,
                 0x6d, 0x63, 0xce, 0x05, 0x83, 0x28, 0xe2, 0x47, 0xb5, 0x98,
             ],
-            note_type: Some([
+            asset: Some([
                 0x96, 0x86, 0xaa, 0x36, 0x36, 0xbd, 0x37, 0x5b, 0xd3, 0x13, 0x6b, 0xee, 0x0b, 0xda,
                 0xab, 0xcf, 0xac, 0x88, 0x1b, 0xc7, 0x01, 0x81, 0x27, 0x21, 0xe6, 0xfb, 0x75, 0xaa,
                 0x07, 0x2d, 0x2d, 0x18,
diff --git a/src/value.rs b/src/value.rs
index d6e18ba23..02d845b4c 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -53,7 +53,7 @@ use pasta_curves::{
 use rand::RngCore;
 use subtle::CtOption;
 
-use crate::note::NoteType;
+use crate::note::AssetId;
 use crate::{
     constants::fixed_bases::{VALUE_COMMITMENT_PERSONALIZATION, VALUE_COMMITMENT_R_BYTES},
     primitives::redpallas::{self, Binding},
@@ -325,7 +325,7 @@ impl ValueCommitment {
     ///
     /// [concretehomomorphiccommit]: https://zips.z.cash/protocol/nu5.pdf#concretehomomorphiccommit
     #[allow(non_snake_case)]
-    pub fn derive(value: ValueSum, rcv: ValueCommitTrapdoor, note_type: NoteType) -> Self {
+    pub fn derive(value: ValueSum, rcv: ValueCommitTrapdoor, asset: AssetId) -> Self {
         let hasher = pallas::Point::hash_to_curve(VALUE_COMMITMENT_PERSONALIZATION);
         let R = hasher(&VALUE_COMMITMENT_R_BYTES);
         let abs_value = u64::try_from(value.0.abs()).expect("value must be in valid range");
@@ -336,7 +336,7 @@ impl ValueCommitment {
             pallas::Scalar::from(abs_value)
         };
 
-        let V_zsa = note_type.cv_base();
+        let V_zsa = asset.cv_base();
 
         ValueCommitment(V_zsa * value + R * rcv.0)
     }
@@ -441,9 +441,9 @@ pub mod testing {
 
 #[cfg(test)]
 mod tests {
-    use crate::note::note_type::testing::{arb_note_type, native_note_type};
+    use crate::note::asset_id::testing::{arb_asset_id, native_asset_id};
 
-    use crate::note::NoteType;
+    use crate::note::AssetId;
     use proptest::prelude::*;
 
     use super::{
@@ -453,8 +453,8 @@ mod tests {
     use crate::primitives::redpallas;
 
     fn _bsk_consistent_with_bvk(
-        native_values: &[(ValueSum, ValueCommitTrapdoor, NoteType)],
-        arb_values: &[(ValueSum, ValueCommitTrapdoor, NoteType)],
+        native_values: &[(ValueSum, ValueCommitTrapdoor, AssetId)],
+        arb_values: &[(ValueSum, ValueCommitTrapdoor, AssetId)],
         neg_trapdoors: &[ValueCommitTrapdoor],
     ) {
         // for each arb value, create a negative value with a different trapdoor
@@ -462,7 +462,7 @@ mod tests {
             .iter()
             .cloned()
             .zip(neg_trapdoors.iter().cloned())
-            .map(|((value, _, note_type), rcv)| ((-value).unwrap(), rcv, note_type))
+            .map(|((value, _, asset), rcv)| ((-value).unwrap(), rcv, asset))
             .collect();
 
         let native_value_balance = native_values
@@ -481,12 +481,12 @@ mod tests {
 
         let bvk = (values
             .iter()
-            .map(|(value, rcv, note_type)| ValueCommitment::derive(*value, *rcv, *note_type))
+            .map(|(value, rcv, asset)| ValueCommitment::derive(*value, *rcv, *asset))
             .sum::<ValueCommitment>()
             - ValueCommitment::derive(
                 native_value_balance,
                 ValueCommitTrapdoor::zero(),
-                NoteType::native(),
+                AssetId::native(),
             ))
         .into_bvk();
 
@@ -498,7 +498,7 @@ mod tests {
         fn bsk_consistent_with_bvk_native_only(
             native_values in (1usize..10).prop_flat_map(|n_values|
                 arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
-                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), native_note_type()), n_values)
+                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), native_asset_id()), n_values)
                 )
             ),
         ) {
@@ -512,12 +512,12 @@ mod tests {
         fn bsk_consistent_with_bvk(
             native_values in (1usize..10).prop_flat_map(|n_values|
                 arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
-                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), native_note_type()), n_values)
+                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), native_asset_id()), n_values)
                 )
             ),
             (arb_values,neg_trapdoors) in (1usize..10).prop_flat_map(|n_values|
                 (arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
-                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), arb_note_type()), n_values)
+                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), arb_asset_id()), n_values)
                 ), prop::collection::vec(arb_trapdoor(), n_values))
             ),
         ) {
diff --git a/tests/builder.rs b/tests/builder.rs
index bf94fc2ee..312541ecf 100644
--- a/tests/builder.rs
+++ b/tests/builder.rs
@@ -1,5 +1,5 @@
 use incrementalmerkletree::{bridgetree::BridgeTree, Hashable, Tree};
-use orchard::note::NoteType;
+use orchard::note::AssetId;
 use orchard::{
     builder::Builder,
     bundle::{Authorized, Flags},
@@ -68,7 +68,7 @@ fn bundle_chain() {
                 None,
                 recipient,
                 NoteValue::from_raw(5000),
-                NoteType::native(),
+                AssetId::native(),
                 None
             ),
             Ok(())
@@ -103,7 +103,7 @@ fn bundle_chain() {
                 None,
                 recipient,
                 NoteValue::from_raw(5000),
-                NoteType::native(),
+                AssetId::native(),
                 None
             ),
             Ok(())
diff --git a/tests/zsa.rs b/tests/zsa.rs
index 6dfff6dc0..f8ae6d23c 100644
--- a/tests/zsa.rs
+++ b/tests/zsa.rs
@@ -6,14 +6,14 @@ use incrementalmerkletree::{Hashable, Tree};
 use orchard::bundle::Authorized;
 use orchard::issuance::{verify_issue_bundle, IssueBundle, Signed, Unauthorized};
 use orchard::keys::{IssuanceAuthorizingKey, IssuanceValidatingKey};
-use orchard::note::{ExtractedNoteCommitment, NoteType};
+use orchard::note::{AssetId, ExtractedNoteCommitment};
 use orchard::note_encryption::OrchardDomain;
 use orchard::tree::{MerkleHashOrchard, MerklePath};
 use orchard::{
     builder::Builder,
     bundle::Flags,
     circuit::{ProvingKey, VerifyingKey},
-    keys::{FullViewingKey, Scope, SpendAuthorizingKey, SpendingKey},
+    keys::{FullViewingKey, Scope, SpendAuthorizingKey, SpendingKey, PreparedIncomingViewingKey},
     value::NoteValue,
     Address, Anchor, Bundle, Note,
 };
@@ -189,7 +189,7 @@ fn create_native_note(keys: &Keychain) -> Note {
                 None,
                 keys.recipient,
                 NoteValue::from_raw(100),
-                NoteType::native(),
+                AssetId::native(),
                 None
             ),
             Ok(())
@@ -205,7 +205,7 @@ fn create_native_note(keys: &Keychain) -> Note {
         .iter()
         .find_map(|action| {
             let domain = OrchardDomain::for_action(action);
-            try_note_decryption(&domain, &ivk, action)
+            try_note_decryption(&domain, &PreparedIncomingViewingKey::new(&ivk), action)
         })
         .unwrap();
 
@@ -225,7 +225,7 @@ impl TestSpendInfo {
 
 struct TestOutputInfo {
     value: NoteValue,
-    note_type: NoteType,
+    asset: AssetId,
 }
 
 fn build_and_verify_bundle(
@@ -247,7 +247,7 @@ fn build_and_verify_bundle(
         });
         outputs.iter().for_each(|output| {
             assert_eq!(
-                builder.add_recipient(None, keys.recipient, output.value, output.note_type, None),
+                builder.add_recipient(None, keys.recipient, output.value, output.asset, None),
                 Ok(())
             )
         });
@@ -289,7 +289,7 @@ fn zsa_issue_and_transfer() {
         vec![&zsa_spend_1],
         vec![TestOutputInfo {
             value: zsa_spend_1.note.value(),
-            note_type: zsa_spend_1.note.note_type(),
+            asset: zsa_spend_1.note.asset(),
         }],
         anchor,
         2,
@@ -303,11 +303,11 @@ fn zsa_issue_and_transfer() {
         vec![
             TestOutputInfo {
                 value: NoteValue::from_raw(zsa_spend_1.note.value().inner() - delta),
-                note_type: zsa_spend_1.note.note_type(),
+                asset: zsa_spend_1.note.asset(),
             },
             TestOutputInfo {
                 value: NoteValue::from_raw(delta),
-                note_type: zsa_spend_1.note.note_type(),
+                asset: zsa_spend_1.note.asset(),
             },
         ],
         anchor,
@@ -322,7 +322,7 @@ fn zsa_issue_and_transfer() {
             value: NoteValue::from_raw(
                 zsa_spend_1.note.value().inner() + zsa_spend_2.note.value().inner(),
             ),
-            note_type: zsa_spend_1.note.note_type(),
+            asset: zsa_spend_1.note.asset(),
         }],
         anchor,
         2,
@@ -335,11 +335,11 @@ fn zsa_issue_and_transfer() {
         vec![
             TestOutputInfo {
                 value: NoteValue::from_raw(zsa_spend_1.note.value().inner() - delta),
-                note_type: zsa_spend_1.note.note_type(),
+                asset: zsa_spend_1.note.asset(),
             },
             TestOutputInfo {
                 value: NoteValue::from_raw(zsa_spend_2.note.value().inner() + delta),
-                note_type: zsa_spend_2.note.note_type(),
+                asset: zsa_spend_2.note.asset(),
             },
         ],
         anchor,
@@ -353,11 +353,11 @@ fn zsa_issue_and_transfer() {
         vec![
             TestOutputInfo {
                 value: zsa_spend_1.note.value(),
-                note_type: zsa_spend_1.note.note_type(),
+                asset: zsa_spend_1.note.asset(),
             },
             TestOutputInfo {
                 value: NoteValue::from_raw(100),
-                note_type: NoteType::native(),
+                asset: AssetId::native(),
             },
         ],
         anchor,
@@ -383,11 +383,11 @@ fn zsa_issue_and_transfer() {
         vec![
             TestOutputInfo {
                 value: zsa_spend_1.note.value(),
-                note_type: zsa_spend_1.note.note_type(),
+                asset: zsa_spend_1.note.asset(),
             },
             TestOutputInfo {
                 value: native_spend.note.value(),
-                note_type: NoteType::native(),
+                asset: AssetId::native(),
             },
         ],
         native_anchor,
@@ -413,11 +413,11 @@ fn zsa_issue_and_transfer() {
         vec![
             TestOutputInfo {
                 value: zsa_spend_t7_1.note.value(),
-                note_type: zsa_spend_t7_1.note.note_type(),
+                asset: zsa_spend_t7_1.note.asset(),
             },
             TestOutputInfo {
                 value: zsa_spend_t7_2.note.value(),
-                note_type: zsa_spend_t7_2.note.note_type(),
+                asset: zsa_spend_t7_2.note.asset(),
             },
         ],
         anchor_t7,
@@ -432,11 +432,11 @@ fn zsa_issue_and_transfer() {
             vec![
                 TestOutputInfo {
                     value: NoteValue::from_raw(zsa_spend_t7_1.note.value().inner() + delta),
-                    note_type: zsa_spend_t7_1.note.note_type(),
+                    asset: zsa_spend_t7_1.note.asset(),
                 },
                 TestOutputInfo {
                     value: NoteValue::from_raw(zsa_spend_t7_2.note.value().inner() - delta),
-                    note_type: zsa_spend_t7_2.note.note_type(),
+                    asset: zsa_spend_t7_2.note.asset(),
                 },
             ],
             anchor_t7,

From 9405f801cd95ad4193c098eea6b47de954198461 Mon Sep 17 00:00:00 2001
From: Paul <3682187+PaulLaux@users.noreply.github.com>
Date: Fri, 28 Oct 2022 10:46:02 +0300
Subject: [PATCH 11/17] verify_issue_bundle() cleanup (#25)

* improved `verify_issue_bundle()`
---
 .github/workflows/bench.yml        |  2 +-
 .github/workflows/ci.yml           | 10 +++++-----
 .github/workflows/lints-stable.yml |  6 +++---
 Cargo.toml                         |  2 +-
 README.md                          |  2 +-
 rust-toolchain                     |  2 +-
 src/issuance.rs                    | 26 +++++++++++++-------------
 src/note.rs                        |  8 +++++++-
 tests/zsa.rs                       |  2 +-
 9 files changed, 33 insertions(+), 27 deletions(-)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index e8e263848..21f631759 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -16,7 +16,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.56.1
+          toolchain: 1.61
           override: true
       - name: Run benchmark
         run: cargo bench -- --output-format bencher | tee output.txt
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e7b900029..101cee1ec 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.56.1
+          toolchain: 1.61
           override: true
       - name: Run tests
         uses: actions-rs/cargo@v1
@@ -30,7 +30,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.56.1
+          toolchain: 1.61
           override: true
       # Build benchmarks to prevent bitrot
       - name: Build benchmarks
@@ -46,7 +46,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.56.1
+          toolchain: 1.61
           override: true
       - name: Setup mdBook
         uses: peaceiris/actions-mdbook@v1
@@ -90,7 +90,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.56.1
+          toolchain: 1.61
           override: true
       - name: cargo fetch
         uses: actions-rs/cargo@v1
@@ -113,7 +113,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.56.1
+          toolchain: 1.61
           override: true
       - run: rustup component add rustfmt
       - uses: actions-rs/cargo@v1
diff --git a/.github/workflows/lints-stable.yml b/.github/workflows/lints-stable.yml
index 242041e89..88a727090 100644
--- a/.github/workflows/lints-stable.yml
+++ b/.github/workflows/lints-stable.yml
@@ -5,19 +5,19 @@ on: pull_request
 
 jobs:
   clippy:
-    name: Clippy (1.56.1)
+    name: Clippy (1.61)
     timeout-minutes: 30
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.56.1
+          toolchain: 1.61
           components: clippy
           override: true
       - name: Run Clippy
         uses: actions-rs/clippy-check@v1
         with:
-          name: Clippy (1.56.1)
+          name: Clippy (1.61)
           token: ${{ secrets.GITHUB_TOKEN }}
           args: --all-features --all-targets -- -D warnings
diff --git a/Cargo.toml b/Cargo.toml
index 813b0aee3..ed956ef27 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,7 +9,7 @@ authors = [
     "Kris Nuttycombe <kris@electriccoin.co>",
 ]
 edition = "2021"
-rust-version = "1.56.1"
+rust-version = "1.61"
 description = "The Orchard shielded transaction protocol"
 license-file = "LICENSE-BOSL"
 repository = "https://github.com/zcash/orchard"
diff --git a/README.md b/README.md
index 12b74651b..4d4ac85eb 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # orchard [![Crates.io](https://img.shields.io/crates/v/orchard.svg)](https://crates.io/crates/orchard) #
 
-Requires Rust 1.56.1+.
+Requires Rust 1.61+.
 
 ## Documentation
 
diff --git a/rust-toolchain b/rust-toolchain
index 43c989b55..4213d88dc 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1 +1 @@
-1.56.1
+1.61
diff --git a/src/issuance.rs b/src/issuance.rs
index 4fbcd8421..9f15d638f 100644
--- a/src/issuance.rs
+++ b/src/issuance.rs
@@ -335,32 +335,32 @@ impl IssueBundle<Signed> {
 /// Validation for Orchard IssueBundles
 ///
 /// A set of previously finalized asset types must be provided.
-/// In case of success, `finalized` will contain a set of the provided **and** the newly finalized `NoteType`s
+/// In case of success, `finalized` will contain a set of the provided **and** the newly finalized `AssetId`s
 ///
 /// The following checks are performed:
 /// * For the `IssueBundle`:
 ///     * the Signature on top of the provided `sighash` verifies correctly.
 /// * For each `IssueAction`:
 ///     * Asset description size is collect.
-///     * `NoteType` for the `IssueAction` has not been previously finalized.
+///     * `AssetId` for the `IssueAction` has not been previously finalized.
 /// * For each `Note` inside an `IssueAction`:
 ///     * All notes have the same, correct `NoteType`.
 pub fn verify_issue_bundle(
     bundle: &IssueBundle<Signed>,
     sighash: [u8; 32],
-    finalized: &mut HashSet<AssetId>, // The current finalization set.
+    finalized: &mut HashSet<AssetId>, // The finalization set.
 ) -> Result<(), Error> {
     if let Err(e) = bundle.ik.verify(&sighash, &bundle.authorization.signature) {
         return Err(IssueBundleInvalidSignature(e));
     };
 
-    let currently_finalized: &mut HashSet<AssetId> = &mut HashSet::new();
+    let s = &mut HashSet::<AssetId>::new();
 
-    // Any IssueAction could have just one properly derived NoteType.
-    let res = bundle
+    // An IssueAction could have just one properly derived AssetId.
+    let newly_finalized = bundle
         .actions()
         .iter()
-        .try_fold(currently_finalized, |acc, action| {
+        .try_fold(s, |newly_finalized, action| {
             if !is_asset_desc_of_valid_size(action.asset_desc()) {
                 return Err(WrongAssetDescSize);
             }
@@ -368,21 +368,21 @@ pub fn verify_issue_bundle(
             // Fail if any note in the IssueAction has incorrect note type.
             let asset = action.are_note_asset_ids_derived_correctly(bundle.ik())?;
 
-            // Fail if the current asset was previously finalized.
-            if finalized.contains(&asset) || acc.contains(&asset) {
+            // Fail if the asset was previously finalized.
+            if finalized.contains(&asset) || newly_finalized.contains(&asset) {
                 return Err(IssueActionPreviouslyFinalizedNoteType(asset));
             }
 
             // Add to finalization set, if needed.
             if action.is_finalized() {
-                acc.insert(asset);
+                newly_finalized.insert(asset);
             }
 
-            // Proceed with the new asset finalization set.
-            Ok(acc)
+            // Proceed with the new finalization set.
+            Ok(newly_finalized)
         })?;
 
-    finalized.extend(res.iter());
+    finalized.extend(newly_finalized.iter());
     Ok(())
 }
 
diff --git a/src/note.rs b/src/note.rs
index 3ac8560e1..d5a58a838 100644
--- a/src/note.rs
+++ b/src/note.rs
@@ -161,7 +161,13 @@ impl Note {
         mut rng: impl RngCore,
     ) -> Self {
         loop {
-            let note = Note::from_parts(recipient, value, asset, rho, RandomSeed::random(&mut rng, &rho));
+            let note = Note::from_parts(
+                recipient,
+                value,
+                asset,
+                rho,
+                RandomSeed::random(&mut rng, &rho),
+            );
             if note.is_some().into() {
                 break note.unwrap();
             }
diff --git a/tests/zsa.rs b/tests/zsa.rs
index f8ae6d23c..f65b18616 100644
--- a/tests/zsa.rs
+++ b/tests/zsa.rs
@@ -13,7 +13,7 @@ use orchard::{
     builder::Builder,
     bundle::Flags,
     circuit::{ProvingKey, VerifyingKey},
-    keys::{FullViewingKey, Scope, SpendAuthorizingKey, SpendingKey, PreparedIncomingViewingKey},
+    keys::{FullViewingKey, PreparedIncomingViewingKey, Scope, SpendAuthorizingKey, SpendingKey},
     value::NoteValue,
     Address, Anchor, Bundle, Note,
 };

From d8f3563c1c6ae83ee44627557954313cebfdd796 Mon Sep 17 00:00:00 2001
From: Alexey Koren <alexey.koren@gmail.com>
Date: Wed, 7 Dec 2022 16:19:51 +0100
Subject: [PATCH 12/17] ZSA burn functionality (#35)

Added a method to add assets to burn to the Builder

bvk computation now includes the burnt assets

Added Tests for bsk/bvk consistency for burning

Added E2E tests for assets burning
---
 .circleci/config.yml               |   2 +-
 .github/workflows/bench.yml        |   2 +-
 .github/workflows/ci.yml           |  10 +--
 .github/workflows/lints-stable.yml |   6 +-
 .gitignore                         |   1 -
 Cargo.toml                         |   2 +-
 rust-toolchain                     |   2 +-
 src/builder.rs                     |  58 ++++++++-----
 src/bundle.rs                      |  52 +++++++++--
 src/value.rs                       |  76 ++++++++++------
 tests/zsa.rs                       | 135 ++++++++++++++++++++---------
 11 files changed, 238 insertions(+), 108 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index ba37a7890..9dead1280 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -12,7 +12,7 @@ jobs:
     # Specify the execution environment. You can specify an image from Dockerhub or use one of our Convenience Images from CircleCI's Developer Hub.
     # See: https://circleci.com/docs/2.0/configuration-reference/#docker-machine-macos-windows-executor
     docker:
-      - image: cimg/rust:1.59.0
+      - image: cimg/rust:1.61.0
     # Add steps to the job
     # See: https://circleci.com/docs/2.0/configuration-reference/#steps
     steps:
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 21f631759..ba1ceea59 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -16,7 +16,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.61
+          toolchain: 1.61.0
           override: true
       - name: Run benchmark
         run: cargo bench -- --output-format bencher | tee output.txt
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 101cee1ec..66b8c4d3b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.61
+          toolchain: 1.61.0
           override: true
       - name: Run tests
         uses: actions-rs/cargo@v1
@@ -30,7 +30,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.61
+          toolchain: 1.61.0
           override: true
       # Build benchmarks to prevent bitrot
       - name: Build benchmarks
@@ -46,7 +46,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.61
+          toolchain: 1.61.0
           override: true
       - name: Setup mdBook
         uses: peaceiris/actions-mdbook@v1
@@ -90,7 +90,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.61
+          toolchain: 1.61.0
           override: true
       - name: cargo fetch
         uses: actions-rs/cargo@v1
@@ -113,7 +113,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.61
+          toolchain: 1.61.0
           override: true
       - run: rustup component add rustfmt
       - uses: actions-rs/cargo@v1
diff --git a/.github/workflows/lints-stable.yml b/.github/workflows/lints-stable.yml
index 88a727090..a000ab449 100644
--- a/.github/workflows/lints-stable.yml
+++ b/.github/workflows/lints-stable.yml
@@ -5,19 +5,19 @@ on: pull_request
 
 jobs:
   clippy:
-    name: Clippy (1.61)
+    name: Clippy (1.61.0)
     timeout-minutes: 30
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.61
+          toolchain: 1.61.0
           components: clippy
           override: true
       - name: Run Clippy
         uses: actions-rs/clippy-check@v1
         with:
-          name: Clippy (1.61)
+          name: Clippy (1.61.0)
           token: ${{ secrets.GITHUB_TOKEN }}
           args: --all-features --all-targets -- -D warnings
diff --git a/.gitignore b/.gitignore
index d7f36bd31..f4ca20140 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,4 +4,3 @@ Cargo.lock
 .vscode
 .idea
 action-circuit-layout.png
-proptest-regressions/*.txt
diff --git a/Cargo.toml b/Cargo.toml
index ed956ef27..cb7508702 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,7 +9,7 @@ authors = [
     "Kris Nuttycombe <kris@electriccoin.co>",
 ]
 edition = "2021"
-rust-version = "1.61"
+rust-version = "1.61.0"
 description = "The Orchard shielded transaction protocol"
 license-file = "LICENSE-BOSL"
 repository = "https://github.com/zcash/orchard"
diff --git a/rust-toolchain b/rust-toolchain
index 4213d88dc..91951fd8a 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1 +1 @@
-1.61
+1.61.0
diff --git a/src/builder.rs b/src/builder.rs
index 5c6147022..4229cbb28 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -251,6 +251,7 @@ impl ActionInfo {
 pub struct Builder {
     spends: Vec<SpendInfo>,
     recipients: Vec<RecipientInfo>,
+    burn: HashMap<AssetId, ValueSum>,
     flags: Flags,
     anchor: Anchor,
 }
@@ -261,6 +262,7 @@ impl Builder {
         Builder {
             spends: vec![],
             recipients: vec![],
+            burn: HashMap::new(),
             flags,
             anchor,
         }
@@ -337,6 +339,17 @@ impl Builder {
         Ok(())
     }
 
+    /// Add an instruction to burn a given amount of a specific asset.
+    pub fn add_burn(&mut self, asset: AssetId, value: NoteValue) -> Result<(), &'static str> {
+        if asset.is_native().into() {
+            return Err("Burning is only possible for non-native assets");
+        }
+        let cur = *self.burn.get(&asset).unwrap_or(&ValueSum::zero());
+        let sum = (cur + value).ok_or("Orchard ValueSum operation overflowed")?;
+        self.burn.insert(asset, sum);
+        Ok(())
+    }
+
     /// The net value of the bundle to be built. The value of all spends,
     /// minus the value of all outputs.
     ///
@@ -366,7 +379,7 @@ impl Builder {
     ///
     /// The returned bundle will have no proof or signatures; these can be applied with
     /// [`Bundle::create_proof`] and [`Bundle::apply_signatures`] respectively.
-    pub fn build<V: TryFrom<i64>>(
+    pub fn build<V: TryFrom<i64> + Copy + Into<i64>>(
         self,
         mut rng: impl RngCore,
     ) -> Result<Bundle<InProgress<Unproven, Unauthorized>, V>, Error> {
@@ -419,16 +432,14 @@ impl Builder {
         let anchor = self.anchor;
 
         // Determine the value balance for this bundle, ensuring it is valid.
-        let value_balance = pre_actions
+        let native_value_balance: V = pre_actions
             .iter()
+            .filter(|action| action.spend.note.asset().is_native().into())
             .fold(Some(ValueSum::zero()), |acc, action| {
                 acc? + action.value_sum()
             })
-            .ok_or(OverflowError)?;
-
-        let result_value_balance: V = i64::try_from(value_balance)
-            .map_err(Error::ValueSum)
-            .and_then(|i| V::try_from(i).map_err(|_| Error::ValueSum(value::OverflowError)))?;
+            .ok_or(OverflowError)?
+            .into()?;
 
         // Compute the transaction binding signing key.
         let bsk = pre_actions
@@ -441,26 +452,26 @@ impl Builder {
         let (actions, circuits): (Vec<_>, Vec<_>) =
             pre_actions.into_iter().map(|a| a.build(&mut rng)).unzip();
 
-        // Verify that bsk and bvk are consistent.
-        let bvk = (actions.iter().map(|a| a.cv_net()).sum::<ValueCommitment>()
-            - ValueCommitment::derive(
-                value_balance,
-                ValueCommitTrapdoor::zero(),
-                AssetId::native(),
-            ))
-        .into_bvk();
-        assert_eq!(redpallas::VerificationKey::from(&bsk), bvk);
-
-        Ok(Bundle::from_parts(
+        let bundle = Bundle::from_parts(
             NonEmpty::from_vec(actions).unwrap(),
             flags,
-            result_value_balance,
+            native_value_balance,
+            self.burn
+                .into_iter()
+                .map(|(asset, value)| Ok((asset, value.into()?)))
+                .collect::<Result<_, Error>>()?,
             anchor,
             InProgress {
                 proof: Unproven { circuits },
                 sigs: Unauthorized { bsk },
             },
-        ))
+        );
+
+        assert_eq!(
+            redpallas::VerificationKey::from(&bundle.authorization().sigs.bsk),
+            bundle.binding_validating_key()
+        );
+        Ok(bundle)
     }
 }
 
@@ -785,7 +796,7 @@ pub mod testing {
 
     impl<R: RngCore + CryptoRng> ArbitraryBundleInputs<R> {
         /// Create a bundle from the set of arbitrary bundle inputs.
-        fn into_bundle<V: TryFrom<i64>>(mut self) -> Bundle<Authorized, V> {
+        fn into_bundle<V: TryFrom<i64> + Copy + Into<i64>>(mut self) -> Bundle<Authorized, V> {
             let fvk = FullViewingKey::from(&self.sk);
             let flags = Flags::from_parts(true, true);
             let mut builder = Builder::new(flags, self.anchor);
@@ -866,14 +877,15 @@ pub mod testing {
     }
 
     /// Produce an arbitrary valid Orchard bundle using a random spending key.
-    pub fn arb_bundle<V: TryFrom<i64> + Debug>() -> impl Strategy<Value = Bundle<Authorized, V>> {
+    pub fn arb_bundle<V: TryFrom<i64> + Debug + Copy + Into<i64>>(
+    ) -> impl Strategy<Value = Bundle<Authorized, V>> {
         arb_spending_key()
             .prop_flat_map(arb_bundle_inputs)
             .prop_map(|inputs| inputs.into_bundle::<V>())
     }
 
     /// Produce an arbitrary valid Orchard bundle using a specified spending key.
-    pub fn arb_bundle_with_key<V: TryFrom<i64> + Debug>(
+    pub fn arb_bundle_with_key<V: TryFrom<i64> + Debug + Copy + Into<i64>>(
         k: SpendingKey,
     ) -> impl Strategy<Value = Bundle<Authorized, V>> {
         arb_bundle_inputs(k).prop_map(|inputs| inputs.into_bundle::<V>())
diff --git a/src/bundle.rs b/src/bundle.rs
index 6f7e0bce9..cbc66e796 100644
--- a/src/bundle.rs
+++ b/src/bundle.rs
@@ -140,6 +140,9 @@ pub struct Bundle<T: Authorization, V> {
     ///
     /// This is the sum of Orchard spends minus the sum of Orchard outputs.
     value_balance: V,
+    /// Assets intended for burning
+    /// TODO We need to add a consensus check to make sure that it is impossible to burn ZEC.
+    burn: Vec<(AssetId, V)>,
     /// The root of the Orchard commitment tree that this bundle commits to.
     anchor: Anchor,
     /// The authorization for this bundle.
@@ -172,6 +175,7 @@ impl<T: Authorization, V> Bundle<T, V> {
         actions: NonEmpty<Action<T::SpendAuth>>,
         flags: Flags,
         value_balance: V,
+        burn: Vec<(AssetId, V)>,
         anchor: Anchor,
         authorization: T,
     ) -> Self {
@@ -179,6 +183,7 @@ impl<T: Authorization, V> Bundle<T, V> {
             actions,
             flags,
             value_balance,
+            burn,
             anchor,
             authorization,
         }
@@ -214,8 +219,8 @@ impl<T: Authorization, V> Bundle<T, V> {
     }
 
     /// Construct a new bundle by applying a transformation that might fail
-    /// to the value balance.
-    pub fn try_map_value_balance<V0, E, F: FnOnce(V) -> Result<V0, E>>(
+    /// to the value balance and balances of assets to burn.
+    pub fn try_map_value_balance<V0, E, F: Fn(V) -> Result<V0, E>>(
         self,
         f: F,
     ) -> Result<Bundle<T, V0>, E> {
@@ -223,6 +228,11 @@ impl<T: Authorization, V> Bundle<T, V> {
             actions: self.actions,
             flags: self.flags,
             value_balance: f(self.value_balance)?,
+            burn: self
+                .burn
+                .into_iter()
+                .map(|(asset, value)| Ok((asset, f(value)?)))
+                .collect::<Result<Vec<(AssetId, V0)>, E>>()?,
             anchor: self.anchor,
             authorization: self.authorization,
         })
@@ -244,6 +254,7 @@ impl<T: Authorization, V> Bundle<T, V> {
             value_balance: self.value_balance,
             anchor: self.anchor,
             authorization: step(context, authorization),
+            burn: self.burn,
         }
     }
 
@@ -267,6 +278,7 @@ impl<T: Authorization, V> Bundle<T, V> {
             value_balance: self.value_balance,
             anchor: self.anchor,
             authorization: step(context, authorization)?,
+            burn: self.burn,
         })
     }
 
@@ -386,7 +398,19 @@ impl<T: Authorization, V: Copy + Into<i64>> Bundle<T, V> {
                 ValueSum::from_raw(self.value_balance.into()),
                 ValueCommitTrapdoor::zero(),
                 AssetId::native(),
-            ))
+            )
+            - self
+                .burn
+                .clone()
+                .into_iter()
+                .map(|(asset, value)| {
+                    ValueCommitment::derive(
+                        ValueSum::from_raw(value.into()),
+                        ValueCommitTrapdoor::zero(),
+                        asset,
+                    )
+                })
+                .sum::<ValueCommitment>())
         .into_bvk()
     }
 }
@@ -503,6 +527,9 @@ pub mod testing {
     use super::{Action, Authorization, Authorized, Bundle, Flags};
 
     pub use crate::action::testing::{arb_action, arb_unauthorized_action};
+    use crate::note::asset_id::testing::zsa_asset_id;
+    use crate::note::AssetId;
+    use crate::value::testing::arb_value_sum;
 
     /// Marker for an unauthorized bundle with no proofs or signatures.
     #[derive(Debug)]
@@ -562,6 +589,13 @@ pub mod testing {
         })
     }
 
+    prop_compose! {
+        /// Create an arbitrary vector of assets to burn.
+        pub fn arb_asset_to_burn()(asset_id in zsa_asset_id(), value in arb_value_sum()) -> (AssetId, ValueSum) {
+            (asset_id, value)
+        }
+    }
+
     prop_compose! {
         /// Create an arbitrary set of flags.
         pub fn arb_flags()(spends_enabled in prop::bool::ANY, outputs_enabled in prop::bool::ANY) -> Flags {
@@ -589,7 +623,8 @@ pub mod testing {
         (
             acts in vec(arb_unauthorized_action_n(n_actions, flags), n_actions),
             anchor in arb_base().prop_map(Anchor::from),
-            flags in Just(flags)
+            flags in Just(flags),
+            burn in vec(arb_asset_to_burn(), 1usize..10)
         ) -> Bundle<Unauthorized, ValueSum> {
             let (balances, actions): (Vec<ValueSum>, Vec<Action<_>>) = acts.into_iter().unzip();
 
@@ -597,8 +632,9 @@ pub mod testing {
                 NonEmpty::from_vec(actions).unwrap(),
                 flags,
                 balances.into_iter().sum::<Result<ValueSum, _>>().unwrap(),
+                burn,
                 anchor,
-                Unauthorized
+                Unauthorized,
             )
         }
     }
@@ -618,7 +654,8 @@ pub mod testing {
             rng_seed in prop::array::uniform32(prop::num::u8::ANY),
             fake_proof in vec(prop::num::u8::ANY, 1973),
             fake_sighash in prop::array::uniform32(prop::num::u8::ANY),
-            flags in Just(flags)
+            flags in Just(flags),
+            burn in vec(arb_asset_to_burn(), 1usize..10)
         ) -> Bundle<Authorized, ValueSum> {
             let (balances, actions): (Vec<ValueSum>, Vec<Action<_>>) = acts.into_iter().unzip();
             let rng = StdRng::from_seed(rng_seed);
@@ -627,11 +664,12 @@ pub mod testing {
                 NonEmpty::from_vec(actions).unwrap(),
                 flags,
                 balances.into_iter().sum::<Result<ValueSum, _>>().unwrap(),
+                burn,
                 anchor,
                 Authorized {
                     proof: Proof::new(fake_proof),
                     binding_signature: sk.sign(rng, &fake_sighash),
-                }
+                },
             )
         }
     }
diff --git a/src/value.rs b/src/value.rs
index 02d845b4c..dd3a5546d 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -53,6 +53,7 @@ use pasta_curves::{
 use rand::RngCore;
 use subtle::CtOption;
 
+use crate::builder::Error;
 use crate::note::AssetId;
 use crate::{
     constants::fixed_bases::{VALUE_COMMITMENT_PERSONALIZATION, VALUE_COMMITMENT_R_BYTES},
@@ -129,6 +130,12 @@ impl From<&NoteValue> for Assigned<pallas::Base> {
     }
 }
 
+impl From<NoteValue> for i128 {
+    fn from(value: NoteValue) -> Self {
+        value.0 as i128
+    }
+}
+
 impl Sub for NoteValue {
     type Output = ValueSum;
 
@@ -181,15 +188,21 @@ impl ValueSum {
             sign,
         )
     }
+
+    pub(crate) fn into<V: TryFrom<i64>>(self) -> Result<V, Error> {
+        i64::try_from(self)
+            .map_err(Error::ValueSum)
+            .and_then(|i| V::try_from(i).map_err(|_| Error::ValueSum(OverflowError)))
+    }
 }
 
-impl Add for ValueSum {
+impl<T: Into<i128>> Add<T> for ValueSum {
     type Output = Option<ValueSum>;
 
     #[allow(clippy::suspicious_arithmetic_impl)]
-    fn add(self, rhs: Self) -> Self::Output {
+    fn add(self, rhs: T) -> Self::Output {
         self.0
-            .checked_add(rhs.0)
+            .checked_add(rhs.into())
             .filter(|v| VALUE_SUM_RANGE.contains(v))
             .map(ValueSum)
     }
@@ -227,6 +240,12 @@ impl TryFrom<ValueSum> for i64 {
     }
 }
 
+impl From<ValueSum> for i128 {
+    fn from(value: ValueSum) -> Self {
+        value.0
+    }
+}
+
 /// The blinding factor for a [`ValueCommitment`].
 #[derive(Clone, Copy, Debug)]
 pub struct ValueCommitTrapdoor(pallas::Scalar);
@@ -452,10 +471,11 @@ mod tests {
     };
     use crate::primitives::redpallas;
 
-    fn _bsk_consistent_with_bvk(
+    fn check_binding_signature(
         native_values: &[(ValueSum, ValueCommitTrapdoor, AssetId)],
         arb_values: &[(ValueSum, ValueCommitTrapdoor, AssetId)],
         neg_trapdoors: &[ValueCommitTrapdoor],
+        arb_values_to_burn: &[(ValueSum, ValueCommitTrapdoor, AssetId)],
     ) {
         // for each arb value, create a negative value with a different trapdoor
         let neg_arb_values: Vec<_> = arb_values
@@ -471,7 +491,13 @@ mod tests {
             .sum::<Result<ValueSum, OverflowError>>()
             .expect("we generate values that won't overflow");
 
-        let values = [native_values, arb_values, &neg_arb_values].concat();
+        let values = [
+            native_values,
+            arb_values,
+            &neg_arb_values,
+            arb_values_to_burn,
+        ]
+        .concat();
 
         let bsk = values
             .iter()
@@ -480,14 +506,20 @@ mod tests {
             .into_bsk();
 
         let bvk = (values
-            .iter()
-            .map(|(value, rcv, asset)| ValueCommitment::derive(*value, *rcv, *asset))
+            .into_iter()
+            .map(|(value, rcv, asset)| ValueCommitment::derive(value, rcv, asset))
             .sum::<ValueCommitment>()
             - ValueCommitment::derive(
                 native_value_balance,
                 ValueCommitTrapdoor::zero(),
                 AssetId::native(),
-            ))
+            )
+            - arb_values_to_burn
+                .iter()
+                .map(|(value, _, asset)| {
+                    ValueCommitment::derive(*value, ValueCommitTrapdoor::zero(), *asset)
+                })
+                .sum::<ValueCommitment>())
         .into_bvk();
 
         assert_eq!(redpallas::VerificationKey::from(&bsk), bvk);
@@ -495,34 +527,26 @@ mod tests {
 
     proptest! {
         #[test]
-        fn bsk_consistent_with_bvk_native_only(
-            native_values in (1usize..10).prop_flat_map(|n_values|
-                arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
-                    prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), native_asset_id()), n_values)
-                )
-            ),
-        ) {
-            // Test with native note type (zec) only
-            _bsk_consistent_with_bvk(&native_values, &[], &[]);
-        }
-    }
-
-    proptest! {
-        #[test]
-        fn bsk_consistent_with_bvk(
+        fn bsk_consistent_with_bvk_native_with_zsa_transfer_and_burning(
             native_values in (1usize..10).prop_flat_map(|n_values|
                 arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
                     prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), native_asset_id()), n_values)
                 )
             ),
-            (arb_values,neg_trapdoors) in (1usize..10).prop_flat_map(|n_values|
+            (asset_values, neg_trapdoors) in (1usize..10).prop_flat_map(|n_values|
                 (arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
                     prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), arb_asset_id()), n_values)
                 ), prop::collection::vec(arb_trapdoor(), n_values))
             ),
+            burn_values in (1usize..10).prop_flat_map(|n_values|
+                arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64)
+                .prop_flat_map(move |bound| prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), arb_asset_id()), n_values))
+            )
         ) {
-            // Test with native note type (zec)
-             _bsk_consistent_with_bvk(&native_values, &arb_values, &neg_trapdoors);
+            check_binding_signature(&native_values, &[], &[], &[]);
+            check_binding_signature(&native_values, &[], &[], &burn_values);
+            check_binding_signature(&native_values, &asset_values, &neg_trapdoors, &[]);
+            check_binding_signature(&native_values, &asset_values, &neg_trapdoors, &burn_values);
         }
     }
 }
diff --git a/tests/zsa.rs b/tests/zsa.rs
index f65b18616..9aad802d5 100644
--- a/tests/zsa.rs
+++ b/tests/zsa.rs
@@ -231,32 +231,31 @@ struct TestOutputInfo {
 fn build_and_verify_bundle(
     spends: Vec<&TestSpendInfo>,
     outputs: Vec<TestOutputInfo>,
+    assets_to_burn: Vec<(AssetId, NoteValue)>,
     anchor: Anchor,
     expected_num_actions: usize,
     keys: &Keychain,
-) {
+) -> Result<(), &'static str> {
     let rng = OsRng;
     let shielded_bundle: Bundle<_, i64> = {
         let mut builder = Builder::new(Flags::from_parts(true, true), anchor);
 
-        spends.iter().for_each(|spend| {
-            assert_eq!(
-                builder.add_spend(keys.fvk().clone(), spend.note, spend.merkle_path().clone()),
-                Ok(())
-            );
-        });
-        outputs.iter().for_each(|output| {
-            assert_eq!(
-                builder.add_recipient(None, keys.recipient, output.value, output.asset, None),
-                Ok(())
-            )
-        });
+        spends.iter().try_for_each(|spend| {
+            builder.add_spend(keys.fvk().clone(), spend.note, spend.merkle_path().clone())
+        })?;
+        outputs.iter().try_for_each(|output| {
+            builder.add_recipient(None, keys.recipient, output.value, output.asset, None)
+        })?;
+        assets_to_burn
+            .into_iter()
+            .try_for_each(|(asset, value)| builder.add_burn(asset, value))?;
         build_and_sign_bundle(builder, rng, keys.pk(), keys.sk())
     };
 
     // Verify the shielded bundle, currently without the proof.
     verify_bundle(&shielded_bundle, &keys.vk, false);
     assert_eq!(shielded_bundle.actions().len(), expected_num_actions);
+    Ok(())
 }
 
 /// Issue several ZSA and native notes and spend them in different combinations, e.g. split and join
@@ -268,20 +267,32 @@ fn zsa_issue_and_transfer() {
     let asset_descr = "zsa_asset";
 
     // Prepare ZSA
-    let (zsa_note1, zsa_note2) = issue_zsa_notes(asset_descr, &keys);
+    let (zsa_note_1, zsa_note_2) = issue_zsa_notes(asset_descr, &keys);
 
     let (merkle_path1, merkle_path2, anchor) =
-        build_merkle_path_with_two_leaves(&zsa_note1, &zsa_note2);
+        build_merkle_path_with_two_leaves(&zsa_note_1, &zsa_note_2);
 
     let zsa_spend_1 = TestSpendInfo {
-        note: zsa_note1,
+        note: zsa_note_1,
         merkle_path: merkle_path1,
     };
     let zsa_spend_2 = TestSpendInfo {
-        note: zsa_note2,
+        note: zsa_note_2,
         merkle_path: merkle_path2,
     };
 
+    let native_note = create_native_note(&keys);
+    let (native_merkle_path_1, native_merkle_path_2, native_anchor) =
+        build_merkle_path_with_two_leaves(&native_note, &zsa_note_1);
+    let native_spend: TestSpendInfo = TestSpendInfo {
+        note: native_note,
+        merkle_path: native_merkle_path_1,
+    };
+    let zsa_spend_with_native: TestSpendInfo = TestSpendInfo {
+        note: zsa_note_1,
+        merkle_path: native_merkle_path_2,
+    };
+
     // --------------------------- Tests -----------------------------------------
 
     // 1. Spend single ZSA note
@@ -291,10 +302,12 @@ fn zsa_issue_and_transfer() {
             value: zsa_spend_1.note.value(),
             asset: zsa_spend_1.note.asset(),
         }],
+        vec![],
         anchor,
         2,
         &keys,
-    );
+    )
+    .unwrap();
 
     // 2. Split single ZSA note into 2 notes
     let delta = 2; // arbitrary number for value manipulation
@@ -310,10 +323,12 @@ fn zsa_issue_and_transfer() {
                 asset: zsa_spend_1.note.asset(),
             },
         ],
+        vec![],
         anchor,
         2,
         &keys,
-    );
+    )
+    .unwrap();
 
     // 3. Join 2 ZSA notes into a single note
     build_and_verify_bundle(
@@ -324,10 +339,12 @@ fn zsa_issue_and_transfer() {
             ),
             asset: zsa_spend_1.note.asset(),
         }],
+        vec![],
         anchor,
         2,
         &keys,
-    );
+    )
+    .unwrap();
 
     // 4. Take 2 ZSA notes and send them as 2 notes with different denomination
     build_and_verify_bundle(
@@ -342,10 +359,12 @@ fn zsa_issue_and_transfer() {
                 asset: zsa_spend_2.note.asset(),
             },
         ],
+        vec![],
         anchor,
         2,
         &keys,
-    );
+    )
+    .unwrap();
 
     // 5. Spend single ZSA note, mixed with native note (shielding)
     build_and_verify_bundle(
@@ -360,24 +379,14 @@ fn zsa_issue_and_transfer() {
                 asset: AssetId::native(),
             },
         ],
+        vec![],
         anchor,
         4,
         &keys,
-    );
+    )
+    .unwrap();
 
     // 6. Spend single ZSA note, mixed with native note (shielded to shielded)
-    let native_note = create_native_note(&keys);
-    let (native_merkle_path1, native_merkle_path2, native_anchor) =
-        build_merkle_path_with_two_leaves(&native_note, &zsa_note1);
-    let native_spend: TestSpendInfo = TestSpendInfo {
-        note: native_note,
-        merkle_path: native_merkle_path1,
-    };
-    let zsa_spend_with_native: TestSpendInfo = TestSpendInfo {
-        note: zsa_note1,
-        merkle_path: native_merkle_path2,
-    };
-
     build_and_verify_bundle(
         vec![&zsa_spend_with_native, &native_spend],
         vec![
@@ -390,21 +399,23 @@ fn zsa_issue_and_transfer() {
                 asset: AssetId::native(),
             },
         ],
+        vec![],
         native_anchor,
         4,
         &keys,
-    );
+    )
+    .unwrap();
 
     // 7. Spend ZSA notes of different asset types
     let (zsa_note_t7, _) = issue_zsa_notes("zsa_asset2", &keys);
     let (merkle_path_t7_1, merkle_path_t7_2, anchor_t7) =
-        build_merkle_path_with_two_leaves(&zsa_note_t7, &zsa_note2);
+        build_merkle_path_with_two_leaves(&zsa_note_t7, &zsa_note_2);
     let zsa_spend_t7_1: TestSpendInfo = TestSpendInfo {
         note: zsa_note_t7,
         merkle_path: merkle_path_t7_1,
     };
     let zsa_spend_t7_2: TestSpendInfo = TestSpendInfo {
-        note: zsa_note2,
+        note: zsa_note_2,
         merkle_path: merkle_path_t7_2,
     };
 
@@ -420,10 +431,12 @@ fn zsa_issue_and_transfer() {
                 asset: zsa_spend_t7_2.note.asset(),
             },
         ],
+        vec![],
         anchor_t7,
         4,
         &keys,
-    );
+    )
+    .unwrap();
 
     // 8. Same but wrong denomination
     let result = std::panic::catch_unwind(|| {
@@ -439,10 +452,54 @@ fn zsa_issue_and_transfer() {
                     asset: zsa_spend_t7_2.note.asset(),
                 },
             ],
+            vec![],
             anchor_t7,
             4,
             &keys,
-        );
+        )
+        .unwrap();
     });
     assert!(result.is_err());
+
+    // 9. Burn ZSA assets
+    build_and_verify_bundle(
+        vec![&zsa_spend_1],
+        vec![],
+        vec![(zsa_spend_1.note.asset(), zsa_spend_1.note.value())],
+        anchor,
+        2,
+        &keys,
+    )
+    .unwrap();
+
+    // 10. Burn a partial amount of the ZSA assets
+    let value_to_burn = 3;
+    let value_to_transfer = zsa_spend_1.note.value().inner() - value_to_burn;
+
+    build_and_verify_bundle(
+        vec![&zsa_spend_1],
+        vec![TestOutputInfo {
+            value: NoteValue::from_raw(value_to_transfer),
+            asset: zsa_spend_1.note.asset(),
+        }],
+        vec![(zsa_spend_1.note.asset(), NoteValue::from_raw(value_to_burn))],
+        anchor,
+        2,
+        &keys,
+    )
+    .unwrap();
+
+    // 11. Try to burn native asset - should fail
+    let result = build_and_verify_bundle(
+        vec![&native_spend],
+        vec![],
+        vec![(AssetId::native(), native_spend.note.value())],
+        native_anchor,
+        2,
+        &keys,
+    );
+    match result {
+        Ok(_) => panic!("Test should fail"),
+        Err(error) => assert_eq!(error, "Burning is only possible for non-native assets"),
+    }
 }

From 5a50fb8d11361d3f7d1f3b2f6c0a468f88c0db49 Mon Sep 17 00:00:00 2001
From: Alexey Koren <alexey.koren@gmail.com>
Date: Sun, 18 Dec 2022 13:53:27 +0100
Subject: [PATCH 13/17] Create dummy spend in empty builder by default (#36)

---
 src/builder.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 4229cbb28..9dfaa9efb 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -387,7 +387,7 @@ impl Builder {
 
         // Pair up the spends and recipients, extending with dummy values as necessary.
         for (asset, (mut spends, mut recipients)) in
-            partition_by_asset(&self.spends, &self.recipients)
+            partition_by_asset(&self.spends, &self.recipients, &mut rng)
         {
             let num_spends = spends.len();
             let num_recipients = recipients.len();
@@ -475,10 +475,12 @@ impl Builder {
     }
 }
 
-/// partition a list of spends and recipients by note types.
+/// Partition a list of spends and recipients by note types.
+/// Method creates single dummy ZEC note if spends and recipients are both empty.
 fn partition_by_asset(
     spends: &[SpendInfo],
     recipients: &[RecipientInfo],
+    rng: &mut impl RngCore,
 ) -> HashMap<AssetId, (Vec<SpendInfo>, Vec<RecipientInfo>)> {
     let mut hm = HashMap::new();
 
@@ -496,6 +498,11 @@ fn partition_by_asset(
             .push(r.clone())
     }
 
+    if hm.is_empty() {
+        let dummy_spend = SpendInfo::dummy(AssetId::native(), rng);
+        hm.insert(dummy_spend.note.asset(), (vec![dummy_spend], vec![]));
+    }
+
     hm
 }
 

From efbfc197a972ba799adc6fff19dbdd415270fcc6 Mon Sep 17 00:00:00 2001
From: Alexey <alexey.koren@gmail.com>
Date: Tue, 20 Dec 2022 15:49:49 +0100
Subject: [PATCH 14/17] AssetID test vectors (#34)

---
 src/note/asset_id.rs                |   17 +
 src/test_vectors.rs                 |    1 +
 src/test_vectors/asset_id.rs        | 1032 +++++++++++++++++++++++++++
 src/test_vectors/note_encryption.rs |  240 +++----
 4 files changed, 1170 insertions(+), 120 deletions(-)
 create mode 100644 src/test_vectors/asset_id.rs

diff --git a/src/note/asset_id.rs b/src/note/asset_id.rs
index 6d9466e05..074e59364 100644
--- a/src/note/asset_id.rs
+++ b/src/note/asset_id.rs
@@ -129,4 +129,21 @@ pub mod testing {
             AssetId::derive(&IssuanceValidatingKey::from(&isk), &str)
         }
     }
+
+    #[test]
+    fn test_vectors() {
+        let test_vectors = crate::test_vectors::asset_id::test_vectors();
+
+        for tv in test_vectors {
+            let description = std::str::from_utf8(&tv.description).unwrap();
+
+            let calculated_asset_id = AssetId::derive(
+                &IssuanceValidatingKey::from_bytes(&tv.key).unwrap(),
+                description,
+            );
+            let test_vector_asset_id = AssetId::from_bytes(&tv.asset_id).unwrap();
+
+            assert_eq!(calculated_asset_id, test_vector_asset_id);
+        }
+    }
 }
diff --git a/src/test_vectors.rs b/src/test_vectors.rs
index 042f3b913..b70b56e56 100644
--- a/src/test_vectors.rs
+++ b/src/test_vectors.rs
@@ -1,3 +1,4 @@
+pub(crate) mod asset_id;
 pub(crate) mod commitment_tree;
 pub(crate) mod keys;
 pub(crate) mod merkle_path;
diff --git a/src/test_vectors/asset_id.rs b/src/test_vectors/asset_id.rs
new file mode 100644
index 000000000..c50c0f8f5
--- /dev/null
+++ b/src/test_vectors/asset_id.rs
@@ -0,0 +1,1032 @@
+// From https://github.com/zcash-hackworks/zcash-test-vectors/ (orchard_asset_id)
+
+pub(crate) struct TestVector {
+    pub(crate) key: [u8; 32],
+    pub(crate) description: [u8; 512],
+    pub(crate) asset_id: [u8; 32],
+}
+
+pub(crate) fn test_vectors() -> Vec<TestVector> {
+    vec![
+        TestVector {
+            key: [
+                0x85, 0xc8, 0xb5, 0xcd, 0x1a, 0xc3, 0xec, 0x3a, 0xd7, 0x09, 0x21, 0x32, 0xf9, 0x7f,
+                0x01, 0x78, 0xb0, 0x75, 0xc8, 0x1a, 0x13, 0x9f, 0xd4, 0x60, 0xbb, 0xe0, 0xdf, 0xcd,
+                0x75, 0x51, 0x47, 0x24,
+            ],
+            description: [
+                0xc5, 0xb3, 0xc8, 0xbe, 0xc8, 0x8a, 0xc8, 0x98, 0xcd, 0xbb, 0xc2, 0xb7, 0xc2, 0xa3,
+                0xc9, 0x8f, 0xc5, 0x94, 0xc2, 0xb5, 0xc8, 0x9d, 0x21, 0xc7, 0xbc, 0xc3, 0xb6, 0xc5,
+                0xa5, 0xc7, 0xae, 0xc4, 0x9c, 0xc6, 0xa4, 0xc3, 0x81, 0xe2, 0xb1, 0xa5, 0xc6, 0xb6,
+                0xc8, 0xb6, 0xc8, 0x88, 0xc3, 0x8c, 0xc6, 0x8e, 0x5d, 0x32, 0xc4, 0x9a, 0xc9, 0x84,
+                0xc6, 0xbf, 0xc7, 0x9b, 0xc8, 0x99, 0xc7, 0x9d, 0xc8, 0xbc, 0xcd, 0xb2, 0xc4, 0x9e,
+                0xc5, 0xa1, 0xc7, 0xa9, 0xc6, 0xbb, 0xc3, 0x80, 0xc8, 0xba, 0xc3, 0xa1, 0xc4, 0x84,
+                0x5f, 0xc7, 0xaa, 0xc5, 0xad, 0xc3, 0x80, 0xc6, 0xaf, 0xc3, 0x85, 0xc6, 0xb1, 0xc7,
+                0xbf, 0xc7, 0x93, 0xcd, 0xbc, 0xc3, 0xad, 0xc4, 0x94, 0xc5, 0xad, 0xc3, 0xb6, 0xc3,
+                0xa4, 0xc7, 0x9e, 0xc7, 0x81, 0x50, 0xc3, 0xb5, 0xc7, 0x86, 0xcd, 0xbd, 0xe1, 0x9b,
+                0x90, 0x23, 0xc6, 0x91, 0xc7, 0x85, 0xc6, 0x8a, 0xc6, 0x9a, 0xc7, 0x88, 0x4e, 0xe1,
+                0x9b, 0x9f, 0xe1, 0x9b, 0x93, 0xe1, 0x9a, 0xaf, 0xc6, 0xa1, 0xc8, 0xb1, 0xc7, 0x8d,
+                0xc5, 0x93, 0xc8, 0xa0, 0xc7, 0x86, 0x4e, 0xc6, 0xb4, 0xc3, 0x80, 0xce, 0x88, 0x77,
+                0xe1, 0x9b, 0xa4, 0xc2, 0xaf, 0xc5, 0x91, 0xc7, 0xa9, 0xc8, 0x83, 0x4d, 0xc8, 0x8b,
+                0x6b, 0xc7, 0x9b, 0xc7, 0x82, 0x57, 0xe2, 0xb1, 0xb3, 0xc5, 0x98, 0xc3, 0xb2, 0x61,
+                0xc5, 0x9b, 0xc3, 0xbe, 0x3f, 0xc5, 0xb5, 0xc3, 0x88, 0x31, 0xc7, 0xb7, 0xc3, 0xa0,
+                0xc5, 0xa2, 0x77, 0xc3, 0x94, 0xc7, 0xa7, 0xc3, 0xa4, 0x6c, 0xe1, 0x9b, 0x97, 0xe1,
+                0x9b, 0x81, 0xc2, 0xa5, 0xc8, 0x99, 0xc3, 0xa6, 0xc4, 0x9f, 0xc5, 0x89, 0xc8, 0xa2,
+                0xc4, 0xb3, 0xc5, 0x9a, 0xc6, 0x90, 0x48, 0xc3, 0x80, 0xc6, 0xb6, 0xc5, 0x92, 0xe1,
+                0x9b, 0xa8, 0xc2, 0xa3, 0xc7, 0xba, 0xc2, 0xa2, 0xc8, 0x87, 0xc3, 0xb1, 0xc7, 0xbb,
+                0x6d, 0xc8, 0xa2, 0xc7, 0xa2, 0xc6, 0xaf, 0xe1, 0x9b, 0xa3, 0xc3, 0x86, 0xe1, 0x9b,
+                0xa1, 0x60, 0x37, 0xc7, 0x91, 0x56, 0xc5, 0x95, 0xc4, 0xbc, 0xc5, 0xbe, 0xc4, 0x97,
+                0x5a, 0x31, 0xc5, 0x89, 0xc9, 0x83, 0xc8, 0xb4, 0xc6, 0xa4, 0xc7, 0xb5, 0xe1, 0x9b,
+                0x9e, 0xc3, 0xab, 0xcd, 0xb0, 0x56, 0xc7, 0x86, 0xc6, 0x99, 0xe1, 0x9b, 0x96, 0xc7,
+                0x90, 0xe1, 0x9b, 0x95, 0xc4, 0xaf, 0xc8, 0xac, 0xe2, 0xb1, 0xa7, 0xc3, 0x91, 0xc9,
+                0x8b, 0xc6, 0xad, 0xc5, 0x87, 0x5f, 0xe2, 0xb1, 0xb4, 0xc2, 0xb4, 0xc9, 0x8b, 0xc8,
+                0x9b, 0xc7, 0x80, 0xc6, 0xbb, 0xc2, 0xbd, 0xc8, 0xbb, 0xc4, 0xa2, 0x48, 0xc7, 0xa1,
+                0xc2, 0xa4, 0xc4, 0x86, 0xe2, 0xb1, 0xa8, 0xc6, 0x87, 0xc7, 0xb9, 0xe1, 0x9a, 0xa0,
+                0xc6, 0xb0, 0xc6, 0xad, 0xc9, 0x83, 0xc7, 0x99, 0xc4, 0x9e, 0xe1, 0x9a, 0xbf, 0xc7,
+                0xa6, 0x67, 0xc8, 0x95, 0xc3, 0x83, 0xe1, 0x9a, 0xa2, 0xce, 0x8a, 0x57, 0xc3, 0xa3,
+                0xc7, 0x81, 0xc6, 0xab, 0xc6, 0xbe, 0x7b, 0xc3, 0x9e, 0xc7, 0x88, 0xe1, 0x9a, 0xae,
+                0xc3, 0x94, 0xc6, 0x8e, 0xce, 0x88, 0xe1, 0x9b, 0x96, 0xc3, 0x85, 0xc4, 0xa9, 0xe2,
+                0xb1, 0xb4, 0xc7, 0xab, 0xe1, 0x9b, 0x8e, 0xc4, 0xa9, 0xe2, 0xb1, 0xa1, 0xe2, 0xb1,
+                0xa0, 0xc7, 0x96, 0xc3, 0xbe, 0xe1, 0x9a, 0xa2, 0xc4, 0xba, 0xe1, 0x9b, 0x95, 0xe2,
+                0xb1, 0xaa, 0xc5, 0x88, 0xc6, 0xa2, 0xe1, 0x9b, 0x99, 0xc2, 0xaa, 0xe1, 0x9a, 0xa7,
+                0xc6, 0x98, 0x72, 0xe1, 0x9b, 0x88, 0xc6, 0xa0, 0xc5, 0x8f, 0xc2, 0xa6, 0xc2, 0xb8,
+                0xc5, 0x8f, 0xc6, 0x9f, 0xc7, 0xb0, 0xc4, 0xb8, 0xc9, 0x8f, 0xc7, 0xac, 0x6e, 0x44,
+                0xe1, 0x9a, 0xba, 0xc3, 0xb3, 0xc3, 0x99, 0x5a,
+            ],
+            asset_id: [
+                0x29, 0xb8, 0x07, 0x86, 0xde, 0xf6, 0x7e, 0xee, 0xe1, 0xfa, 0x1e, 0xb2, 0x4f, 0xd9,
+                0xad, 0xf0, 0xab, 0xba, 0xe1, 0x70, 0x57, 0xeb, 0x4a, 0x04, 0x11, 0x13, 0xa4, 0x4e,
+                0x9a, 0x1c, 0x92, 0x33,
+            ],
+        },
+        TestVector {
+            key: [
+                0x43, 0x10, 0x6d, 0xe9, 0xa7, 0xec, 0x54, 0xdd, 0x36, 0xdf, 0xa7, 0x0b, 0xdb, 0xd9,
+                0x07, 0x2d, 0xbd, 0xda, 0xb5, 0xe0, 0x66, 0xaa, 0xef, 0xfc, 0xf9, 0xbb, 0xa3, 0x20,
+                0xd4, 0xff, 0xf7, 0x12,
+            ],
+            description: [
+                0x76, 0xc4, 0xb6, 0xc5, 0xb8, 0xe1, 0x9b, 0xa4, 0xc4, 0x9f, 0xc7, 0xb9, 0xc2, 0xb8,
+                0xc7, 0x95, 0xc6, 0xbf, 0xc9, 0x87, 0xc5, 0xb3, 0xe1, 0x9b, 0xa1, 0xc5, 0xa9, 0xc3,
+                0xa2, 0xc7, 0xb7, 0x77, 0xc6, 0xbf, 0xc6, 0xb5, 0xe1, 0x9a, 0xb6, 0xc3, 0xa2, 0xc5,
+                0xbf, 0xe1, 0x9b, 0x82, 0xc4, 0x9c, 0xc6, 0xab, 0xc4, 0xbc, 0xc5, 0xb8, 0xe1, 0x9a,
+                0xb6, 0xc7, 0xb7, 0xc2, 0xbe, 0xc7, 0x8e, 0xcd, 0xbd, 0xe1, 0x9a, 0xb4, 0xc8, 0x98,
+                0xc8, 0x93, 0xc5, 0xb9, 0xc7, 0xb8, 0xc4, 0x8d, 0xe1, 0x9b, 0x86, 0xc7, 0x85, 0xc7,
+                0x8e, 0xc4, 0x9f, 0xc5, 0xa3, 0x47, 0x7a, 0xc6, 0xa3, 0x5e, 0xe1, 0x9a, 0xa7, 0x66,
+                0xc8, 0x9a, 0x45, 0xc4, 0x94, 0xc9, 0x8e, 0xc7, 0x9b, 0xc8, 0xbf, 0xe1, 0x9a, 0xa4,
+                0x2b, 0xc6, 0xad, 0xc3, 0x9c, 0xc5, 0xbf, 0xc3, 0x91, 0xe1, 0x9b, 0xaf, 0xc5, 0x94,
+                0xe1, 0x9b, 0x8d, 0xc2, 0xbb, 0xc4, 0xab, 0xc3, 0x88, 0xc4, 0xac, 0xe1, 0x9b, 0x96,
+                0xcd, 0xb7, 0xc3, 0x97, 0x2b, 0x3c, 0xe1, 0x9b, 0x99, 0xc7, 0x91, 0xe1, 0x9a, 0xa4,
+                0xc4, 0x8e, 0xc7, 0xa7, 0xe2, 0xb1, 0xac, 0xc2, 0xbc, 0xc4, 0x82, 0xc3, 0x81, 0xc6,
+                0xb8, 0xe1, 0x9b, 0xa8, 0xe1, 0x9b, 0x95, 0xc4, 0xa4, 0xe1, 0x9b, 0xaa, 0xe1, 0x9a,
+                0xa0, 0xc5, 0xbe, 0xe1, 0x9b, 0x8a, 0x34, 0xc7, 0x82, 0x7d, 0xe1, 0x9a, 0xbe, 0xc4,
+                0x83, 0xe1, 0x9a, 0xa5, 0xc5, 0x8d, 0x51, 0xc8, 0xa9, 0xc9, 0x81, 0xc7, 0xa9, 0xc4,
+                0x8f, 0xe2, 0xb1, 0xa2, 0x58, 0xc3, 0x9d, 0xc6, 0x94, 0xce, 0x85, 0xc7, 0xbe, 0xc4,
+                0x89, 0x3c, 0xc2, 0xa3, 0xc7, 0xaf, 0xc3, 0x9b, 0xc7, 0xae, 0xc8, 0x89, 0xc9, 0x88,
+                0xc5, 0xa8, 0xe2, 0xb1, 0xa9, 0xc5, 0xa3, 0x67, 0xc6, 0xa8, 0xe1, 0x9a, 0xb3, 0xc7,
+                0x95, 0xc5, 0xa9, 0xc5, 0xa0, 0xc5, 0x84, 0xe1, 0x9a, 0xbf, 0xc7, 0xb4, 0xc9, 0x8a,
+                0xc4, 0xbc, 0xc5, 0xbb, 0xc7, 0x99, 0xc3, 0x8e, 0xe1, 0x9a, 0xb0, 0xc5, 0x87, 0xe2,
+                0xb1, 0xb0, 0xe1, 0x9a, 0xab, 0xc4, 0x8f, 0xc5, 0xb8, 0xc5, 0x90, 0xc5, 0xbc, 0xc3,
+                0x80, 0xc3, 0xbc, 0xc4, 0x8a, 0xc5, 0xbb, 0x64, 0x3e, 0xc2, 0xa7, 0xc6, 0xb3, 0xe2,
+                0xb1, 0xb6, 0xc8, 0xa4, 0x72, 0x71, 0xe1, 0x9b, 0x92, 0x3c, 0xc4, 0x99, 0xe2, 0xb1,
+                0xb5, 0xc7, 0x81, 0xc4, 0xbd, 0xc8, 0xa6, 0xc4, 0xa8, 0xe1, 0x9a, 0xa1, 0xc3, 0x85,
+                0xc6, 0x8f, 0xc2, 0xb9, 0xc7, 0x9b, 0xc7, 0xa7, 0xe1, 0x9a, 0xb3, 0xc8, 0x99, 0xc7,
+                0xb4, 0xe1, 0x9b, 0xa6, 0xc3, 0x94, 0xe1, 0x9b, 0x91, 0xc6, 0xb7, 0x31, 0xc7, 0xb2,
+                0xc3, 0x9e, 0xc7, 0xad, 0xc3, 0xa4, 0xc4, 0x97, 0xcd, 0xb5, 0xe1, 0x9a, 0xac, 0x63,
+                0xc7, 0x96, 0xe2, 0xb1, 0xa3, 0xc8, 0x86, 0xc4, 0x97, 0x37, 0xc5, 0xa9, 0xc2, 0xa5,
+                0xc4, 0xbf, 0xc7, 0x85, 0xc2, 0xa4, 0xe1, 0x9a, 0xa6, 0xc5, 0xba, 0xc6, 0xb3, 0xc5,
+                0xb5, 0x36, 0x4e, 0x6e, 0xc5, 0x90, 0xc3, 0x80, 0xc7, 0xbd, 0xc6, 0x88, 0xc3, 0xb4,
+                0xe2, 0xb1, 0xa6, 0xc8, 0xa4, 0xc8, 0xb0, 0xe1, 0x9a, 0xa0, 0xc3, 0x84, 0xc8, 0x8b,
+                0xcd, 0xbe, 0xc5, 0x80, 0xc8, 0x9e, 0xc3, 0x99, 0xc4, 0x8a, 0xc3, 0x83, 0x3e, 0x28,
+                0x4a, 0xe1, 0x9b, 0x85, 0xce, 0x87, 0xc5, 0x82, 0xc8, 0xbb, 0xc8, 0x8d, 0xc4, 0x88,
+                0xc6, 0x9e, 0xc6, 0x98, 0xc5, 0xbf, 0x45, 0xc7, 0xb2, 0xe1, 0x9a, 0xbb, 0xe1, 0x9b,
+                0x9a, 0xc4, 0xb5, 0xc2, 0xae, 0xc9, 0x80, 0xc6, 0x88, 0xc3, 0x8c, 0xc8, 0xa5, 0xc2,
+                0xb8, 0x35, 0xc7, 0xba, 0xc6, 0xac, 0x58, 0xc4, 0x97, 0x7e, 0xc7, 0x98, 0xc3, 0xbd,
+                0xc2, 0xb9, 0xc8, 0x99, 0xe1, 0x9b, 0x8c, 0x5a,
+            ],
+            asset_id: [
+                0x35, 0x52, 0x83, 0x87, 0xd4, 0x4d, 0x74, 0x21, 0xa9, 0x78, 0xad, 0x56, 0xe5, 0x33,
+                0xf3, 0x6e, 0x85, 0xec, 0xac, 0x44, 0x9f, 0x3b, 0x3f, 0x68, 0xe7, 0xff, 0x39, 0x7f,
+                0xae, 0x24, 0x5a, 0x99,
+            ],
+        },
+        TestVector {
+            key: [
+                0x6b, 0xfb, 0xe5, 0xc2, 0x42, 0x23, 0x94, 0xdc, 0x23, 0x76, 0xad, 0x10, 0x69, 0x3a,
+                0xbc, 0x1b, 0xf4, 0xa1, 0x6e, 0x18, 0x56, 0x5e, 0xbe, 0x79, 0x84, 0x1b, 0x95, 0x13,
+                0x45, 0x02, 0x53, 0x01,
+            ],
+            description: [
+                0xc7, 0x8e, 0x4f, 0xc2, 0xbb, 0x39, 0xc3, 0xa4, 0xc4, 0x94, 0xc5, 0xbb, 0xc5, 0xa6,
+                0xc2, 0xab, 0xc2, 0xba, 0xc7, 0x9e, 0xc5, 0x88, 0xc8, 0x9c, 0x57, 0xc3, 0xbc, 0xe2,
+                0xb1, 0xb7, 0xe1, 0x9a, 0xa9, 0x3a, 0xc3, 0x84, 0xc5, 0x9b, 0xc8, 0xb5, 0xc5, 0x80,
+                0xc9, 0x81, 0xc7, 0xa7, 0xc5, 0x92, 0xc6, 0x9b, 0xc7, 0x86, 0xc8, 0xba, 0xc6, 0x88,
+                0xc9, 0x85, 0xc3, 0xab, 0xc8, 0x94, 0xc8, 0x92, 0xc7, 0xa2, 0xc7, 0x82, 0xc4, 0x91,
+                0x74, 0x62, 0xc5, 0x9b, 0x42, 0xc8, 0xbe, 0xc3, 0xa7, 0xc4, 0xb8, 0xc2, 0xaf, 0xc6,
+                0x8d, 0x39, 0xc7, 0xb3, 0xc8, 0x97, 0xc8, 0x91, 0xc2, 0xbb, 0xc4, 0x87, 0xe1, 0x9b,
+                0x8a, 0xc2, 0xa7, 0xc7, 0xb4, 0xc4, 0xbb, 0xc2, 0xb2, 0xc8, 0x9a, 0xe1, 0x9a, 0xa3,
+                0xc3, 0x92, 0x36, 0xe1, 0x9b, 0x9d, 0xc7, 0x8f, 0xc8, 0x90, 0xc8, 0xb3, 0x36, 0x49,
+                0xc4, 0x92, 0xe1, 0x9b, 0x84, 0xc6, 0x94, 0xc8, 0xba, 0xc9, 0x8c, 0xc7, 0x85, 0xc6,
+                0x94, 0xc6, 0x87, 0xc6, 0xb6, 0xc4, 0xba, 0xc5, 0xb4, 0x51, 0xe1, 0x9a, 0xb7, 0xc3,
+                0xbb, 0xcd, 0xbb, 0xc7, 0x89, 0xc3, 0xba, 0xc6, 0x93, 0xc2, 0xa7, 0xc3, 0xa1, 0xc3,
+                0x8f, 0x7b, 0xc7, 0xa9, 0xc6, 0x92, 0x4b, 0xe1, 0x9b, 0xb0, 0xc8, 0xb3, 0xc5, 0x9a,
+                0xe1, 0x9a, 0xb8, 0x71, 0xc9, 0x88, 0x4c, 0x25, 0xc7, 0x9b, 0xe1, 0x9b, 0x9a, 0xc2,
+                0xb7, 0xc4, 0xb1, 0xe1, 0x9b, 0x97, 0x64, 0xe1, 0x9b, 0xa3, 0xc5, 0xb4, 0xe2, 0xb1,
+                0xb1, 0xc9, 0x8d, 0x60, 0xe1, 0x9b, 0xa7, 0xe1, 0x9b, 0xa3, 0xc5, 0x84, 0xc4, 0x94,
+                0xc7, 0xb8, 0xc8, 0x9c, 0x7c, 0xc3, 0xaa, 0x36, 0xc2, 0xa4, 0xc3, 0xa8, 0xe1, 0x9b,
+                0x9f, 0xc3, 0x95, 0xc8, 0xa1, 0xc3, 0xac, 0xc4, 0x99, 0xc7, 0xa4, 0xc8, 0x93, 0xc8,
+                0xb0, 0xc8, 0xa2, 0xc6, 0xb4, 0xc6, 0xa4, 0xe1, 0x9a, 0xaa, 0xc9, 0x85, 0xc2, 0xa5,
+                0xcd, 0xbd, 0xc4, 0x97, 0xc4, 0xb2, 0xc4, 0xa7, 0xc4, 0x91, 0xc7, 0xbe, 0xe2, 0xb1,
+                0xb4, 0xc9, 0x87, 0xc5, 0xab, 0xc7, 0x84, 0xc5, 0x9c, 0xe2, 0xb1, 0xaf, 0x55, 0xe2,
+                0xb1, 0xaf, 0x23, 0xc4, 0x8e, 0xc5, 0xba, 0xc5, 0xaf, 0xc8, 0xaf, 0xe2, 0xb1, 0xa0,
+                0x56, 0xc7, 0xb2, 0xc6, 0xb7, 0xc6, 0x90, 0xc6, 0x8d, 0x5e, 0xc6, 0xb5, 0xe1, 0x9a,
+                0xb7, 0xc3, 0x89, 0xc8, 0x91, 0xc6, 0x9a, 0x74, 0x4f, 0xc4, 0xb1, 0xc7, 0xae, 0xc4,
+                0xaa, 0xc3, 0xae, 0xc6, 0x9f, 0xc3, 0x99, 0xc8, 0x87, 0xe1, 0x9b, 0x9d, 0xe1, 0x9a,
+                0xa4, 0xe1, 0x9b, 0xad, 0xc8, 0x93, 0xc6, 0x94, 0xc8, 0x82, 0xc7, 0xa8, 0xc6, 0xba,
+                0xc6, 0x90, 0xc3, 0x88, 0xc6, 0xbb, 0xc9, 0x88, 0xc2, 0xa5, 0xc6, 0xad, 0xe1, 0x9a,
+                0xb0, 0xc4, 0xbb, 0x47, 0x2e, 0xc6, 0x92, 0xc6, 0x8b, 0xe1, 0x9a, 0xaa, 0xc7, 0x80,
+                0xe1, 0x9a, 0xa0, 0xc6, 0xab, 0xc3, 0xaf, 0xc8, 0xb9, 0xe1, 0x9b, 0x8f, 0xe1, 0x9a,
+                0xb9, 0xc3, 0xa9, 0xc5, 0x8e, 0x68, 0xc8, 0xaa, 0xc4, 0xb6, 0xe2, 0xb1, 0xbd, 0xe1,
+                0x9b, 0xad, 0xc7, 0xa6, 0xc5, 0x96, 0xc6, 0x82, 0xc7, 0x84, 0x3f, 0xc3, 0x97, 0xc4,
+                0xbe, 0xc8, 0x91, 0xc6, 0xaa, 0x41, 0xc4, 0xa9, 0xc6, 0x80, 0xc2, 0xb7, 0xe2, 0xb1,
+                0xb1, 0xc2, 0xa3, 0xc6, 0xa8, 0xe1, 0x9a, 0xa7, 0xc2, 0xaf, 0xc8, 0x83, 0xe1, 0x9b,
+                0xac, 0x37, 0xc4, 0x8f, 0xc5, 0xb9, 0xe2, 0xb1, 0xb8, 0xc3, 0x8f, 0xc6, 0xb1, 0xc4,
+                0xaa, 0xc5, 0x97, 0xe2, 0xb1, 0xab, 0xe1, 0x9b, 0x80, 0x58, 0xe1, 0x9b, 0x8b, 0xc8,
+                0xb8, 0x2c, 0x21, 0x36, 0xc5, 0xb3, 0xc6, 0xaa, 0xc7, 0x8a, 0xc4, 0xa3, 0xc4, 0xb6,
+                0xc5, 0xa4, 0xc5, 0x92, 0xe1, 0x9a, 0xbf, 0x5a,
+            ],
+            asset_id: [
+                0xf5, 0x4b, 0x0c, 0x9b, 0xad, 0x5a, 0x85, 0x26, 0x2b, 0x8a, 0x3b, 0xa4, 0x13, 0x6a,
+                0x5b, 0x4c, 0xf3, 0x23, 0x85, 0xca, 0x49, 0x2f, 0x09, 0x4a, 0x42, 0xb2, 0xf6, 0xad,
+                0x65, 0xc1, 0x07, 0x33,
+            ],
+        },
+        TestVector {
+            key: [
+                0xab, 0x90, 0x15, 0x62, 0x52, 0x72, 0xe1, 0xe7, 0xba, 0x69, 0x0a, 0xe0, 0x09, 0xa9,
+                0x92, 0xe4, 0x9d, 0xe1, 0x9f, 0x33, 0xfc, 0xde, 0xb9, 0xf1, 0x71, 0xab, 0x1a, 0xaf,
+                0x28, 0x88, 0xc6, 0x0e,
+            ],
+            description: [
+                0xce, 0x88, 0xcd, 0xb5, 0xc6, 0x9f, 0xc6, 0xa5, 0xc8, 0x9e, 0xc7, 0xb2, 0xc7, 0xbc,
+                0x7d, 0xc3, 0xb9, 0xc5, 0x84, 0xc5, 0x8b, 0xc4, 0x9a, 0xc3, 0xb4, 0xc7, 0x9a, 0xe2,
+                0xb1, 0xa1, 0xc7, 0xb4, 0xc3, 0x8d, 0xe1, 0x9a, 0xab, 0xc7, 0x92, 0xe1, 0x9b, 0xaa,
+                0xc5, 0x88, 0x26, 0xc5, 0xba, 0xc4, 0xad, 0xc5, 0xb5, 0xc3, 0xa3, 0xc5, 0xa8, 0x30,
+                0xc5, 0xaf, 0xc8, 0x96, 0xe1, 0x9b, 0xa6, 0xe1, 0x9b, 0xa9, 0xc2, 0xb2, 0xc7, 0xaa,
+                0xc4, 0x93, 0xc8, 0x8f, 0xc5, 0xac, 0xe1, 0x9a, 0xa7, 0xc4, 0x89, 0xc8, 0xbc, 0xc3,
+                0xb9, 0xc6, 0xb6, 0xe1, 0x9b, 0x99, 0xc7, 0xae, 0xc4, 0xa6, 0xc7, 0xb9, 0x7c, 0xce,
+                0x88, 0xc3, 0xbe, 0xc5, 0x9c, 0xc8, 0x82, 0xc6, 0x88, 0xc7, 0x9a, 0xc6, 0xbb, 0xcd,
+                0xb6, 0xc7, 0x8a, 0xc5, 0x88, 0xe1, 0x9a, 0xa2, 0x52, 0xc4, 0xae, 0xc2, 0xa9, 0xc5,
+                0x9b, 0xc4, 0x83, 0x74, 0xc8, 0x9e, 0xc3, 0xb4, 0xc3, 0x82, 0x30, 0xc3, 0xbd, 0xc3,
+                0x87, 0xc8, 0xba, 0xc5, 0xb1, 0xc8, 0x85, 0x6b, 0xc4, 0xb7, 0xc5, 0x9d, 0x57, 0xc7,
+                0x90, 0xc6, 0xb9, 0x45, 0xc4, 0x9f, 0xc7, 0x8d, 0xc5, 0xa8, 0xc5, 0x8f, 0xc3, 0xaf,
+                0xc3, 0xb3, 0xc3, 0xb3, 0xc3, 0xb1, 0xc2, 0xac, 0xc5, 0xb7, 0xe2, 0xb1, 0xa2, 0xc8,
+                0xbb, 0xc7, 0xa7, 0xe1, 0x9a, 0xb9, 0xc5, 0xb2, 0xc5, 0xbd, 0xc6, 0xaf, 0xc3, 0xac,
+                0xe1, 0x9b, 0xb0, 0xc7, 0x9d, 0xc4, 0x8a, 0xc6, 0xa9, 0xc5, 0xaa, 0xc3, 0x8e, 0xc2,
+                0xa7, 0xc7, 0xaa, 0xc4, 0x90, 0x66, 0xe2, 0xb1, 0xb7, 0xe1, 0x9a, 0xbc, 0xc6, 0xbc,
+                0xc5, 0x91, 0xc8, 0xbb, 0x44, 0xce, 0x8c, 0xc8, 0x84, 0xc8, 0x92, 0xe1, 0x9a, 0xbb,
+                0xe1, 0x9a, 0xa2, 0xc6, 0x88, 0xc7, 0xb7, 0xc6, 0xa1, 0xe1, 0x9b, 0x90, 0xc4, 0xa2,
+                0xc4, 0x92, 0x36, 0xc6, 0xb8, 0xc4, 0xaa, 0xc2, 0xb3, 0xe1, 0x9b, 0x81, 0xc9, 0x87,
+                0xc7, 0xbc, 0x3b, 0xc8, 0xbc, 0xc8, 0x8e, 0xc3, 0xaa, 0xc9, 0x8a, 0xc6, 0x94, 0xe2,
+                0xb1, 0xb4, 0xc5, 0x9a, 0xe1, 0x9b, 0x92, 0xc8, 0xa2, 0xc4, 0xb6, 0xc4, 0x91, 0xcd,
+                0xbe, 0xc8, 0xac, 0xc4, 0xb5, 0xcd, 0xbc, 0x3d, 0xe1, 0x9b, 0xa7, 0xc2, 0xab, 0xc2,
+                0xa8, 0xc6, 0xb0, 0xc4, 0x84, 0xc3, 0xb5, 0xe1, 0x9a, 0xb8, 0xc6, 0x96, 0xc3, 0x99,
+                0x65, 0x56, 0xc3, 0xb9, 0xc8, 0xb0, 0xc4, 0xb2, 0xcd, 0xb6, 0x71, 0xc3, 0xb8, 0xc7,
+                0xb6, 0xc8, 0x8b, 0xc3, 0xa3, 0xe1, 0x9b, 0x8f, 0x6c, 0xc4, 0xad, 0xc3, 0xa2, 0xc2,
+                0xb2, 0xe1, 0x9a, 0xb6, 0xe1, 0x9b, 0x98, 0xe1, 0x9b, 0xae, 0xc8, 0xa2, 0xc2, 0xb6,
+                0xc8, 0xb3, 0xc6, 0xbe, 0xe1, 0x9b, 0x85, 0xe1, 0x9b, 0x90, 0xe1, 0x9b, 0x89, 0xc3,
+                0xbc, 0xe2, 0xb1, 0xa2, 0xc5, 0xb3, 0xc3, 0x84, 0xc7, 0x95, 0xc5, 0x9d, 0xc4, 0xba,
+                0xe2, 0xb1, 0xb6, 0xc2, 0xa8, 0x78, 0xc8, 0xad, 0xc3, 0xae, 0xc6, 0x88, 0xc3, 0x9e,
+                0xc3, 0xa9, 0xc3, 0x9d, 0xe2, 0xb1, 0xaf, 0xc5, 0x8c, 0xe2, 0xb1, 0xa1, 0xc5, 0xbc,
+                0xe1, 0x9a, 0xab, 0xc8, 0xbf, 0xc7, 0x8b, 0xc6, 0xb2, 0x21, 0xc3, 0x93, 0xc5, 0xa5,
+                0x6d, 0xcd, 0xb2, 0xe1, 0x9b, 0x88, 0x5e, 0xe1, 0x9a, 0xb6, 0xc5, 0xb1, 0xc7, 0x87,
+                0xc8, 0x9a, 0xc7, 0xa6, 0xc2, 0xaf, 0xe1, 0x9b, 0xa6, 0xc4, 0x86, 0xc2, 0xb1, 0x29,
+                0xe1, 0x9a, 0xb9, 0xc7, 0x90, 0xc9, 0x8a, 0xc4, 0xab, 0xe1, 0x9b, 0x8e, 0xc7, 0x90,
+                0xe1, 0x9a, 0xa7, 0xe1, 0x9b, 0xa5, 0xc6, 0xb8, 0xc4, 0xa6, 0xe1, 0x9b, 0x8a, 0xc5,
+                0xb2, 0xc6, 0xa8, 0xc6, 0x8e, 0xc2, 0xbe, 0xc8, 0xbd, 0xc8, 0xa5, 0xc5, 0xa5, 0xc6,
+                0x90, 0x3f, 0xc7, 0xa8, 0xc4, 0xaf, 0xc2, 0xaa,
+            ],
+            asset_id: [
+                0xe2, 0xc6, 0x6a, 0x5e, 0x81, 0xaf, 0x85, 0x65, 0x05, 0x7c, 0x42, 0xab, 0x5a, 0x5b,
+                0x5b, 0xb8, 0xc3, 0xca, 0x18, 0x13, 0xbe, 0x45, 0x76, 0xd8, 0xea, 0xe8, 0xb2, 0x50,
+                0xfd, 0xe9, 0xfd, 0x95,
+            ],
+        },
+        TestVector {
+            key: [
+                0x06, 0xd4, 0x75, 0x14, 0x97, 0x0d, 0x02, 0xd3, 0xf8, 0x43, 0xfb, 0x9b, 0x96, 0x51,
+                0x08, 0x75, 0xa7, 0xa6, 0xc0, 0x15, 0x68, 0x1d, 0x06, 0xe0, 0xb1, 0x5b, 0x8a, 0x92,
+                0x1f, 0xbd, 0x81, 0x30,
+            ],
+            description: [
+                0xe1, 0x9a, 0xa5, 0xe1, 0x9a, 0xb5, 0xc7, 0xb1, 0x2b, 0x72, 0xc6, 0x83, 0xc3, 0x82,
+                0xe1, 0x9b, 0x8e, 0x34, 0xe1, 0x9b, 0x98, 0x3c, 0xc2, 0xa5, 0xc8, 0xbe, 0x2c, 0xc3,
+                0x82, 0xc3, 0xa4, 0xe2, 0xb1, 0xa3, 0xc5, 0xab, 0xc3, 0xb4, 0xc7, 0xb8, 0xc2, 0xa2,
+                0xc6, 0x86, 0xc6, 0xad, 0xc3, 0x9a, 0xc5, 0x93, 0xc7, 0xa3, 0xc2, 0xb7, 0xc6, 0x9a,
+                0x5f, 0x55, 0xc9, 0x8c, 0xc9, 0x89, 0x58, 0xc6, 0x95, 0xe1, 0x9a, 0xba, 0xc7, 0x80,
+                0xc2, 0xb4, 0xe1, 0x9b, 0x9b, 0xc4, 0x90, 0xe1, 0x9b, 0x8b, 0xe1, 0x9a, 0xae, 0xc8,
+                0x92, 0xe1, 0x9b, 0xa8, 0xe2, 0xb1, 0xb2, 0xcd, 0xbd, 0xc3, 0x98, 0xe1, 0x9a, 0xba,
+                0xe1, 0x9a, 0xb0, 0x48, 0xc6, 0xa4, 0x2f, 0xc5, 0x9d, 0xe1, 0x9b, 0x86, 0xe1, 0x9a,
+                0xb5, 0x7c, 0xc5, 0xa5, 0xe1, 0x9a, 0xba, 0xc4, 0x86, 0xc8, 0xa6, 0xc6, 0xa6, 0xc6,
+                0x84, 0xc3, 0xbb, 0xc5, 0xbe, 0x6e, 0xe1, 0x9b, 0xa6, 0xc5, 0x95, 0xe1, 0x9b, 0xaa,
+                0xc7, 0xb7, 0xe2, 0xb1, 0xbd, 0xce, 0x8c, 0xc3, 0xa6, 0xc6, 0x9e, 0xc4, 0xb5, 0xe1,
+                0x9a, 0xa4, 0xc3, 0xa8, 0xc7, 0x9c, 0xc4, 0x82, 0xc2, 0xa6, 0x31, 0xc3, 0xa6, 0xe2,
+                0xb1, 0xae, 0xc7, 0xbb, 0x26, 0xc7, 0xa0, 0xc5, 0x9d, 0xc5, 0xb9, 0xe1, 0x9a, 0xb4,
+                0xe1, 0x9b, 0xad, 0xc7, 0x88, 0x30, 0x42, 0xc6, 0x9f, 0xc3, 0x9b, 0x25, 0xc4, 0x9c,
+                0xce, 0x87, 0xc5, 0x9c, 0xc5, 0x8c, 0xe1, 0x9b, 0x81, 0xce, 0x89, 0xc4, 0x9a, 0xc5,
+                0xa7, 0xe1, 0x9a, 0xa9, 0xc3, 0x93, 0xc7, 0x9b, 0xc3, 0x8d, 0xc3, 0xbe, 0xc3, 0x93,
+                0xc8, 0xbc, 0xc8, 0xb3, 0xc5, 0xaf, 0xc7, 0xb3, 0xe1, 0x9a, 0xa7, 0xc4, 0x80, 0xc4,
+                0x80, 0xcd, 0xb2, 0xc7, 0x82, 0xc4, 0x83, 0xc7, 0x88, 0xc6, 0x84, 0xe1, 0x9b, 0x90,
+                0xc3, 0xa4, 0xc3, 0xbc, 0xc5, 0xad, 0xc6, 0x8b, 0xc2, 0xac, 0xc4, 0xa1, 0xc3, 0xae,
+                0xce, 0x86, 0xe1, 0x9b, 0x94, 0xc5, 0x9e, 0xc6, 0x92, 0xe1, 0x9b, 0xac, 0xc3, 0x8d,
+                0xc5, 0xb9, 0xc3, 0x82, 0xc8, 0x81, 0xe2, 0xb1, 0xbb, 0xc8, 0xa0, 0xc2, 0xbd, 0xc5,
+                0xa2, 0xc6, 0x86, 0xc3, 0xb7, 0xe1, 0x9a, 0xad, 0xc5, 0xbc, 0x2c, 0x51, 0xe1, 0x9a,
+                0xab, 0xe1, 0x9b, 0x99, 0x77, 0xc3, 0x9c, 0xc6, 0x9c, 0x31, 0x60, 0xc5, 0x8e, 0xc3,
+                0xb5, 0xc3, 0x85, 0xe1, 0x9b, 0xad, 0xc9, 0x8f, 0xc4, 0x8b, 0xc5, 0x93, 0xc2, 0xa2,
+                0xc6, 0x8a, 0xe1, 0x9a, 0xa3, 0x4a, 0xc3, 0x9e, 0x30, 0xc8, 0xae, 0xc7, 0xbc, 0xcd,
+                0xb3, 0xc7, 0x94, 0xe1, 0x9b, 0x93, 0xc3, 0x93, 0xc3, 0xaa, 0xc4, 0xad, 0xc8, 0x91,
+                0xc5, 0xac, 0xe1, 0x9b, 0xa6, 0x26, 0x74, 0xc6, 0xbd, 0xe1, 0x9b, 0xa3, 0xc9, 0x8e,
+                0xc8, 0x94, 0xc5, 0xad, 0xc6, 0xac, 0xc6, 0xb7, 0xc7, 0xa5, 0xc3, 0xa5, 0xc8, 0xb4,
+                0xc6, 0x95, 0xc8, 0x93, 0xc8, 0xbc, 0xc8, 0xb9, 0xe1, 0x9b, 0x86, 0xc3, 0xb2, 0xc2,
+                0xb5, 0xc5, 0x92, 0xe1, 0x9b, 0xa2, 0xe2, 0xb1, 0xb2, 0xc8, 0x80, 0xc4, 0x90, 0xe1,
+                0x9a, 0xb9, 0xe2, 0xb1, 0xa7, 0xc5, 0xab, 0xc5, 0xa6, 0xc6, 0xaa, 0xc5, 0x98, 0xc4,
+                0xb0, 0xc7, 0xb0, 0xe1, 0x9a, 0xbe, 0xe1, 0x9a, 0xaa, 0xc5, 0xb7, 0xc4, 0x96, 0xc7,
+                0xa1, 0xc6, 0xbc, 0xe1, 0x9a, 0xb5, 0xc3, 0x87, 0xc8, 0xa5, 0x73, 0xc3, 0x84, 0xc4,
+                0xa6, 0xc6, 0x9d, 0xc5, 0xa9, 0xc5, 0xaa, 0xc7, 0xa6, 0xc6, 0x9e, 0xc8, 0xbc, 0xe1,
+                0x9a, 0xbf, 0xc6, 0xa3, 0xc3, 0x99, 0xc5, 0x97, 0xe2, 0xb1, 0xa0, 0xc4, 0x9e, 0x74,
+                0xc4, 0x90, 0xc6, 0xa0, 0xe1, 0x9b, 0xaa, 0xc7, 0xaf, 0xc5, 0x8c, 0xc4, 0x91, 0xc7,
+                0x93, 0xe1, 0x9b, 0xa3, 0xc5, 0xbd, 0xc8, 0xa3,
+            ],
+            asset_id: [
+                0x9e, 0xa8, 0x07, 0x5c, 0x02, 0xdf, 0xe4, 0x64, 0x18, 0x07, 0xe0, 0x7d, 0x2d, 0x8a,
+                0x84, 0x6c, 0x1f, 0xfb, 0xaf, 0x66, 0x86, 0x85, 0x74, 0x5c, 0x04, 0x5a, 0xf9, 0xe3,
+                0x6c, 0xbe, 0x91, 0xb9,
+            ],
+        },
+        TestVector {
+            key: [
+                0x3d, 0x8b, 0xb6, 0x41, 0x5a, 0x53, 0x0b, 0xb2, 0x0f, 0x0d, 0x70, 0x2e, 0x8c, 0xb8,
+                0x0b, 0xc1, 0xd5, 0xae, 0x41, 0x66, 0x5c, 0x53, 0x14, 0x4c, 0xfb, 0x60, 0x6e, 0x58,
+                0x6a, 0xbc, 0x03, 0x33,
+            ],
+            description: [
+                0xc3, 0x92, 0xcd, 0xb4, 0xc2, 0xaa, 0xc2, 0xb7, 0x78, 0xc5, 0x8d, 0xc5, 0x8f, 0xc5,
+                0x84, 0xe1, 0x9b, 0x9c, 0xc4, 0x8f, 0xc3, 0x9a, 0xc6, 0x8f, 0x42, 0xc4, 0x94, 0x50,
+                0x3a, 0xc5, 0x9f, 0x60, 0xc8, 0xa5, 0x21, 0xc3, 0xa2, 0x3a, 0xe1, 0x9a, 0xb1, 0xc5,
+                0x88, 0xc5, 0x81, 0xc6, 0x9d, 0xc7, 0x95, 0xc4, 0xa1, 0x55, 0x3f, 0x48, 0xc9, 0x8a,
+                0xc4, 0x8d, 0xc3, 0xbf, 0xe1, 0x9b, 0x8e, 0xc6, 0x8e, 0xc4, 0xbb, 0xe1, 0x9b, 0x9f,
+                0xe1, 0x9a, 0xb9, 0xc4, 0xb1, 0xe1, 0x9a, 0xb3, 0xe1, 0x9b, 0x9b, 0xc6, 0x84, 0xe1,
+                0x9a, 0xac, 0x2b, 0x51, 0xc5, 0x99, 0xe1, 0x9a, 0xb3, 0xc3, 0xb8, 0xc6, 0x99, 0xc8,
+                0x9b, 0xe1, 0x9a, 0xbc, 0xc8, 0xa4, 0xe1, 0x9b, 0x84, 0x6e, 0xc4, 0x83, 0x5e, 0xe1,
+                0x9a, 0xa8, 0xc6, 0xad, 0xc5, 0x82, 0xc8, 0xa4, 0xc4, 0x8a, 0xe2, 0xb1, 0xab, 0xc6,
+                0x89, 0xe1, 0x9b, 0x8c, 0xc8, 0x8d, 0xe1, 0x9a, 0xb2, 0xe2, 0xb1, 0xb1, 0xc5, 0x87,
+                0xe2, 0xb1, 0xad, 0xc4, 0xab, 0x50, 0xc2, 0xb9, 0xc7, 0xae, 0xc5, 0x99, 0xc3, 0x8a,
+                0xc3, 0xbc, 0xc4, 0xa9, 0xe1, 0x9b, 0xa6, 0xc8, 0x92, 0xc4, 0xa7, 0xc2, 0xbd, 0xc2,
+                0xbb, 0xc8, 0xb2, 0xcd, 0xbd, 0xe1, 0x9b, 0xa0, 0xc2, 0xbe, 0x63, 0xc5, 0xae, 0x69,
+                0xc4, 0x90, 0x2e, 0xc4, 0xb0, 0x53, 0xc3, 0x83, 0xc5, 0xa7, 0xc3, 0xb1, 0xc2, 0xb1,
+                0xc6, 0x8a, 0xc8, 0x85, 0xc6, 0xb0, 0x46, 0xc2, 0xb6, 0xc9, 0x88, 0xc4, 0xa5, 0xc7,
+                0xb9, 0xc5, 0xb5, 0xc8, 0x80, 0xc4, 0xa8, 0xc8, 0x87, 0xc5, 0x8d, 0xc4, 0x97, 0xc8,
+                0x86, 0xc2, 0xa8, 0xc4, 0xa9, 0xc6, 0x99, 0xc3, 0x98, 0xc4, 0x97, 0xc8, 0xb1, 0xce,
+                0x84, 0xe1, 0x9a, 0xb0, 0xc6, 0x86, 0xc4, 0x97, 0xc6, 0xab, 0xe2, 0xb1, 0xac, 0xc8,
+                0xa5, 0xc8, 0xa9, 0xc5, 0x80, 0x65, 0x51, 0xc8, 0x87, 0xe1, 0x9b, 0x95, 0xc4, 0x88,
+                0xe1, 0x9b, 0xb0, 0xc6, 0x9d, 0xc5, 0xa8, 0xc8, 0x8b, 0xc7, 0xb4, 0xc4, 0xb9, 0xc7,
+                0xb2, 0xc4, 0xb4, 0xe1, 0x9b, 0x9c, 0xc2, 0xbb, 0xe2, 0xb1, 0xa9, 0xc4, 0xa7, 0xc7,
+                0x86, 0xc8, 0xac, 0xe2, 0xb1, 0xb1, 0xe1, 0x9b, 0x81, 0x71, 0xc4, 0x8d, 0xc7, 0x97,
+                0x33, 0xc3, 0x83, 0xc9, 0x8a, 0xc6, 0xb3, 0xc4, 0xb0, 0xc3, 0xb1, 0xe2, 0xb1, 0xac,
+                0xe1, 0x9b, 0x91, 0xc6, 0x96, 0xc2, 0xb5, 0xc7, 0xac, 0x29, 0x6d, 0x36, 0xc6, 0x91,
+                0xc4, 0xa8, 0xc4, 0xb1, 0xc7, 0x8d, 0xce, 0x8c, 0xc3, 0x88, 0x6b, 0xc7, 0xbd, 0xc7,
+                0x98, 0xc8, 0x95, 0xc7, 0xa2, 0xe2, 0xb1, 0xa0, 0xc7, 0xa0, 0x46, 0x31, 0x2e, 0xc6,
+                0x81, 0xc8, 0x96, 0xc8, 0x8f, 0xe1, 0x9b, 0x98, 0xc4, 0xb3, 0xc8, 0xb8, 0xe1, 0x9a,
+                0xb2, 0xc8, 0x9e, 0xc5, 0x83, 0xc7, 0x87, 0xc6, 0xa1, 0xc2, 0xae, 0x43, 0xc8, 0xb3,
+                0xc4, 0x89, 0xc3, 0x9e, 0xe1, 0x9b, 0x96, 0xc5, 0x84, 0x33, 0xc9, 0x87, 0x69, 0xce,
+                0x88, 0xc8, 0xac, 0xc5, 0x87, 0xc5, 0x87, 0xe1, 0x9b, 0x8b, 0xc4, 0x89, 0xc5, 0xb0,
+                0xc4, 0x9f, 0xe1, 0x9b, 0x97, 0xc7, 0xa8, 0xc8, 0xb3, 0xc7, 0x83, 0xc4, 0x91, 0xe1,
+                0x9a, 0xba, 0xc7, 0x82, 0xc7, 0xb0, 0xc4, 0xbd, 0xc5, 0xab, 0xe1, 0x9b, 0xac, 0xe2,
+                0xb1, 0xbe, 0xc4, 0x89, 0xc3, 0x8b, 0xe2, 0xb1, 0xae, 0xcd, 0xbe, 0xc4, 0x9b, 0xc4,
+                0xab, 0xc6, 0xbc, 0xe1, 0x9b, 0xac, 0xc4, 0x84, 0xc5, 0x9f, 0xc7, 0xac, 0xc3, 0xba,
+                0xc6, 0x83, 0xc3, 0x9b, 0xc6, 0xa6, 0xc6, 0xac, 0xc7, 0xb5, 0xc6, 0x8a, 0xc4, 0xbf,
+                0xe2, 0xb1, 0xaa, 0xc3, 0x96, 0x42, 0xc4, 0x95, 0xc3, 0xa2, 0xc6, 0xa5, 0x5b, 0x2e,
+                0xc3, 0xaf, 0xc3, 0x93, 0xc4, 0x9d, 0xc8, 0xa4,
+            ],
+            asset_id: [
+                0x02, 0xce, 0x39, 0x82, 0x1e, 0x86, 0x41, 0xcd, 0x79, 0x5c, 0x1e, 0x41, 0xf7, 0x48,
+                0x3c, 0x59, 0x88, 0x81, 0xb5, 0x0f, 0x88, 0xe7, 0x36, 0xcb, 0x4f, 0xb0, 0x00, 0xbc,
+                0xf0, 0x28, 0x62, 0x2b,
+            ],
+        },
+        TestVector {
+            key: [
+                0x95, 0xa6, 0xa5, 0x7f, 0x8e, 0x85, 0x43, 0x72, 0xf9, 0xce, 0x7d, 0xb1, 0x34, 0xfd,
+                0x9e, 0x87, 0x43, 0xbd, 0x39, 0x17, 0xe6, 0x50, 0x52, 0x93, 0x4c, 0xbd, 0xef, 0xa7,
+                0x67, 0xb7, 0xc7, 0x18,
+            ],
+            description: [
+                0xc7, 0x84, 0xc3, 0xb8, 0xc7, 0xba, 0xc6, 0xbc, 0xc6, 0xa3, 0x28, 0xc5, 0xb4, 0xc7,
+                0x8c, 0xc2, 0xba, 0xe1, 0x9b, 0xac, 0x3d, 0xc5, 0xb3, 0xc5, 0xbf, 0xc4, 0xb5, 0xce,
+                0x8a, 0xc5, 0xab, 0xc7, 0xbe, 0xc7, 0xa0, 0xc4, 0x95, 0xe1, 0x9b, 0xa8, 0xc3, 0xab,
+                0xc7, 0x99, 0xe1, 0x9a, 0xae, 0xcd, 0xb6, 0xe2, 0xb1, 0xb1, 0xc5, 0x8a, 0xe1, 0x9b,
+                0xab, 0xc5, 0xaa, 0xc7, 0xb8, 0xc6, 0xb2, 0x48, 0xe1, 0x9b, 0x94, 0xc8, 0xb4, 0xc7,
+                0x9e, 0xc8, 0x9b, 0x4f, 0xc7, 0xab, 0xc5, 0xa8, 0xc7, 0x9c, 0xc8, 0x9f, 0xc4, 0x8a,
+                0xc8, 0x98, 0xe1, 0x9a, 0xa6, 0xc4, 0xb7, 0xc3, 0xb8, 0xe1, 0x9b, 0x97, 0xc7, 0xb6,
+                0x57, 0xc4, 0xa0, 0xe1, 0x9b, 0x9f, 0xc5, 0x9a, 0xc2, 0xa7, 0x2c, 0xe1, 0x9a, 0xa4,
+                0xc6, 0x84, 0xcd, 0xba, 0xc7, 0x90, 0xc4, 0xae, 0xc4, 0xaf, 0xc2, 0xb1, 0xce, 0x84,
+                0xe1, 0x9a, 0xa0, 0xe1, 0x9b, 0xa9, 0xc4, 0xa0, 0xce, 0x86, 0xc3, 0x83, 0xc7, 0xab,
+                0xcd, 0xb4, 0xc5, 0x83, 0xc8, 0xbd, 0xc8, 0x98, 0xce, 0x89, 0x73, 0xe1, 0x9a, 0xa6,
+                0xc5, 0xa1, 0xc2, 0xa7, 0xc3, 0x81, 0xc9, 0x83, 0xc5, 0xbc, 0xc5, 0x9b, 0xc4, 0xbe,
+                0x5f, 0xc6, 0xb8, 0xe1, 0x9b, 0x86, 0x74, 0xc3, 0xb4, 0x40, 0xc8, 0xbc, 0xc8, 0x93,
+                0xc8, 0x9c, 0xc2, 0xa4, 0xe1, 0x9a, 0xb4, 0xc3, 0x98, 0xc5, 0x96, 0xe1, 0x9b, 0xa0,
+                0x7c, 0xe2, 0xb1, 0xa0, 0xc4, 0xb2, 0xc2, 0xb7, 0xce, 0x85, 0xc3, 0x8c, 0xc2, 0xa2,
+                0xc8, 0x9a, 0x4f, 0xc7, 0xae, 0xc4, 0xb5, 0xc7, 0x95, 0xc3, 0x8e, 0xc8, 0xa3, 0xe1,
+                0x9a, 0xa3, 0xc3, 0xa7, 0xc7, 0xb7, 0xc6, 0xaa, 0xc6, 0xb6, 0xc8, 0xbb, 0xc2, 0xa9,
+                0xe1, 0x9b, 0x8b, 0xc7, 0x9a, 0xc9, 0x84, 0xc3, 0xa2, 0x71, 0xc5, 0x83, 0xc3, 0x83,
+                0xc8, 0x86, 0xcd, 0xb2, 0xc4, 0xa7, 0xe1, 0x9b, 0x80, 0x58, 0xc5, 0x96, 0xe2, 0xb1,
+                0xb2, 0xe2, 0xb1, 0xbd, 0xc7, 0xbc, 0x4b, 0xcd, 0xbc, 0xc8, 0x88, 0xc4, 0x81, 0xc7,
+                0xb8, 0xc4, 0x8f, 0xc8, 0x8d, 0x26, 0xc7, 0x92, 0xc3, 0xa0, 0xc5, 0x8c, 0xc5, 0xbd,
+                0xc6, 0xb3, 0xc2, 0xa4, 0x67, 0xc8, 0x93, 0xc8, 0xac, 0xc9, 0x89, 0xc4, 0xbd, 0xc8,
+                0x82, 0xe2, 0xb1, 0xa9, 0xe1, 0x9b, 0xa2, 0x79, 0x54, 0xe1, 0x9b, 0x94, 0xc7, 0x96,
+                0xc8, 0xae, 0xc7, 0xba, 0xc8, 0xa3, 0xc6, 0xa3, 0xcd, 0xba, 0xc8, 0xa7, 0xc4, 0xa8,
+                0x3b, 0xc7, 0xb9, 0xc6, 0x83, 0xc8, 0x98, 0xc2, 0xb0, 0xe1, 0x9a, 0xae, 0xc8, 0x8c,
+                0xc3, 0xa3, 0xe1, 0x9a, 0xbd, 0x45, 0xc8, 0xb6, 0xc9, 0x80, 0x28, 0xe1, 0x9b, 0x81,
+                0x2b, 0x6d, 0xc8, 0xb9, 0xc7, 0x80, 0xe2, 0xb1, 0xad, 0xc8, 0x8d, 0x6c, 0x7b, 0xc6,
+                0x91, 0xc3, 0x93, 0xc8, 0xa9, 0xc7, 0xaf, 0xc5, 0x95, 0xe1, 0x9b, 0xa0, 0xc6, 0xbe,
+                0x21, 0xc4, 0xac, 0xc4, 0xa8, 0xe1, 0x9a, 0xbe, 0xc9, 0x8e, 0xc3, 0x88, 0xc4, 0x9e,
+                0xc4, 0xbe, 0xe1, 0x9b, 0x90, 0xc3, 0x99, 0xc7, 0x93, 0xc6, 0xa8, 0xe1, 0x9b, 0xa9,
+                0xe1, 0x9b, 0xa5, 0xc7, 0xa4, 0xc6, 0x81, 0xe1, 0x9b, 0x9a, 0xc3, 0xa0, 0xc5, 0xab,
+                0xc4, 0x86, 0xc8, 0xa4, 0x53, 0xce, 0x8c, 0xc9, 0x81, 0xc3, 0xb7, 0xc7, 0xaa, 0xc8,
+                0x8a, 0xc3, 0xa9, 0x41, 0xe1, 0x9b, 0xaa, 0xcd, 0xb7, 0xc3, 0xac, 0xc3, 0xbf, 0xc8,
+                0x8d, 0xc7, 0xa7, 0xc7, 0xa3, 0xe1, 0x9b, 0xa9, 0x5a, 0xc4, 0xb1, 0x68, 0xe2, 0xb1,
+                0xbf, 0x2a, 0x5b, 0xc8, 0xb6, 0xc5, 0xa0, 0x39, 0xc4, 0x8b, 0xc8, 0xae, 0x6c, 0xe2,
+                0xb1, 0xb5, 0xe1, 0x9b, 0x9b, 0xc5, 0x8c, 0xc5, 0x91, 0x68, 0xc6, 0xaf, 0xc9, 0x84,
+                0x44, 0xc7, 0x93, 0xc2, 0xb5, 0xc8, 0x90, 0x67,
+            ],
+            asset_id: [
+                0x7a, 0x8e, 0xea, 0x55, 0xfb, 0xde, 0x77, 0x4d, 0x8a, 0x7a, 0x5c, 0x01, 0xfa, 0x8e,
+                0xbc, 0x8c, 0x57, 0x5f, 0xf9, 0x33, 0xd9, 0xd1, 0x51, 0x9b, 0x62, 0xf3, 0x18, 0xf4,
+                0x8c, 0xa2, 0xab, 0x94,
+            ],
+        },
+        TestVector {
+            key: [
+                0xa3, 0x6d, 0xf3, 0x6a, 0xc7, 0xa2, 0xe2, 0xba, 0xab, 0xfd, 0x1e, 0x8d, 0xbf, 0x39,
+                0x3b, 0xd8, 0x25, 0x32, 0xec, 0x3d, 0x52, 0x3b, 0xbe, 0x85, 0x7f, 0x71, 0x58, 0x0c,
+                0xcd, 0x22, 0xdf, 0x08,
+            ],
+            description: [
+                0xc6, 0x81, 0xc4, 0x90, 0xe1, 0x9a, 0xa0, 0xe1, 0x9b, 0x8c, 0x40, 0xc8, 0x8d, 0xc7,
+                0xaf, 0xcd, 0xb2, 0xc5, 0xae, 0xc7, 0xb1, 0xce, 0x84, 0xc2, 0xb6, 0xc7, 0x99, 0xe1,
+                0x9a, 0xb4, 0xe1, 0x9b, 0xaf, 0xc6, 0x93, 0xc9, 0x83, 0x37, 0xe2, 0xb1, 0xb1, 0xc4,
+                0x98, 0xe1, 0x9b, 0xa7, 0xc8, 0x8f, 0xc3, 0x83, 0xc3, 0x82, 0xc4, 0x98, 0xc7, 0x9c,
+                0xc2, 0xae, 0xc8, 0x9a, 0xcd, 0xb5, 0xc3, 0xac, 0xc6, 0x9c, 0xc8, 0xab, 0xc6, 0xbd,
+                0x71, 0xc4, 0xaf, 0xe1, 0x9a, 0xa0, 0xe1, 0x9a, 0xb1, 0x23, 0xc5, 0xa8, 0xc4, 0xb9,
+                0x45, 0xe1, 0x9b, 0xa8, 0xc6, 0xb0, 0xc4, 0xa0, 0xc8, 0xa7, 0xe1, 0x9b, 0x9b, 0xc6,
+                0xa7, 0x79, 0xc7, 0xa8, 0xc7, 0xa1, 0xc7, 0xbd, 0xc3, 0xa1, 0xe2, 0xb1, 0xa2, 0xc3,
+                0x82, 0xc6, 0xa7, 0xc4, 0x9d, 0xc7, 0xbb, 0x64, 0xc2, 0xb0, 0xc4, 0x91, 0xe1, 0x9a,
+                0xbe, 0xc7, 0xaf, 0xe2, 0xb1, 0xaa, 0xc8, 0xa3, 0xe2, 0xb1, 0xbe, 0x3f, 0xc8, 0xa7,
+                0xe1, 0x9b, 0x9c, 0xe1, 0x9b, 0x88, 0xc8, 0xa0, 0xc8, 0x96, 0x28, 0xc6, 0xb7, 0xc7,
+                0xa2, 0xc6, 0x99, 0x66, 0xc8, 0x8c, 0xc3, 0x93, 0xc5, 0x8b, 0xc8, 0xa2, 0xc5, 0x91,
+                0xe2, 0xb1, 0xa6, 0xc3, 0xbd, 0xc3, 0xa4, 0xc6, 0x86, 0xe1, 0x9b, 0xa4, 0xc3, 0xbe,
+                0xc4, 0xbf, 0xc9, 0x88, 0xc6, 0x97, 0xcd, 0xb5, 0xc4, 0xb1, 0xc7, 0x92, 0xc3, 0x86,
+                0xc5, 0x80, 0xc5, 0x9c, 0xc5, 0x92, 0xc3, 0x80, 0xe1, 0x9a, 0xbd, 0xc6, 0x84, 0x46,
+                0xc6, 0xb6, 0xc6, 0x87, 0xc4, 0x95, 0xc3, 0xbe, 0xc3, 0xbc, 0xc2, 0xaf, 0xc2, 0xa9,
+                0xe1, 0x9a, 0xa1, 0xc3, 0xa4, 0xe1, 0x9b, 0xaf, 0xc5, 0x8f, 0xe1, 0x9b, 0x98, 0xc5,
+                0x91, 0x55, 0xc3, 0x99, 0xc8, 0xbf, 0xc7, 0xb4, 0x63, 0xc5, 0xa0, 0xc8, 0xa1, 0xe2,
+                0xb1, 0xb7, 0xc3, 0xaf, 0xc5, 0x8c, 0xc8, 0xab, 0xc8, 0x8b, 0x3c, 0xc3, 0x8d, 0xc6,
+                0x80, 0xc8, 0xa1, 0xc7, 0xb9, 0xc3, 0xbf, 0xc2, 0xa4, 0x4f, 0xc8, 0x82, 0xe2, 0xb1,
+                0xa8, 0xc2, 0xbd, 0x78, 0xe1, 0x9b, 0xac, 0xc5, 0x90, 0xc3, 0x94, 0xc3, 0xb8, 0xc7,
+                0xb7, 0xc3, 0x84, 0xe2, 0xb1, 0xaf, 0xc6, 0x88, 0xc7, 0x83, 0xc9, 0x8d, 0xc5, 0x9f,
+                0x78, 0xc3, 0xbb, 0xe2, 0xb1, 0xa7, 0xe2, 0xb1, 0xbc, 0xc5, 0x8d, 0xc6, 0xbd, 0xe2,
+                0xb1, 0xa5, 0xc4, 0x94, 0xc7, 0x91, 0xc8, 0x97, 0x63, 0xc3, 0x99, 0xc2, 0xb6, 0xc7,
+                0x99, 0xe1, 0x9a, 0xa2, 0xc7, 0xa0, 0xc8, 0xa6, 0xcd, 0xbc, 0xc6, 0x86, 0xe2, 0xb1,
+                0xb5, 0x42, 0xc2, 0xa1, 0xc8, 0x97, 0xc8, 0xa6, 0xc5, 0x98, 0xc4, 0xba, 0xc4, 0x88,
+                0xc3, 0x80, 0x59, 0xc8, 0xa0, 0xc6, 0xa7, 0xc4, 0xb5, 0xc8, 0x8e, 0xc3, 0xa1, 0x7c,
+                0xc6, 0xae, 0xc2, 0xaa, 0x7c, 0xc8, 0xaa, 0xc2, 0xb8, 0xc4, 0xa9, 0xc7, 0xa8, 0xc3,
+                0x98, 0xc9, 0x82, 0xc8, 0x87, 0xc3, 0x98, 0xc5, 0x9d, 0xc9, 0x8b, 0xc4, 0x87, 0xce,
+                0x86, 0xc8, 0x96, 0xc2, 0xa5, 0x66, 0xe2, 0xb1, 0xbb, 0xc4, 0x9f, 0xc7, 0xaa, 0xc8,
+                0x93, 0xc4, 0xbe, 0xe2, 0xb1, 0xac, 0x5c, 0xc3, 0x8f, 0x44, 0xcd, 0xb4, 0x53, 0x31,
+                0xc8, 0xaf, 0xc2, 0xbd, 0xc4, 0x85, 0xc4, 0xa1, 0xc5, 0xaf, 0xc8, 0xa2, 0xc8, 0x95,
+                0xc6, 0x95, 0xe1, 0x9b, 0xac, 0xc4, 0x95, 0x2b, 0x4e, 0x78, 0xc5, 0xbf, 0xc7, 0x89,
+                0xc7, 0x9c, 0xc3, 0x9b, 0x72, 0xcd, 0xbc, 0xc8, 0x93, 0xc6, 0x93, 0xc3, 0xa5, 0x66,
+                0xe1, 0x9a, 0xbf, 0xc3, 0xa6, 0xc5, 0x84, 0xc4, 0xbd, 0xe2, 0xb1, 0xaf, 0xc4, 0x92,
+                0x4e, 0xc5, 0x8c, 0xe1, 0x9b, 0xae, 0xc3, 0xac, 0xce, 0x88, 0xc7, 0xb5, 0xc3, 0xa8,
+                0xe1, 0x9a, 0xab, 0xc7, 0x95, 0xe2, 0xb1, 0xbd,
+            ],
+            asset_id: [
+                0xbe, 0x14, 0xb4, 0xa7, 0x43, 0x0a, 0x90, 0xa9, 0x50, 0xd5, 0x8d, 0xd7, 0xbb, 0x10,
+                0x72, 0x0e, 0xb9, 0x50, 0xb2, 0x4e, 0x6f, 0x27, 0xce, 0x85, 0x4a, 0x80, 0xf6, 0x4a,
+                0x19, 0x24, 0xcd, 0x28,
+            ],
+        },
+        TestVector {
+            key: [
+                0x68, 0x89, 0x11, 0x8f, 0xa9, 0xe7, 0xda, 0xf2, 0x76, 0xfd, 0x62, 0xcb, 0x66, 0x5a,
+                0xbf, 0x50, 0x72, 0x20, 0x15, 0xc2, 0xa0, 0x8b, 0x13, 0xf7, 0x7d, 0x20, 0x24, 0x75,
+                0x96, 0x26, 0xc5, 0x03,
+            ],
+            description: [
+                0xc2, 0xaa, 0xc2, 0xb5, 0xc2, 0xa5, 0xc7, 0xbc, 0xc3, 0x9a, 0xc9, 0x83, 0xc3, 0x8f,
+                0x25, 0xc5, 0x83, 0xc3, 0x86, 0xc4, 0xa4, 0xc3, 0xac, 0xc7, 0xbf, 0xc3, 0x93, 0xc6,
+                0x95, 0x42, 0x3b, 0xe1, 0x9b, 0x96, 0xc7, 0x85, 0xc3, 0x84, 0x23, 0xc3, 0xb9, 0x53,
+                0xc6, 0xb0, 0xc2, 0xac, 0xc4, 0x94, 0xe1, 0x9a, 0xba, 0xc9, 0x8c, 0xc8, 0x8e, 0xce,
+                0x87, 0xc7, 0x8f, 0xc8, 0xbb, 0x79, 0xc3, 0xb4, 0x36, 0xc5, 0x9c, 0xc4, 0x9b, 0xe1,
+                0x9a, 0xb4, 0x51, 0xc5, 0xb3, 0x2b, 0xc7, 0x93, 0xe1, 0x9b, 0xa7, 0xc5, 0x93, 0xe1,
+                0x9b, 0x9b, 0xc6, 0x81, 0xc4, 0xa8, 0xc8, 0x9a, 0xe1, 0x9b, 0x90, 0xc8, 0x9b, 0xc3,
+                0xa5, 0xc4, 0xbd, 0xc7, 0x8b, 0xe1, 0x9b, 0xad, 0xc5, 0xa0, 0xe1, 0x9a, 0xb5, 0x5e,
+                0x69, 0x78, 0xc5, 0xbc, 0xc7, 0x8e, 0xc4, 0x8b, 0xc4, 0xa9, 0xc6, 0x91, 0xc5, 0xa8,
+                0xc5, 0xbe, 0xc4, 0xb0, 0xc5, 0x96, 0xe1, 0x9a, 0xac, 0xe2, 0xb1, 0xbf, 0xc8, 0xae,
+                0xc3, 0x97, 0xc6, 0x8a, 0xc4, 0x9b, 0xc8, 0x9b, 0xc7, 0x89, 0xe1, 0x9a, 0xbd, 0xe1,
+                0x9b, 0x89, 0xc9, 0x86, 0xc7, 0x91, 0xe1, 0x9b, 0x96, 0xe1, 0x9a, 0xa4, 0xc8, 0xad,
+                0xcd, 0xb0, 0xce, 0x87, 0xc5, 0xb7, 0x5d, 0xe1, 0x9b, 0x9b, 0xc9, 0x80, 0xc3, 0x9b,
+                0xc3, 0x85, 0xc3, 0x9a, 0xc6, 0xb7, 0xe1, 0x9b, 0x89, 0xc2, 0xb6, 0xe1, 0x9a, 0xac,
+                0xe1, 0x9b, 0x8f, 0xc2, 0xb3, 0xcd, 0xbd, 0xc3, 0x85, 0xc6, 0x90, 0x32, 0xc7, 0xab,
+                0xe2, 0xb1, 0xac, 0xc8, 0x8a, 0xc4, 0x86, 0xc5, 0x98, 0xc5, 0x90, 0xc8, 0x9c, 0xc3,
+                0x8e, 0xc8, 0x96, 0xc5, 0xa8, 0xc3, 0xa4, 0x7c, 0xc6, 0xb9, 0xc5, 0xa8, 0xc3, 0xa5,
+                0x36, 0xc2, 0xa3, 0x7a, 0xc5, 0xb1, 0xc7, 0xb0, 0xc5, 0xb6, 0x61, 0xc5, 0x80, 0xc9,
+                0x84, 0xc6, 0xb0, 0xc5, 0x8f, 0xe1, 0x9b, 0x9a, 0xc6, 0xb0, 0xcd, 0xb7, 0xe1, 0x9b,
+                0x8a, 0xc6, 0xba, 0xe1, 0x9b, 0x9e, 0x3e, 0x57, 0xc8, 0x9c, 0xc6, 0x9b, 0x5e, 0xc8,
+                0xa7, 0xc8, 0x98, 0xc5, 0xbc, 0xc3, 0x9d, 0xc3, 0xa4, 0xe1, 0x9a, 0xbd, 0xe1, 0x9b,
+                0x81, 0xc6, 0xbf, 0x6c, 0xc4, 0xbd, 0xc4, 0xbe, 0xe1, 0x9b, 0x8a, 0x75, 0x6c, 0xc5,
+                0x97, 0xc8, 0xbc, 0xc5, 0x9e, 0xc5, 0x94, 0xe1, 0x9a, 0xa5, 0xc9, 0x81, 0xc6, 0x88,
+                0xe1, 0x9b, 0x85, 0xe2, 0xb1, 0xbe, 0x49, 0xc5, 0xa6, 0xc4, 0xb7, 0xc9, 0x88, 0xe1,
+                0x9a, 0xa6, 0xc5, 0x91, 0xc5, 0xa5, 0xce, 0x8c, 0x56, 0xc3, 0x99, 0xc4, 0x9e, 0xc2,
+                0xb4, 0xc3, 0x8b, 0x53, 0x2c, 0xc7, 0xb8, 0x3a, 0xc7, 0x81, 0xc6, 0xb3, 0xe1, 0x9b,
+                0xaf, 0xc3, 0xaa, 0xc7, 0xa7, 0xc3, 0xbe, 0xe2, 0xb1, 0xb7, 0xe1, 0x9a, 0xb4, 0x5c,
+                0x7c, 0xc2, 0xbf, 0xe1, 0x9a, 0xb3, 0xc8, 0xb6, 0xc6, 0x8e, 0xe1, 0x9b, 0xae, 0xc5,
+                0xaf, 0xe1, 0x9b, 0x90, 0xc6, 0xab, 0xc5, 0xb2, 0xe1, 0x9b, 0x81, 0x49, 0xe1, 0x9b,
+                0xa4, 0xc3, 0x80, 0x75, 0xc4, 0x9c, 0xc8, 0x96, 0xe1, 0x9a, 0xae, 0x5d, 0xc4, 0xba,
+                0xe1, 0x9b, 0x86, 0x2b, 0xe2, 0xb1, 0xb0, 0xc4, 0x9d, 0xe2, 0xb1, 0xb9, 0xc6, 0xb5,
+                0xc3, 0xb2, 0xc6, 0x87, 0xc5, 0x9c, 0xc5, 0x94, 0xc6, 0x92, 0xc3, 0x86, 0xc5, 0x82,
+                0xc6, 0xb7, 0x47, 0xc6, 0x8b, 0xcd, 0xbd, 0xcd, 0xbd, 0xc7, 0xad, 0xc7, 0x97, 0xc2,
+                0xa1, 0xc8, 0xa8, 0xe1, 0x9a, 0xbd, 0xc7, 0xad, 0xc4, 0xac, 0xc8, 0x99, 0x6c, 0x36,
+                0x5f, 0xc5, 0x89, 0xc4, 0x87, 0xc4, 0x80, 0xc2, 0xbe, 0xe2, 0xb1, 0xbd, 0xc4, 0x8f,
+                0xc4, 0xb1, 0xc3, 0x83, 0xc5, 0xbd, 0xc6, 0xa5, 0xc5, 0xb9, 0xc5, 0xa5, 0xc6, 0xba,
+                0x6e, 0xc8, 0xaa, 0x6d, 0xc4, 0x80, 0x7c, 0x5a,
+            ],
+            asset_id: [
+                0xac, 0xa7, 0x66, 0x43, 0xac, 0xdd, 0x83, 0xe3, 0x8e, 0xe5, 0xcf, 0xe0, 0xe7, 0xd2,
+                0x99, 0xd6, 0x35, 0x69, 0x0a, 0x82, 0xba, 0x96, 0x51, 0x47, 0xe2, 0xa4, 0x48, 0x24,
+                0x9b, 0xee, 0xb2, 0x88,
+            ],
+        },
+        TestVector {
+            key: [
+                0x7a, 0xb9, 0xe5, 0xa6, 0x04, 0x28, 0x8a, 0x55, 0x0b, 0x9e, 0x08, 0x7a, 0x00, 0x4b,
+                0xb8, 0x8b, 0xe4, 0xb2, 0xb4, 0x8d, 0xb3, 0x3f, 0xb0, 0x80, 0x97, 0xf8, 0xbc, 0x64,
+                0x60, 0x3e, 0xf8, 0x1f,
+            ],
+            description: [
+                0xc7, 0xad, 0x3b, 0xc8, 0x91, 0xc6, 0x96, 0xe1, 0x9a, 0xbd, 0xe1, 0x9a, 0xa6, 0xce,
+                0x87, 0xc3, 0x83, 0xc3, 0x84, 0xe1, 0x9b, 0x84, 0xc9, 0x8a, 0xc4, 0x97, 0xc9, 0x87,
+                0xe2, 0xb1, 0xba, 0xc6, 0x93, 0xc6, 0x98, 0xe2, 0xb1, 0xb7, 0xc6, 0x8e, 0xc8, 0x8f,
+                0xc9, 0x84, 0xc2, 0xbe, 0x55, 0xc8, 0xb0, 0xc7, 0x82, 0xc2, 0xb2, 0xc6, 0x88, 0xcd,
+                0xb3, 0xc6, 0xb2, 0x2e, 0x2e, 0xc3, 0x87, 0xc9, 0x80, 0xc7, 0x9c, 0xc8, 0x9f, 0xc5,
+                0xb0, 0xc8, 0x9e, 0xc4, 0xbb, 0xc7, 0x81, 0x74, 0x6c, 0xc6, 0x8c, 0xc6, 0x8f, 0xe1,
+                0x9a, 0xb4, 0xc8, 0x94, 0xc2, 0xac, 0xc4, 0x8f, 0xc5, 0xb6, 0xc8, 0xb5, 0xc3, 0xb7,
+                0xcd, 0xb6, 0xc2, 0xb1, 0xc5, 0xb1, 0xc4, 0xa5, 0x40, 0x68, 0x58, 0x2b, 0xc5, 0xb7,
+                0xc4, 0x91, 0xc6, 0xa1, 0xc7, 0xa7, 0x79, 0xe1, 0x9b, 0xa6, 0xe2, 0xb1, 0xac, 0xc6,
+                0x99, 0x51, 0xc7, 0xaf, 0xcd, 0xb4, 0xe1, 0x9b, 0x8e, 0xe1, 0x9b, 0xad, 0xc8, 0x96,
+                0xe1, 0x9b, 0xad, 0xc3, 0xa1, 0xc6, 0x95, 0xc5, 0x98, 0xc6, 0x95, 0xc2, 0xaf, 0xe2,
+                0xb1, 0xac, 0xc4, 0xbe, 0xc5, 0xac, 0xc8, 0x85, 0xc5, 0xa9, 0xc4, 0x93, 0xc5, 0x9a,
+                0x6c, 0xc3, 0xae, 0xe1, 0x9a, 0xba, 0xc6, 0x85, 0xc6, 0x92, 0xc5, 0xa7, 0xc4, 0xa5,
+                0xc5, 0x80, 0xc6, 0xaa, 0xe2, 0xb1, 0xa5, 0xc4, 0xaa, 0xc8, 0x83, 0xc5, 0xad, 0xc9,
+                0x88, 0x7c, 0xc7, 0xa6, 0xe1, 0x9a, 0xb9, 0xc3, 0xa4, 0xc9, 0x84, 0xc5, 0xa3, 0xc3,
+                0xb6, 0xc5, 0x8c, 0xc8, 0xab, 0xc8, 0xa7, 0xc8, 0xb7, 0xc5, 0x9c, 0xc6, 0xb5, 0xc8,
+                0x8d, 0xc2, 0xb7, 0xc5, 0x93, 0xc5, 0xb7, 0xc7, 0xac, 0xcd, 0xbe, 0xc3, 0xa2, 0xc5,
+                0xa5, 0xc4, 0x8c, 0xe2, 0xb1, 0xbf, 0x66, 0xc5, 0xbf, 0xc6, 0x83, 0xc6, 0x99, 0xc2,
+                0xa2, 0xe1, 0x9b, 0xad, 0x7c, 0xc4, 0x9e, 0xc6, 0xa2, 0xc3, 0xb8, 0xc6, 0xb6, 0xc6,
+                0xaf, 0x72, 0xc6, 0xb1, 0xc6, 0x98, 0xc6, 0xb8, 0x49, 0xe1, 0x9a, 0xa6, 0x59, 0xe1,
+                0x9b, 0xa1, 0xc8, 0xb6, 0xc4, 0xa6, 0xc6, 0xbe, 0xc8, 0xa1, 0xe2, 0xb1, 0xa5, 0xe1,
+                0x9b, 0xa3, 0xc5, 0x8d, 0xc2, 0xb5, 0xc6, 0xa8, 0xc7, 0xbd, 0xc8, 0x8a, 0xe1, 0x9b,
+                0xb0, 0xc5, 0xaf, 0x56, 0xc8, 0x8b, 0x34, 0xc4, 0x94, 0xc4, 0xbc, 0x67, 0xc6, 0xb5,
+                0xc2, 0xb0, 0x63, 0xe1, 0x9b, 0x99, 0xc4, 0xa8, 0xc6, 0x9c, 0xe1, 0x9a, 0xbc, 0xe1,
+                0x9b, 0x8a, 0xc6, 0x99, 0x4b, 0xc6, 0xb2, 0xe1, 0x9b, 0xa2, 0xc8, 0x9f, 0xc5, 0x88,
+                0xc5, 0xb6, 0xc3, 0xb8, 0x6d, 0xe2, 0xb1, 0xa2, 0xc7, 0xb4, 0xcd, 0xb3, 0xc2, 0xa3,
+                0xc7, 0xa1, 0xc4, 0x83, 0xc7, 0xb1, 0xc8, 0x98, 0xc8, 0x84, 0x6b, 0xc7, 0x84, 0xc6,
+                0xb6, 0xe1, 0x9a, 0xb8, 0xc5, 0x93, 0xc8, 0x90, 0x79, 0xc8, 0xa3, 0xe1, 0x9a, 0xb0,
+                0xe1, 0x9b, 0xad, 0xc8, 0xb0, 0xc4, 0x9e, 0xe1, 0x9b, 0x9a, 0xc7, 0x97, 0x32, 0xc6,
+                0xb2, 0xc9, 0x83, 0xe1, 0x9b, 0x96, 0xc9, 0x8f, 0xc3, 0x8c, 0xe2, 0xb1, 0xad, 0xc4,
+                0xbd, 0xc3, 0xbe, 0xe1, 0x9b, 0x8b, 0xc8, 0x9d, 0xc6, 0x95, 0xc8, 0x8f, 0xc8, 0x9e,
+                0xc8, 0x83, 0x74, 0xc7, 0xbe, 0xe1, 0x9b, 0x8a, 0x3c, 0xc5, 0x93, 0x63, 0xc7, 0x98,
+                0x31, 0xc4, 0x82, 0x56, 0xe2, 0xb1, 0xa3, 0x53, 0xe1, 0x9b, 0xa4, 0xc7, 0x94, 0xc7,
+                0x9e, 0x2e, 0xcd, 0xbe, 0xc7, 0x9c, 0xc4, 0x90, 0xe2, 0xb1, 0xbe, 0xe2, 0xb1, 0xba,
+                0xc7, 0x82, 0xc5, 0xb2, 0xe1, 0x9a, 0xa4, 0xc6, 0xb2, 0xcd, 0xb2, 0xc3, 0xa5, 0xe1,
+                0x9b, 0xab, 0xc3, 0xa9, 0xc7, 0xa3, 0xc3, 0x8a, 0xc2, 0xa3, 0xc9, 0x82, 0x7b, 0xc6,
+                0xb3, 0x4b, 0xc4, 0xb6, 0xc4, 0x85, 0xc7, 0x8c,
+            ],
+            asset_id: [
+                0x03, 0x74, 0x69, 0x16, 0xa8, 0xa6, 0xb8, 0xff, 0xa0, 0x4d, 0x71, 0x95, 0xbc, 0x06,
+                0x74, 0x96, 0xa6, 0xce, 0xce, 0x35, 0x6a, 0x2a, 0x14, 0x6d, 0x69, 0x52, 0x9a, 0xea,
+                0xac, 0x10, 0x1a, 0xb8,
+            ],
+        },
+        TestVector {
+            key: [
+                0xa2, 0x4a, 0x5b, 0x4b, 0x0c, 0x62, 0xe0, 0xfb, 0x6f, 0x01, 0xdb, 0x56, 0x7c, 0x33,
+                0x3e, 0x12, 0x82, 0xe3, 0x70, 0xa6, 0x6f, 0x16, 0x8a, 0xe7, 0xf7, 0x7a, 0x3f, 0x16,
+                0xaf, 0x40, 0x8d, 0x12,
+            ],
+            description: [
+                0xe1, 0x9b, 0xad, 0xe1, 0x9a, 0xaf, 0x39, 0xc7, 0x92, 0xc4, 0x87, 0xc8, 0x8b, 0xe2,
+                0xb1, 0xa9, 0xe1, 0x9a, 0xbb, 0xe1, 0x9b, 0x97, 0xc6, 0x89, 0xc4, 0xb1, 0xc8, 0xa1,
+                0xc7, 0xad, 0xc7, 0x8a, 0xe1, 0x9a, 0xb4, 0xe1, 0x9a, 0xa4, 0xc5, 0x99, 0xe1, 0x9b,
+                0xa5, 0xcd, 0xb7, 0xc6, 0xa5, 0xc3, 0xb6, 0xe1, 0x9b, 0x9a, 0xe1, 0x9b, 0xab, 0xc5,
+                0x9a, 0x4d, 0xe1, 0x9b, 0x81, 0xe1, 0x9b, 0x8a, 0xc2, 0xbe, 0xc5, 0x88, 0xc6, 0xbd,
+                0xe2, 0xb1, 0xb8, 0xe2, 0xb1, 0xbb, 0xc5, 0x8d, 0xc2, 0xbc, 0xc6, 0x81, 0xc5, 0x9c,
+                0xe2, 0xb1, 0xb5, 0xc8, 0x95, 0x6d, 0xc3, 0x9b, 0xc2, 0xb3, 0x36, 0xc4, 0x88, 0xc6,
+                0xbf, 0xc7, 0xb6, 0xe1, 0x9b, 0xad, 0xc7, 0x8e, 0xe1, 0x9b, 0xa9, 0x69, 0xc3, 0xa5,
+                0xe2, 0xb1, 0xb3, 0xc7, 0xbb, 0xc6, 0x9f, 0xc3, 0xa7, 0xc3, 0xbe, 0xce, 0x86, 0xc6,
+                0xbd, 0xc6, 0x95, 0xc7, 0xa2, 0xc7, 0xbf, 0xc7, 0xad, 0xc4, 0x93, 0xc6, 0xb6, 0xc3,
+                0x8b, 0xe2, 0xb1, 0xbb, 0xc3, 0x96, 0xc8, 0xaa, 0xc7, 0xa9, 0xc8, 0x8e, 0xc2, 0xb9,
+                0xc8, 0x99, 0xc3, 0x93, 0xe1, 0x9b, 0x9c, 0xc2, 0xac, 0xc7, 0xbc, 0xc3, 0xb6, 0xc2,
+                0xa7, 0xc3, 0xa9, 0xcd, 0xbc, 0xe2, 0xb1, 0xbf, 0xe1, 0x9a, 0xb1, 0xc2, 0xb8, 0xc3,
+                0xb9, 0xe1, 0x9b, 0x9e, 0xc7, 0x88, 0xc5, 0x9e, 0xc6, 0xb9, 0xc4, 0x9e, 0xc6, 0x8e,
+                0x3e, 0xc8, 0x93, 0x74, 0x37, 0xe2, 0xb1, 0xb2, 0x58, 0xcd, 0xbe, 0xc6, 0x9a, 0x5c,
+                0xc8, 0x94, 0xe1, 0x9a, 0xb6, 0xc8, 0x90, 0xc5, 0x95, 0xe2, 0xb1, 0xa6, 0x23, 0xc5,
+                0xa2, 0xc3, 0x9c, 0xe2, 0xb1, 0xb4, 0xc4, 0x94, 0xc3, 0x97, 0xc6, 0x9f, 0xc3, 0x92,
+                0xcd, 0xbd, 0xc4, 0xbe, 0xc5, 0xba, 0xc6, 0xb0, 0x77, 0xc7, 0xba, 0xc5, 0xb0, 0xc3,
+                0x9b, 0xc5, 0xbf, 0xc7, 0xa3, 0xc3, 0xad, 0xc6, 0xbf, 0xc3, 0xbe, 0xc5, 0xab, 0xc7,
+                0xb9, 0xe1, 0x9b, 0xa9, 0xc5, 0xb3, 0xe1, 0x9a, 0xac, 0xe1, 0x9a, 0xa4, 0xc5, 0x9e,
+                0xc2, 0xa7, 0xcd, 0xbe, 0x4e, 0xe2, 0xb1, 0xb5, 0xc4, 0xb8, 0xe1, 0x9a, 0xbd, 0xe1,
+                0x9b, 0x83, 0xe2, 0xb1, 0xa2, 0xc6, 0xa4, 0xc6, 0xa6, 0xc7, 0xbc, 0xe1, 0x9b, 0x82,
+                0x44, 0xe1, 0x9a, 0xa4, 0xc3, 0xb3, 0xc5, 0xb1, 0xc3, 0xa5, 0xc7, 0xaa, 0x5b, 0xc6,
+                0x9c, 0xc7, 0x92, 0x2f, 0xc6, 0x86, 0xe1, 0x9b, 0xa5, 0xe1, 0x9a, 0xb5, 0x44, 0xc7,
+                0xb1, 0xc4, 0xac, 0xc8, 0xae, 0xe1, 0x9a, 0xa1, 0xc8, 0xaa, 0xc5, 0x9a, 0xc3, 0xac,
+                0xc8, 0xac, 0xe1, 0x9b, 0xa3, 0xc5, 0xab, 0xc7, 0x98, 0xe1, 0x9b, 0x93, 0x6e, 0xc7,
+                0x8a, 0xc4, 0x9f, 0xe1, 0x9b, 0x9b, 0xc7, 0x86, 0xe2, 0xb1, 0xb8, 0xc6, 0xaa, 0xc8,
+                0xa1, 0xc2, 0xbf, 0xc3, 0x97, 0xcd, 0xbd, 0xc8, 0x99, 0xc4, 0x98, 0xc3, 0x88, 0x3f,
+                0x4a, 0xc7, 0x99, 0xc4, 0x8a, 0xc7, 0x9a, 0xc5, 0xa9, 0xc7, 0xb5, 0xc7, 0x9b, 0xc5,
+                0xb1, 0xc5, 0xbf, 0xc7, 0x81, 0xc8, 0xb2, 0xc9, 0x89, 0xc5, 0xa4, 0xc8, 0x82, 0xc6,
+                0x91, 0xe1, 0x9a, 0xa8, 0xc7, 0xac, 0x6c, 0x64, 0xc4, 0x86, 0xc8, 0x8b, 0xc5, 0x99,
+                0xc6, 0x9a, 0xc3, 0x83, 0xc6, 0x8e, 0xc3, 0x9a, 0xc7, 0xa9, 0xc3, 0xb3, 0xe1, 0x9b,
+                0x8a, 0xc7, 0x94, 0xc7, 0xbb, 0xe1, 0x9a, 0xbb, 0xc6, 0xb4, 0xc6, 0xaf, 0xe1, 0x9b,
+                0xa8, 0xc2, 0xa1, 0x24, 0xe1, 0x9b, 0xab, 0xc8, 0xbb, 0xc3, 0xba, 0xe1, 0x9a, 0xb9,
+                0xc8, 0x92, 0xc8, 0xb2, 0xc5, 0xa6, 0xc5, 0xb3, 0xc4, 0x8d, 0xc5, 0xad, 0xc5, 0xa0,
+                0xc3, 0x9c, 0xe1, 0x9b, 0xae, 0xc7, 0xb2, 0xc4, 0x9b, 0xc6, 0xbb, 0xc5, 0xb0, 0xc7,
+                0xbb, 0xc7, 0xba, 0xc5, 0xb7, 0xc8, 0xa4, 0x5a,
+            ],
+            asset_id: [
+                0x0f, 0x1a, 0x21, 0x20, 0x6c, 0x80, 0xdb, 0x63, 0x73, 0xde, 0x95, 0x66, 0xe9, 0x06,
+                0xf1, 0x87, 0xe5, 0xea, 0x72, 0x84, 0x10, 0x86, 0x13, 0x86, 0x31, 0x77, 0x51, 0x0c,
+                0xee, 0x14, 0xd7, 0xb1,
+            ],
+        },
+        TestVector {
+            key: [
+                0xbe, 0xb4, 0x9a, 0x61, 0x01, 0x0b, 0x35, 0x51, 0xbc, 0x5c, 0xb2, 0xdb, 0xbc, 0xa6,
+                0x0b, 0x20, 0xb5, 0x31, 0x6e, 0x42, 0x21, 0xdc, 0x9c, 0xed, 0xb8, 0xc3, 0xc4, 0x62,
+                0xc1, 0xca, 0xcd, 0x02,
+            ],
+            description: [
+                0xc3, 0xa0, 0x26, 0xc8, 0xb0, 0xc3, 0x82, 0xc3, 0xb6, 0xc4, 0xa3, 0xc6, 0x85, 0xc3,
+                0x8f, 0xc9, 0x8a, 0xc4, 0x99, 0xc8, 0xb8, 0xc6, 0xaa, 0xc4, 0xa4, 0xe1, 0x9b, 0x99,
+                0xc6, 0x98, 0xe1, 0x9b, 0x99, 0xc6, 0x8a, 0x3c, 0xe1, 0x9b, 0x89, 0xc6, 0xa8, 0xc6,
+                0xb4, 0x33, 0xe1, 0x9b, 0xa1, 0xc6, 0xb7, 0xcd, 0xb2, 0xc6, 0xbc, 0xc7, 0x86, 0xc6,
+                0x9d, 0xc5, 0xac, 0xc2, 0xb7, 0xc6, 0x8a, 0xc7, 0xa5, 0xc3, 0x95, 0x35, 0xc3, 0x86,
+                0x44, 0xc3, 0x89, 0xc5, 0xa1, 0xe1, 0x9b, 0xaf, 0xc6, 0xae, 0x41, 0xc4, 0x99, 0xc3,
+                0xa8, 0x45, 0xe2, 0xb1, 0xb5, 0xc3, 0x83, 0x5f, 0x37, 0xc7, 0xbf, 0xe1, 0x9a, 0xa8,
+                0xc7, 0x8f, 0xc5, 0x92, 0x7e, 0xc3, 0xad, 0xe2, 0xb1, 0xb9, 0xe1, 0x9a, 0xa9, 0xc6,
+                0xa3, 0xc7, 0xbf, 0xcd, 0xb1, 0xc7, 0xb6, 0xe1, 0x9b, 0xa4, 0xe1, 0x9a, 0xb1, 0xe1,
+                0x9a, 0xb8, 0x41, 0xc7, 0x90, 0xc5, 0x8e, 0xe1, 0x9b, 0xad, 0xc3, 0xb8, 0xc6, 0xae,
+                0xc5, 0x9d, 0xc3, 0xb3, 0xc3, 0xbb, 0xc5, 0x97, 0xc7, 0x8f, 0xc8, 0xa4, 0xe1, 0x9b,
+                0xb0, 0x63, 0x39, 0xe2, 0xb1, 0xa0, 0xc3, 0xbc, 0xc3, 0x97, 0xc8, 0x88, 0x5a, 0x30,
+                0xc6, 0xb0, 0xe1, 0x9b, 0xa6, 0xc6, 0xbb, 0xc6, 0x86, 0xc6, 0xb8, 0xc6, 0x88, 0xe1,
+                0x9a, 0xbc, 0xc5, 0xbb, 0xc5, 0xaa, 0xcd, 0xb6, 0xc6, 0xa0, 0xe2, 0xb1, 0xb7, 0xc3,
+                0x8b, 0xc7, 0xa5, 0xc7, 0x9c, 0xe1, 0x9b, 0xa8, 0xe1, 0x9b, 0x82, 0xc6, 0xb4, 0xc8,
+                0xa1, 0xc3, 0xb2, 0x77, 0xc3, 0xaf, 0xc2, 0xb9, 0xc6, 0x8d, 0xe2, 0xb1, 0xbf, 0xc4,
+                0xb8, 0x33, 0xc3, 0xa4, 0xc8, 0xa5, 0xc7, 0xb5, 0xc7, 0x94, 0xc2, 0xaa, 0xc2, 0xbd,
+                0x40, 0xe1, 0x9a, 0xba, 0xc8, 0x80, 0xc6, 0x9c, 0xc4, 0x96, 0x32, 0xe1, 0x9a, 0xb8,
+                0xc3, 0xa2, 0xc7, 0xb1, 0xc4, 0x94, 0xc7, 0x88, 0xcd, 0xb4, 0xc4, 0x8d, 0x49, 0xc4,
+                0xbd, 0xe1, 0x9a, 0xb4, 0xc7, 0x88, 0xe1, 0x9b, 0xac, 0xc4, 0x9a, 0xcd, 0xbe, 0xc5,
+                0x96, 0xc8, 0x92, 0xe1, 0x9b, 0xaf, 0xc9, 0x89, 0xc5, 0xb5, 0x2f, 0x41, 0xcd, 0xbe,
+                0xc4, 0x9d, 0xc3, 0x86, 0xc2, 0xbb, 0x25, 0xc3, 0xaa, 0xc3, 0x86, 0xc4, 0x97, 0xc8,
+                0x9f, 0xcd, 0xb5, 0xc6, 0xb9, 0xc4, 0x83, 0x35, 0xe1, 0x9b, 0x9b, 0xc4, 0xa0, 0xc4,
+                0x89, 0xc8, 0xa8, 0xc4, 0x84, 0xc4, 0xba, 0xc3, 0x80, 0xc4, 0xb4, 0x53, 0xc7, 0x81,
+                0xc9, 0x85, 0xc6, 0xbc, 0xcd, 0xbb, 0xc6, 0xa8, 0xc5, 0x92, 0xce, 0x87, 0xe1, 0x9b,
+                0x88, 0x34, 0xc8, 0xbc, 0xc6, 0xae, 0xc3, 0xbe, 0xc4, 0x9d, 0xc8, 0x81, 0xc4, 0xa4,
+                0x60, 0xc7, 0x93, 0xce, 0x86, 0xc7, 0x94, 0xc7, 0x84, 0x78, 0xc8, 0x82, 0xcd, 0xb0,
+                0xc6, 0xa4, 0xc6, 0x8a, 0x65, 0xc7, 0xba, 0xc6, 0xb7, 0xc4, 0xae, 0xc9, 0x82, 0xc5,
+                0xaf, 0xc4, 0x84, 0xc8, 0x96, 0xc7, 0xb6, 0xc2, 0xb1, 0xc5, 0xaf, 0xc3, 0xac, 0xe1,
+                0x9b, 0xa9, 0xc4, 0x87, 0x43, 0xc8, 0x84, 0xc9, 0x82, 0xc7, 0xb3, 0x6a, 0xc5, 0x89,
+                0xc3, 0xb4, 0xc8, 0xa0, 0xe1, 0x9b, 0x8d, 0xc7, 0xbd, 0xc2, 0xb3, 0xc3, 0x80, 0xc6,
+                0xa6, 0xc4, 0x84, 0x69, 0xc7, 0xa7, 0xc5, 0xb5, 0xc7, 0x95, 0x21, 0xc4, 0xad, 0xe1,
+                0x9b, 0xaf, 0xe1, 0x9a, 0xa8, 0xc5, 0x85, 0xc7, 0xa8, 0xc9, 0x8c, 0xc5, 0x96, 0xe2,
+                0xb1, 0xa1, 0x33, 0xe1, 0x9b, 0xa2, 0xc3, 0xbc, 0x2e, 0x63, 0x2b, 0xc3, 0x9f, 0x7c,
+                0xc6, 0xa4, 0xc6, 0xbf, 0xc8, 0x8d, 0xc5, 0xa8, 0xc5, 0xb5, 0xc5, 0x96, 0xe1, 0x9b,
+                0x98, 0xc8, 0xb3, 0xc6, 0x90, 0xc3, 0xa6, 0x3d, 0xc9, 0x8e, 0xc8, 0xb4, 0xc7, 0xbf,
+                0xc2, 0xa6, 0xe1, 0x9a, 0xad, 0x41, 0x5e, 0x40,
+            ],
+            asset_id: [
+                0x8e, 0x95, 0x38, 0x48, 0xf3, 0xbd, 0xa6, 0xcd, 0xc0, 0x11, 0xdf, 0xd6, 0xe0, 0x1e,
+                0x9f, 0x45, 0x71, 0xf9, 0x2c, 0xa1, 0x29, 0x4f, 0xd2, 0x69, 0xff, 0x98, 0x2b, 0xd2,
+                0x1a, 0xac, 0xa0, 0xbc,
+            ],
+        },
+        TestVector {
+            key: [
+                0xb7, 0x0b, 0xb2, 0x77, 0xc0, 0x83, 0xf2, 0x95, 0x37, 0x6a, 0x02, 0xb3, 0x98, 0x76,
+                0xae, 0x35, 0xfb, 0x26, 0x62, 0x3d, 0x9d, 0x6a, 0x55, 0xa5, 0x63, 0xf7, 0x85, 0xa6,
+                0x5b, 0xc5, 0xa8, 0x27,
+            ],
+            description: [
+                0xe1, 0x9b, 0x96, 0xe1, 0x9a, 0xb1, 0xc7, 0xb2, 0xc4, 0xb1, 0xc9, 0x81, 0xc2, 0xbe,
+                0xc6, 0x84, 0xc4, 0x91, 0xc7, 0xb1, 0xc5, 0x83, 0xc2, 0xa3, 0xce, 0x8c, 0xce, 0x8c,
+                0xc8, 0x8d, 0xc5, 0xaa, 0xc7, 0xa1, 0xe1, 0x9b, 0x9f, 0xc8, 0x8a, 0xc6, 0xbc, 0xc8,
+                0xa3, 0xc8, 0xa8, 0xe1, 0x9b, 0x9b, 0xc8, 0xba, 0xc3, 0x88, 0xc7, 0x9f, 0x34, 0xc6,
+                0xb9, 0xc2, 0xb9, 0xe1, 0x9a, 0xac, 0xc9, 0x88, 0xc5, 0x84, 0xc6, 0xa1, 0xe2, 0xb1,
+                0xb6, 0xc2, 0xa8, 0xc6, 0xb4, 0xc7, 0xb3, 0x5a, 0x3d, 0xc7, 0xa1, 0xc8, 0x80, 0xc3,
+                0x92, 0xc7, 0xa2, 0xc7, 0x93, 0xc7, 0xbb, 0xc8, 0xae, 0xc4, 0xb2, 0xc9, 0x83, 0xc6,
+                0x88, 0xe2, 0xb1, 0xa2, 0xc8, 0x95, 0xc2, 0xb4, 0xc4, 0x86, 0xc5, 0xa5, 0x47, 0x70,
+                0xe2, 0xb1, 0xb1, 0x62, 0xc3, 0x96, 0x5a, 0xe1, 0x9b, 0x97, 0xc5, 0x99, 0xc6, 0xb7,
+                0xc3, 0xaa, 0xc5, 0x9d, 0xc7, 0x85, 0xc2, 0xa1, 0xc4, 0x93, 0xe1, 0x9a, 0xb8, 0xc3,
+                0x8b, 0xe1, 0x9a, 0xad, 0xc7, 0xb3, 0xc7, 0x9a, 0xc7, 0xac, 0xe2, 0xb1, 0xaa, 0xc7,
+                0xac, 0xc6, 0x91, 0xc2, 0xa9, 0xc5, 0xba, 0xc5, 0xa7, 0xc7, 0x9f, 0xc3, 0xad, 0xc8,
+                0x81, 0xc8, 0x88, 0xc4, 0x86, 0xc9, 0x8d, 0xe1, 0x9b, 0xaf, 0xe1, 0x9b, 0xa1, 0xe2,
+                0xb1, 0xb6, 0xc8, 0x8a, 0xc8, 0xa4, 0xc2, 0xaa, 0xe1, 0x9b, 0x9e, 0xc5, 0xa2, 0xc7,
+                0x98, 0xc6, 0x93, 0xc4, 0xa8, 0xe1, 0x9b, 0x80, 0x2c, 0xc3, 0x8e, 0x25, 0x51, 0xe2,
+                0xb1, 0xa7, 0xc8, 0xb3, 0xc3, 0xa4, 0xcd, 0xb6, 0xe2, 0xb1, 0xae, 0xc5, 0xb0, 0xe2,
+                0xb1, 0xaa, 0xc7, 0xae, 0xc7, 0x8f, 0xc7, 0x9b, 0xc8, 0xa5, 0xc6, 0x9f, 0xc8, 0x8e,
+                0x2e, 0x5a, 0xe1, 0x9a, 0xb9, 0xc2, 0xba, 0xc7, 0x8f, 0xc6, 0x90, 0xe1, 0x9a, 0xa9,
+                0xc4, 0x85, 0xe1, 0x9b, 0x9f, 0x45, 0x3c, 0xc4, 0xbf, 0xc2, 0xa6, 0xc7, 0x9d, 0xe2,
+                0xb1, 0xa8, 0xc7, 0x97, 0xc2, 0xbd, 0xc6, 0x8d, 0xcd, 0xb0, 0xc9, 0x83, 0x4a, 0xc8,
+                0x80, 0xce, 0x89, 0xc9, 0x8f, 0xc3, 0xbb, 0xc4, 0xa7, 0xc7, 0x8c, 0x39, 0x7e, 0xc7,
+                0x8f, 0xc5, 0xaa, 0x5a, 0xc3, 0x88, 0xc8, 0x93, 0xe1, 0x9b, 0xa6, 0xc5, 0x9e, 0xc8,
+                0xaa, 0xc5, 0x90, 0x2e, 0xc8, 0xac, 0xe2, 0xb1, 0xb8, 0x7d, 0xc5, 0x9d, 0xc6, 0xaf,
+                0xc8, 0x9d, 0xcd, 0xbe, 0xe2, 0xb1, 0xac, 0xc2, 0xbd, 0xc6, 0x9a, 0xc8, 0xb0, 0xe2,
+                0xb1, 0xbc, 0xe1, 0x9b, 0x83, 0x29, 0x44, 0xe1, 0x9b, 0x9d, 0xc4, 0x87, 0xc6, 0x99,
+                0xc7, 0xb6, 0xe1, 0x9b, 0x90, 0xcd, 0xb5, 0x3b, 0xc8, 0x92, 0xc6, 0x80, 0xc8, 0xa7,
+                0xc9, 0x8e, 0xc2, 0xa8, 0xc7, 0x8b, 0xc2, 0xb1, 0xc5, 0xb4, 0xe2, 0xb1, 0xbf, 0xe1,
+                0x9b, 0x86, 0xe1, 0x9a, 0xb8, 0x46, 0xe1, 0x9b, 0x81, 0x55, 0xc7, 0xa2, 0x26, 0xc5,
+                0x99, 0x37, 0xe1, 0x9a, 0xa5, 0xc3, 0x93, 0xc7, 0x94, 0x6f, 0xe2, 0xb1, 0xba, 0xc7,
+                0x86, 0xc2, 0xa9, 0xc5, 0x87, 0xc6, 0x9e, 0xc3, 0xae, 0xc8, 0xa7, 0xc3, 0x8c, 0x30,
+                0xc7, 0x82, 0xc7, 0xaf, 0xc5, 0xa6, 0x77, 0xe1, 0x9b, 0x80, 0x5c, 0xcd, 0xbd, 0xc2,
+                0xb5, 0xc7, 0x8f, 0x3c, 0xc3, 0x97, 0xc2, 0xb3, 0x58, 0xc6, 0x84, 0xc7, 0x86, 0xc6,
+                0xaa, 0x61, 0xc5, 0x8c, 0xc5, 0xa1, 0xe2, 0xb1, 0xbf, 0xe1, 0x9b, 0xb0, 0xc3, 0x96,
+                0xc8, 0x9e, 0xc8, 0xbb, 0xe1, 0x9a, 0xa0, 0xc6, 0x9d, 0xc4, 0xb3, 0xc8, 0x91, 0xc8,
+                0xb2, 0xc8, 0xa5, 0xc8, 0x81, 0xc5, 0x80, 0xc8, 0x93, 0x62, 0x30, 0xe1, 0x9b, 0xa6,
+                0xc5, 0x93, 0xc6, 0x81, 0xe1, 0x9a, 0xb3, 0x72, 0xc8, 0xa8, 0xc5, 0x90, 0xc8, 0x85,
+                0xc3, 0x81, 0xc4, 0x97, 0xe1, 0x9b, 0x92, 0x5a,
+            ],
+            asset_id: [
+                0x08, 0xfe, 0xbb, 0x02, 0x39, 0x9f, 0x3d, 0x81, 0x83, 0x8b, 0x51, 0xbf, 0x9a, 0xb5,
+                0x35, 0xe9, 0x5b, 0xba, 0x0f, 0x19, 0x9a, 0xda, 0x1c, 0x26, 0x65, 0xd4, 0x39, 0x4e,
+                0xa0, 0xb2, 0xa7, 0x02,
+            ],
+        },
+        TestVector {
+            key: [
+                0x70, 0x0d, 0xc0, 0x7a, 0xea, 0x5b, 0x17, 0xb5, 0xc0, 0x2b, 0xe3, 0x8c, 0x71, 0x1c,
+                0x5d, 0x6d, 0x38, 0x13, 0xa4, 0x5e, 0xc2, 0x30, 0xda, 0x29, 0xfb, 0x37, 0x3c, 0x56,
+                0x8c, 0x10, 0x44, 0x20,
+            ],
+            description: [
+                0xc3, 0x92, 0xe1, 0x9b, 0x95, 0xe1, 0x9a, 0xbf, 0xc4, 0xbc, 0x42, 0xc3, 0x88, 0xc7,
+                0xb1, 0x42, 0xc8, 0xb4, 0xc4, 0x8b, 0xc4, 0xa9, 0xc4, 0xbe, 0xc2, 0xa4, 0xc2, 0xa3,
+                0xc8, 0xaf, 0xc4, 0x87, 0xc4, 0xaa, 0xc3, 0x94, 0xcd, 0xb0, 0xc8, 0x87, 0xc5, 0xaa,
+                0x3d, 0xc2, 0xbb, 0xc7, 0x9c, 0xc3, 0xb1, 0xc2, 0xb9, 0xc8, 0x94, 0xc4, 0x93, 0x5e,
+                0xe1, 0x9b, 0xa1, 0xc8, 0x91, 0xc7, 0xb7, 0x41, 0x46, 0x44, 0xc4, 0xac, 0xc6, 0x83,
+                0xc5, 0xbe, 0xc3, 0xa7, 0xc8, 0x9a, 0xe1, 0x9b, 0x86, 0xc3, 0xa5, 0xc3, 0x9f, 0xc6,
+                0xb5, 0xe1, 0x9b, 0xa8, 0xe2, 0xb1, 0xbc, 0xc6, 0xaa, 0xe1, 0x9a, 0xa1, 0xc3, 0x81,
+                0xce, 0x87, 0xc3, 0x8c, 0xc6, 0xa0, 0xe1, 0x9a, 0xa7, 0x38, 0xc4, 0x98, 0xc4, 0x99,
+                0xc2, 0xbd, 0xc3, 0xa4, 0xc3, 0xab, 0xc4, 0xa7, 0xe1, 0x9a, 0xa3, 0xcd, 0xb4, 0x7b,
+                0xe1, 0x9a, 0xb7, 0xc4, 0xbb, 0xe2, 0xb1, 0xb3, 0xe2, 0xb1, 0xa7, 0xc6, 0x97, 0xc3,
+                0x9f, 0xc3, 0x91, 0xce, 0x8c, 0xc3, 0x84, 0xc7, 0xac, 0xcd, 0xb1, 0xe2, 0xb1, 0xb9,
+                0xe2, 0xb1, 0xac, 0xc9, 0x87, 0xc3, 0x9a, 0xc7, 0xb9, 0xc5, 0x96, 0xc7, 0x8e, 0xc4,
+                0x8e, 0xc7, 0xbb, 0xc4, 0x9b, 0xe1, 0x9b, 0x9c, 0xc4, 0xad, 0xc7, 0x81, 0xc4, 0xa4,
+                0x39, 0xc6, 0x81, 0xc6, 0x89, 0xc7, 0xa9, 0xc2, 0xa3, 0xe2, 0xb1, 0xac, 0xc9, 0x80,
+                0x51, 0xcd, 0xbd, 0xc6, 0xb8, 0xc9, 0x81, 0xc5, 0x93, 0xc8, 0xa0, 0x5d, 0xc4, 0x9c,
+                0xc6, 0x90, 0x35, 0xc4, 0xb7, 0xc8, 0x9a, 0xc5, 0x90, 0xc8, 0x94, 0xc8, 0x95, 0xc8,
+                0x92, 0xc9, 0x8c, 0xc4, 0xb5, 0x49, 0xc6, 0xbe, 0xc9, 0x84, 0xc2, 0xbf, 0xc6, 0xbb,
+                0xc2, 0xab, 0xe1, 0x9b, 0xac, 0xc6, 0x87, 0x6a, 0xc6, 0xbc, 0xc4, 0xae, 0xe1, 0x9b,
+                0x81, 0xc4, 0xb3, 0xe2, 0xb1, 0xb4, 0xc3, 0x96, 0x2f, 0xc4, 0x94, 0xc7, 0x8c, 0xc3,
+                0xb2, 0xc2, 0xab, 0xc5, 0x80, 0xc5, 0xac, 0xe2, 0xb1, 0xad, 0xc4, 0x9c, 0xc4, 0xae,
+                0xc7, 0xb7, 0x7d, 0xe1, 0x9b, 0x9d, 0xe1, 0x9a, 0xbd, 0xc4, 0xb3, 0xcd, 0xb3, 0xc2,
+                0xa6, 0xe1, 0x9a, 0xbc, 0x33, 0xe2, 0xb1, 0xb8, 0xc7, 0xa8, 0xe1, 0x9a, 0xa1, 0xe1,
+                0x9b, 0xad, 0xc5, 0xac, 0xce, 0x8a, 0xc4, 0x94, 0xc3, 0x80, 0xc7, 0xb4, 0xc7, 0xa9,
+                0xc9, 0x84, 0xc2, 0xb1, 0xc5, 0x9c, 0xc7, 0x88, 0xe2, 0xb1, 0xb6, 0xcd, 0xb0, 0xc5,
+                0x93, 0xc2, 0xb7, 0xe1, 0x9b, 0x8e, 0xe1, 0x9a, 0xa4, 0xc4, 0x87, 0xc4, 0x8c, 0xc6,
+                0x92, 0xc3, 0xa9, 0xc5, 0xa7, 0xc7, 0x96, 0xc3, 0xbd, 0xc4, 0x83, 0xc3, 0xb4, 0x44,
+                0xc3, 0x96, 0xc2, 0xb3, 0x7b, 0xe1, 0x9b, 0x8d, 0xc6, 0x86, 0xc6, 0x89, 0x61, 0xc7,
+                0x90, 0xc2, 0xb1, 0xc5, 0xaf, 0xc7, 0x94, 0xc6, 0xb5, 0xc7, 0xae, 0xe1, 0x9b, 0x8f,
+                0xc7, 0xa6, 0xc8, 0xac, 0xc5, 0x92, 0xc5, 0xb3, 0xc5, 0xb3, 0xc8, 0x92, 0xc3, 0x8e,
+                0xc4, 0x93, 0xc3, 0xb0, 0xc4, 0x9b, 0xc4, 0x8c, 0xc3, 0x83, 0xce, 0x89, 0xc6, 0x9b,
+                0x79, 0xc2, 0xa5, 0xc7, 0xa9, 0xc4, 0xa3, 0xc2, 0xa2, 0xc3, 0x90, 0xc6, 0x9e, 0xc6,
+                0x9d, 0xe1, 0x9a, 0xbb, 0xc4, 0x8c, 0xc5, 0xa8, 0xc8, 0xb2, 0xc3, 0xac, 0x5e, 0xc8,
+                0xb2, 0x38, 0xc7, 0xa0, 0xc4, 0x9e, 0xc5, 0x8f, 0xc6, 0xa9, 0xe1, 0x9a, 0xb1, 0xe1,
+                0x9b, 0x84, 0xcd, 0xbe, 0x61, 0xc7, 0x87, 0xce, 0x85, 0xc4, 0x89, 0xc8, 0x96, 0xc8,
+                0xa3, 0xc8, 0x96, 0xc3, 0xab, 0xc6, 0xae, 0xce, 0x88, 0xe1, 0x9a, 0xbf, 0xc5, 0x91,
+                0xe1, 0x9b, 0xab, 0xc7, 0x96, 0x33, 0xc3, 0xab, 0xe2, 0xb1, 0xb9, 0xe2, 0xb1, 0xac,
+                0xe2, 0xb1, 0xbb, 0xe2, 0xb1, 0xae, 0xc2, 0xbf,
+            ],
+            asset_id: [
+                0xda, 0x5b, 0xdf, 0x78, 0xe8, 0x94, 0xa9, 0x67, 0xb8, 0x2b, 0xfe, 0xc3, 0x50, 0x04,
+                0x41, 0x5e, 0xe1, 0xc8, 0xc3, 0xf2, 0x66, 0x22, 0xa2, 0xc2, 0x0c, 0xf5, 0x13, 0x9b,
+                0x79, 0xf1, 0x08, 0xba,
+            ],
+        },
+        TestVector {
+            key: [
+                0xf3, 0x2c, 0x7a, 0x80, 0xb6, 0x83, 0x45, 0xb2, 0x38, 0xc7, 0x73, 0x34, 0x67, 0xba,
+                0x6c, 0xd9, 0x7c, 0xcd, 0xf4, 0xfd, 0x21, 0x29, 0x48, 0x13, 0x1b, 0xfb, 0xc4, 0x06,
+                0x19, 0x68, 0x73, 0x26,
+            ],
+            description: [
+                0xe1, 0x9b, 0xa7, 0xe2, 0xb1, 0xb3, 0xc4, 0x8f, 0xe1, 0x9b, 0x97, 0x23, 0xe1, 0x9b,
+                0xaf, 0x70, 0xc6, 0x9f, 0xc8, 0x82, 0xc4, 0x9c, 0xc7, 0x96, 0xc5, 0x81, 0xc3, 0x90,
+                0xc5, 0xaf, 0xc6, 0x81, 0x33, 0xc8, 0xb2, 0x46, 0xc8, 0xba, 0x65, 0xcd, 0xb6, 0xe2,
+                0xb1, 0xb7, 0xc8, 0xae, 0x5a, 0xc3, 0x87, 0xc6, 0xb3, 0xc6, 0x9f, 0x3d, 0xc3, 0x8a,
+                0xc2, 0xb2, 0xc6, 0xab, 0xe1, 0x9b, 0x90, 0xc8, 0xbb, 0xe2, 0xb1, 0xab, 0xc3, 0x9f,
+                0xc7, 0xb9, 0x67, 0xe2, 0xb1, 0xba, 0xe1, 0x9b, 0x88, 0xc4, 0x91, 0xc5, 0x9a, 0xe1,
+                0x9b, 0x86, 0xe2, 0xb1, 0xbf, 0xc5, 0x9c, 0xc5, 0xad, 0x7d, 0xe2, 0xb1, 0xb1, 0xc4,
+                0x9e, 0xc6, 0x90, 0xc5, 0x8b, 0xc4, 0xa3, 0xc5, 0x8c, 0xc3, 0xaf, 0xc4, 0x90, 0xc4,
+                0xb2, 0x76, 0xc8, 0xbe, 0x33, 0xc9, 0x85, 0xc5, 0x80, 0xc7, 0x98, 0x6b, 0xe1, 0x9a,
+                0xa8, 0x5e, 0xc4, 0xa3, 0xe1, 0x9b, 0x9c, 0xc7, 0x87, 0xc4, 0xbd, 0xce, 0x89, 0xc8,
+                0xb4, 0x50, 0x3d, 0xc7, 0xa7, 0xc6, 0x97, 0xe1, 0x9b, 0xac, 0xc3, 0xb4, 0xe2, 0xb1,
+                0xbc, 0xc6, 0x9f, 0xc4, 0xb5, 0xc5, 0xb7, 0xe1, 0x9a, 0xac, 0xc7, 0xa1, 0xe1, 0x9a,
+                0xbe, 0xe2, 0xb1, 0xbb, 0xc6, 0x94, 0xc7, 0x90, 0xe1, 0x9b, 0x82, 0xe1, 0x9b, 0x80,
+                0xc6, 0x98, 0xc4, 0x9f, 0xc7, 0xac, 0xc6, 0xab, 0xc5, 0xb2, 0x48, 0x6e, 0xc2, 0xa5,
+                0xc4, 0x8c, 0xc9, 0x83, 0xc9, 0x86, 0x73, 0x29, 0x6b, 0xc3, 0xbd, 0xc2, 0xbf, 0xc4,
+                0x9b, 0xe1, 0x9a, 0xbf, 0xc7, 0xbe, 0xe1, 0x9b, 0x83, 0xe2, 0xb1, 0xab, 0xc7, 0x8d,
+                0xe2, 0xb1, 0xa2, 0x57, 0xc5, 0x84, 0xc6, 0xbc, 0xe1, 0x9b, 0xaf, 0xc5, 0xa3, 0xc8,
+                0x8f, 0x25, 0xe2, 0xb1, 0xa3, 0x6d, 0x35, 0xc8, 0xae, 0x34, 0xe2, 0xb1, 0xb9, 0xe2,
+                0xb1, 0xad, 0xc3, 0xb6, 0x71, 0xce, 0x84, 0xc8, 0x92, 0xc5, 0xa7, 0xc6, 0xb9, 0xce,
+                0x87, 0xc4, 0xb8, 0xe1, 0x9b, 0xa8, 0xe1, 0x9b, 0x89, 0x76, 0xc4, 0xaf, 0xc4, 0x85,
+                0xc2, 0xac, 0xc4, 0xbd, 0x7c, 0xc4, 0xba, 0xc4, 0x80, 0xc4, 0xa0, 0xc9, 0x82, 0xc3,
+                0xb3, 0xe1, 0x9b, 0x9e, 0xc2, 0xaf, 0xc3, 0x86, 0x7e, 0xc6, 0xa0, 0xc4, 0x8d, 0xc6,
+                0x8a, 0xc2, 0xba, 0xc4, 0xbd, 0xe1, 0x9b, 0x84, 0x75, 0xe1, 0x9a, 0xa1, 0xe2, 0xb1,
+                0xbe, 0xc7, 0xa1, 0xc7, 0x90, 0xcd, 0xbb, 0x29, 0xc5, 0xa4, 0xc4, 0xb8, 0xc4, 0xbd,
+                0xc9, 0x87, 0xc4, 0x9a, 0xc6, 0xa2, 0xe2, 0xb1, 0xa3, 0xc5, 0xae, 0xc2, 0xb4, 0xc5,
+                0x89, 0xc7, 0x93, 0xc2, 0xa9, 0xc4, 0x9c, 0xe1, 0x9a, 0xa9, 0xc9, 0x81, 0xc6, 0x88,
+                0xc3, 0x95, 0xc6, 0xb5, 0x56, 0x6b, 0x69, 0xc4, 0x86, 0xc4, 0xa5, 0xc4, 0xb3, 0xc3,
+                0x85, 0xe2, 0xb1, 0xb0, 0xc4, 0x8e, 0x38, 0x5e, 0x3c, 0xc7, 0xb1, 0xc8, 0xa1, 0xc5,
+                0x84, 0xc6, 0x85, 0xc8, 0xb9, 0xc6, 0x96, 0xc8, 0x94, 0xc3, 0x98, 0xc5, 0xb6, 0xc8,
+                0x9a, 0xc8, 0x97, 0xc3, 0xa4, 0xc3, 0x81, 0xc3, 0xa9, 0x5c, 0xc7, 0xb7, 0xe1, 0x9b,
+                0xac, 0xc8, 0x90, 0x2c, 0xe1, 0x9b, 0xa2, 0xc6, 0xb8, 0xc7, 0x93, 0xc4, 0x9e, 0xc4,
+                0xbd, 0xc4, 0x90, 0xe1, 0x9a, 0xb7, 0xc9, 0x85, 0xc7, 0x9f, 0xc4, 0xbf, 0xc5, 0xba,
+                0xc2, 0xa9, 0xe1, 0x9b, 0x9f, 0x76, 0xc3, 0xa3, 0xc8, 0xa6, 0xc5, 0x8c, 0xc6, 0xa0,
+                0xc9, 0x8d, 0xc3, 0xa0, 0xc8, 0xa7, 0x2c, 0xc6, 0x80, 0xc8, 0xbf, 0x75, 0x2b, 0xc7,
+                0xbe, 0xc5, 0xb5, 0xe1, 0x9b, 0x87, 0xc3, 0xbe, 0xcd, 0xba, 0xe1, 0x9b, 0x8f, 0xc6,
+                0x82, 0xc7, 0xa7, 0xe1, 0x9b, 0x87, 0x62, 0xc3, 0x95, 0xc4, 0xbf, 0xe1, 0x9b, 0xaf,
+                0xc4, 0xb3, 0xc7, 0xaf, 0xc3, 0x95, 0xc7, 0x9f,
+            ],
+            asset_id: [
+                0x4f, 0x20, 0x3c, 0x3a, 0x6f, 0x5b, 0x58, 0xbb, 0x4b, 0x01, 0x14, 0xf0, 0x2c, 0x1f,
+                0x4e, 0xbb, 0x78, 0x4a, 0xa3, 0xa3, 0x7e, 0x5d, 0xae, 0x4a, 0x27, 0xf0, 0xea, 0xcc,
+                0xf6, 0x8b, 0xab, 0x29,
+            ],
+        },
+        TestVector {
+            key: [
+                0x98, 0xee, 0xc6, 0xfb, 0xdc, 0xa2, 0x77, 0x2a, 0x2a, 0x6b, 0xf9, 0x2f, 0x17, 0x18,
+                0xdf, 0x59, 0xba, 0xb2, 0x5f, 0xd1, 0x05, 0x4c, 0x57, 0xad, 0xae, 0x0d, 0x72, 0x20,
+                0xbf, 0xcd, 0x06, 0x38,
+            ],
+            description: [
+                0xc8, 0xb4, 0x34, 0xc3, 0x8c, 0xc7, 0x89, 0xc7, 0x86, 0x5e, 0xc5, 0xbb, 0xc7, 0xba,
+                0xe1, 0x9b, 0x96, 0x5d, 0xc5, 0x88, 0x52, 0xcd, 0xb1, 0xe1, 0x9b, 0xad, 0xce, 0x88,
+                0xc7, 0x80, 0xc5, 0x91, 0xc6, 0xba, 0xc6, 0x8f, 0xc6, 0x81, 0xc7, 0xa8, 0xc6, 0xb1,
+                0x6b, 0xc6, 0x8c, 0xc5, 0x8f, 0xe2, 0xb1, 0xb3, 0xc5, 0x95, 0xc5, 0xa3, 0xc7, 0xaa,
+                0xc5, 0xb5, 0xc7, 0xbe, 0xc6, 0xb2, 0xc6, 0x8d, 0x61, 0x23, 0xe2, 0xb1, 0xb3, 0xc4,
+                0xbb, 0xc5, 0x96, 0xc6, 0x91, 0xc7, 0x99, 0x60, 0x2c, 0xe1, 0x9b, 0x82, 0xce, 0x86,
+                0xc8, 0x92, 0xc4, 0xa1, 0xc4, 0xa2, 0xc7, 0xb4, 0x56, 0x23, 0xe1, 0x9b, 0xae, 0xc7,
+                0x8d, 0xc3, 0xa0, 0xc6, 0xa4, 0xc4, 0x9b, 0xc9, 0x81, 0xc8, 0xb6, 0xe1, 0x9b, 0xa0,
+                0xe2, 0xb1, 0xbc, 0xe1, 0x9b, 0x82, 0xc8, 0x98, 0xc3, 0xb7, 0xe1, 0x9b, 0x8b, 0xe1,
+                0x9b, 0x80, 0xe1, 0x9a, 0xa5, 0x2a, 0xc3, 0x90, 0x5c, 0xc4, 0xb8, 0xc8, 0x9e, 0xc5,
+                0x80, 0xc8, 0x9b, 0xe2, 0xb1, 0xaf, 0xc7, 0x9f, 0xc7, 0x97, 0xc3, 0x9d, 0xe1, 0x9b,
+                0x9e, 0xc4, 0xaf, 0xc4, 0xb8, 0xc2, 0xb9, 0x3c, 0xc4, 0x9a, 0xc8, 0x80, 0xc6, 0x9d,
+                0x2f, 0x47, 0xc6, 0xb0, 0xc6, 0xb4, 0xc7, 0xb9, 0xe2, 0xb1, 0xb6, 0xc8, 0xa5, 0xc7,
+                0x91, 0xe1, 0x9b, 0x9d, 0xc6, 0x95, 0x74, 0xe1, 0x9b, 0x9b, 0xc4, 0xac, 0xc6, 0xa3,
+                0xe1, 0x9b, 0xa8, 0xc4, 0x8d, 0xc6, 0x97, 0xc5, 0xb6, 0xc6, 0xb8, 0xe2, 0xb1, 0xa8,
+                0xc2, 0xbb, 0xe1, 0x9b, 0x95, 0xc7, 0x91, 0xe1, 0x9a, 0xba, 0xc8, 0xbe, 0xc3, 0xa1,
+                0xc2, 0xbf, 0xc6, 0x9d, 0xcd, 0xb2, 0x51, 0xc6, 0x8d, 0xe1, 0x9a, 0xb9, 0xc8, 0x8d,
+                0xc5, 0xaf, 0xc4, 0xa9, 0xc6, 0xa4, 0xc5, 0x8b, 0xc6, 0xbd, 0xc3, 0xb6, 0xc4, 0x8d,
+                0xc7, 0x80, 0xc6, 0x95, 0xc5, 0xb9, 0xc2, 0xae, 0xe1, 0x9a, 0xa4, 0x54, 0x69, 0xc3,
+                0x9b, 0xc4, 0x8e, 0xc6, 0x9f, 0xc8, 0xb5, 0x65, 0xc5, 0x95, 0xcd, 0xb3, 0xc5, 0x9f,
+                0xc7, 0xae, 0xc4, 0xa4, 0xc3, 0x83, 0xc3, 0x82, 0xe1, 0x9a, 0xa4, 0xc4, 0x93, 0xc7,
+                0x88, 0x67, 0xc3, 0xaf, 0xc3, 0xb9, 0xc5, 0xb5, 0x46, 0xcd, 0xb1, 0x5e, 0x28, 0xe1,
+                0x9a, 0xb6, 0xc6, 0x86, 0x67, 0xc3, 0xb9, 0xc5, 0xb2, 0xc5, 0x8c, 0xc4, 0xb5, 0xc3,
+                0xba, 0xe1, 0x9a, 0xbe, 0xc6, 0x85, 0x5a, 0xcd, 0xb4, 0xe1, 0x9b, 0xa8, 0xc6, 0x86,
+                0xc7, 0xb5, 0xc6, 0x83, 0xc3, 0x8d, 0xc4, 0xa0, 0xc7, 0x9d, 0xc6, 0xab, 0x57, 0xc4,
+                0xa3, 0xc3, 0x9d, 0xc7, 0x88, 0x3f, 0xc8, 0x99, 0xc5, 0x98, 0xc4, 0x91, 0xe1, 0x9b,
+                0x88, 0xe2, 0xb1, 0xa1, 0xc7, 0x97, 0xc5, 0x8d, 0xe1, 0x9a, 0xb8, 0xc8, 0xa8, 0xc2,
+                0xac, 0x4d, 0xc6, 0xa2, 0xe2, 0xb1, 0xb8, 0x3f, 0xe2, 0xb1, 0xb8, 0xc8, 0xa4, 0xc7,
+                0x98, 0xc7, 0x98, 0x63, 0xc6, 0xb3, 0xc5, 0x8f, 0xc8, 0x86, 0xc4, 0xbf, 0xe2, 0xb1,
+                0xb8, 0xc8, 0xb6, 0xc4, 0x98, 0xc4, 0x8a, 0xc6, 0x93, 0xe1, 0x9b, 0x87, 0xc7, 0x93,
+                0xc6, 0xbb, 0xc8, 0x84, 0xc7, 0x92, 0xc8, 0x97, 0xe2, 0xb1, 0xa2, 0xc6, 0x8b, 0xc5,
+                0xa1, 0xc8, 0x8b, 0xc9, 0x8b, 0xc3, 0x9a, 0xe1, 0x9b, 0x81, 0xc2, 0xa2, 0xc6, 0x95,
+                0xc8, 0x99, 0x38, 0xc4, 0xb2, 0x68, 0xc7, 0x83, 0xe1, 0x9a, 0xb2, 0xc4, 0xae, 0xc8,
+                0x8d, 0xc5, 0xb6, 0xc5, 0x9e, 0x79, 0xc6, 0xa9, 0x45, 0xc6, 0x9f, 0xc7, 0x99, 0xc7,
+                0x99, 0xe1, 0x9b, 0x9c, 0xe1, 0x9b, 0xa1, 0xc7, 0xbc, 0xc8, 0x88, 0xc6, 0xbe, 0xc4,
+                0xb3, 0xc8, 0x90, 0x4c, 0xc8, 0xba, 0xc3, 0x9d, 0xe1, 0x9b, 0x8f, 0xe1, 0x9a, 0xb7,
+                0xe2, 0xb1, 0xb6, 0xc4, 0x83, 0xc5, 0xa9, 0x5a,
+            ],
+            asset_id: [
+                0x61, 0xb6, 0x64, 0xff, 0x70, 0xb4, 0x5a, 0x10, 0x5a, 0x5e, 0x5e, 0x2a, 0x65, 0xbd,
+                0x5b, 0x37, 0x7a, 0x0d, 0x89, 0xf0, 0x65, 0x6d, 0xb9, 0xe5, 0x72, 0x43, 0x2a, 0x3b,
+                0x41, 0x09, 0xb8, 0xba,
+            ],
+        },
+        TestVector {
+            key: [
+                0x3a, 0x86, 0x32, 0x5c, 0x89, 0x70, 0xca, 0x21, 0xb8, 0x3a, 0xb7, 0x59, 0x76, 0xa8,
+                0xd8, 0x54, 0xff, 0xa0, 0xc7, 0x63, 0x1b, 0xd0, 0xf8, 0xa8, 0x8c, 0x0a, 0x09, 0x89,
+                0xbd, 0xb7, 0x75, 0x19,
+            ],
+            description: [
+                0xc4, 0xae, 0xc6, 0x83, 0xc3, 0xb4, 0xe1, 0x9b, 0xa2, 0xc6, 0x93, 0xc9, 0x86, 0xc4,
+                0xa7, 0xe2, 0xb1, 0xb9, 0xc8, 0x9b, 0x3d, 0xcd, 0xbd, 0x3f, 0x54, 0xc8, 0xa9, 0xce,
+                0x84, 0xc8, 0x87, 0xc4, 0x8d, 0xe1, 0x9b, 0x83, 0xc6, 0xac, 0xe1, 0x9b, 0x9f, 0xc5,
+                0x83, 0xc7, 0x89, 0x66, 0xc4, 0x86, 0xe1, 0x9b, 0x9e, 0xe1, 0x9b, 0x8f, 0xc6, 0x99,
+                0xc5, 0xb0, 0xc4, 0x8e, 0xc4, 0x8b, 0xc7, 0x93, 0xc5, 0x9b, 0xc5, 0xb7, 0xc8, 0x89,
+                0xc3, 0x9b, 0x6e, 0xc5, 0xbd, 0xc2, 0xbe, 0xc4, 0x9e, 0x5f, 0xe1, 0x9b, 0x9a, 0xc4,
+                0x86, 0xe2, 0xb1, 0xa2, 0x7c, 0xcd, 0xb7, 0xc3, 0xab, 0x43, 0xc7, 0xa7, 0xe2, 0xb1,
+                0xa0, 0xcd, 0xbc, 0xc8, 0x90, 0xc7, 0x9f, 0xc7, 0xb4, 0xc8, 0x9d, 0xc4, 0x9e, 0xe1,
+                0x9a, 0xb3, 0x38, 0xc6, 0xaa, 0xe2, 0xb1, 0xb4, 0xc8, 0x97, 0xc8, 0x96, 0xc6, 0x90,
+                0xc7, 0xaf, 0xc7, 0x97, 0x77, 0x5f, 0xc4, 0x9d, 0xc7, 0xa9, 0xc8, 0x9f, 0xe1, 0x9a,
+                0xb0, 0xc3, 0x90, 0x35, 0x49, 0xc4, 0xb9, 0xc5, 0x96, 0xcd, 0xbc, 0xc7, 0xb3, 0xc8,
+                0xa4, 0x37, 0x46, 0xc2, 0xba, 0xe1, 0x9b, 0x89, 0xc5, 0x86, 0xc6, 0x84, 0xc5, 0x9b,
+                0xe1, 0x9b, 0x93, 0xc7, 0x81, 0xc5, 0x8d, 0x29, 0xc4, 0x9c, 0xc6, 0xbe, 0xc4, 0xad,
+                0xc8, 0x83, 0xe1, 0x9b, 0x81, 0xc4, 0xa2, 0xc8, 0x9d, 0xc4, 0x9c, 0xc7, 0xae, 0xc7,
+                0x80, 0x35, 0xe1, 0x9a, 0xa6, 0xe1, 0x9a, 0xac, 0xc4, 0xb7, 0xe1, 0x9b, 0xa2, 0xc7,
+                0xa6, 0xe2, 0xb1, 0xad, 0xc5, 0x89, 0xc6, 0x95, 0xc4, 0x98, 0xc8, 0x8d, 0xe2, 0xb1,
+                0xa3, 0xc6, 0xb3, 0xc7, 0xaf, 0xe1, 0x9a, 0xb7, 0xc4, 0xb8, 0xe2, 0xb1, 0xa8, 0xc8,
+                0xa9, 0xc8, 0xba, 0xc3, 0x97, 0xe1, 0x9b, 0x89, 0xc3, 0x93, 0xc5, 0x9a, 0xc4, 0x8b,
+                0xc5, 0xa6, 0xc4, 0xad, 0xc5, 0xb3, 0xe2, 0xb1, 0xb5, 0x66, 0xc6, 0x9c, 0x40, 0xc2,
+                0xa1, 0xc8, 0x96, 0xe2, 0xb1, 0xa3, 0xc3, 0xbf, 0xc5, 0xa5, 0xcd, 0xb0, 0xc8, 0xb8,
+                0xc6, 0xa1, 0x33, 0xe1, 0x9a, 0xb1, 0xe1, 0x9a, 0xbd, 0x33, 0xc3, 0xa2, 0xc6, 0xb7,
+                0xc4, 0xb9, 0xc7, 0xba, 0x30, 0xc5, 0x9f, 0xc8, 0xad, 0xc5, 0x9c, 0xc4, 0xa5, 0xc2,
+                0xbc, 0xce, 0x88, 0x4c, 0xc8, 0x9f, 0x7c, 0xc5, 0xbd, 0xc5, 0xa2, 0xe2, 0xb1, 0xae,
+                0xc3, 0xb2, 0xc7, 0xb6, 0xc4, 0x96, 0xc5, 0xaa, 0xc6, 0x87, 0xc5, 0xb6, 0xe1, 0x9b,
+                0x9a, 0xc3, 0xb1, 0xcd, 0xbb, 0xc6, 0xbd, 0xcd, 0xb5, 0x70, 0xce, 0x88, 0xc4, 0x8a,
+                0xc2, 0xa8, 0xc4, 0xa6, 0xc2, 0xb0, 0xc4, 0xaf, 0xc6, 0xb5, 0xcd, 0xbd, 0x34, 0xc4,
+                0x9a, 0xc4, 0x93, 0xc8, 0xbb, 0xc5, 0x99, 0xc7, 0x9d, 0xc2, 0xb4, 0xc9, 0x86, 0xe1,
+                0x9b, 0x91, 0xc4, 0x9b, 0xc8, 0x94, 0xc7, 0xae, 0xe1, 0x9b, 0x9c, 0xc8, 0xab, 0xe1,
+                0x9b, 0xa9, 0xc3, 0x99, 0xc8, 0x9c, 0xc3, 0x83, 0x7a, 0xe1, 0x9b, 0x87, 0xe1, 0x9a,
+                0xad, 0xc5, 0x8c, 0xe1, 0x9a, 0xaa, 0xc7, 0xbe, 0x5f, 0xc8, 0xb5, 0xc6, 0x99, 0xe1,
+                0x9b, 0xa7, 0xc7, 0xb1, 0xc6, 0x90, 0xc7, 0xb0, 0xc4, 0xac, 0xc3, 0x90, 0x77, 0xc7,
+                0xb8, 0xc6, 0xa9, 0xc7, 0xa7, 0xce, 0x88, 0xe1, 0x9a, 0xa1, 0x36, 0xc4, 0xbb, 0xc4,
+                0xa1, 0xc8, 0x8c, 0xc3, 0xb4, 0xc2, 0xa2, 0xe1, 0x9a, 0xb9, 0x68, 0xc7, 0x9a, 0xc5,
+                0x9e, 0x75, 0xcd, 0xb5, 0xe1, 0x9b, 0x98, 0xc7, 0x82, 0xce, 0x88, 0xe1, 0x9b, 0x9c,
+                0xc5, 0xa6, 0xc7, 0x98, 0xc5, 0xa7, 0x30, 0xc8, 0xbf, 0xcd, 0xb6, 0xc5, 0xbe, 0xc7,
+                0x97, 0x6e, 0xc6, 0xab, 0xc8, 0x92, 0xc8, 0x88, 0xc5, 0x87, 0xc7, 0x95, 0xc3, 0x97,
+                0xc4, 0xbb, 0xc7, 0x9c, 0xc5, 0x80, 0xc2, 0xb6,
+            ],
+            asset_id: [
+                0x8b, 0x7d, 0xde, 0x16, 0x1b, 0xad, 0x63, 0xb2, 0x3f, 0x2a, 0xa4, 0x2d, 0x23, 0xa3,
+                0x7b, 0x5e, 0x0e, 0x33, 0x61, 0xa9, 0x85, 0x97, 0x47, 0x96, 0xf7, 0x10, 0xef, 0x46,
+                0x4e, 0xa7, 0xa0, 0xaf,
+            ],
+        },
+        TestVector {
+            key: [
+                0x4f, 0x50, 0xd9, 0x58, 0xf6, 0xb6, 0x79, 0x91, 0x33, 0x48, 0x49, 0xd1, 0x85, 0xf1,
+                0xa3, 0x92, 0x0e, 0xfb, 0x46, 0x35, 0x1c, 0x70, 0x7d, 0xc3, 0x7d, 0x3e, 0xa9, 0xa1,
+                0x79, 0xc0, 0x76, 0x27,
+            ],
+            description: [
+                0xc7, 0xa3, 0xc8, 0x83, 0xc6, 0xa9, 0xc6, 0x9c, 0xe1, 0x9b, 0x95, 0xc3, 0x94, 0xc2,
+                0xa1, 0xc2, 0xa5, 0xc5, 0x92, 0xe2, 0xb1, 0xbe, 0xe1, 0x9a, 0xa9, 0x60, 0xc6, 0xbc,
+                0x51, 0xe1, 0x9a, 0xa9, 0xe1, 0x9a, 0xb9, 0xe1, 0x9a, 0xae, 0xc8, 0xb1, 0xcd, 0xb7,
+                0xc8, 0x9a, 0xc8, 0xa2, 0xc6, 0x91, 0xc5, 0x90, 0xc5, 0x8a, 0xc8, 0x94, 0xe1, 0x9a,
+                0xbe, 0xce, 0x88, 0xc6, 0xb8, 0xc8, 0x8e, 0xc2, 0xbe, 0xce, 0x86, 0xc5, 0xb4, 0xe1,
+                0x9a, 0xa1, 0xc5, 0xbe, 0xc2, 0xa1, 0x39, 0xc8, 0xbd, 0xc4, 0xbb, 0xc8, 0x96, 0xe1,
+                0x9b, 0x98, 0x72, 0xc3, 0x98, 0xc8, 0x9e, 0x33, 0x40, 0xc3, 0x9c, 0xe1, 0x9b, 0x97,
+                0xc8, 0x8e, 0xc7, 0xab, 0x4b, 0xc6, 0xa1, 0xc6, 0x91, 0xc3, 0x90, 0xc7, 0xa5, 0xc4,
+                0x88, 0xc5, 0x96, 0xc5, 0xb2, 0xc9, 0x84, 0xc6, 0xa6, 0xe1, 0x9a, 0xb0, 0xe2, 0xb1,
+                0xad, 0xc3, 0x99, 0x45, 0xc3, 0x9d, 0xc3, 0xaf, 0xc6, 0xb0, 0xc5, 0x9c, 0xc4, 0x83,
+                0xc4, 0x86, 0xc5, 0x91, 0xc7, 0xbe, 0xc4, 0x98, 0xc4, 0xa8, 0x62, 0xc4, 0x9b, 0xc3,
+                0xb0, 0xe1, 0x9a, 0xa3, 0xc6, 0xab, 0xc4, 0x95, 0xc8, 0x99, 0xc5, 0xa8, 0xe1, 0x9b,
+                0x92, 0xc8, 0xae, 0x4d, 0xe1, 0x9a, 0xae, 0xcd, 0xb2, 0xc3, 0x95, 0xc4, 0x8f, 0xc6,
+                0xa9, 0xc5, 0x83, 0xc2, 0xaf, 0xc2, 0xb6, 0x5b, 0xc9, 0x8b, 0xe1, 0x9a, 0xae, 0xc3,
+                0x9e, 0xc5, 0xa1, 0xcd, 0xb0, 0xc6, 0x87, 0xe1, 0x9a, 0xaa, 0xe1, 0x9a, 0xb8, 0xc7,
+                0x94, 0xc6, 0xbc, 0xc7, 0xb4, 0xe1, 0x9b, 0x98, 0xc3, 0xbf, 0xc4, 0xbc, 0xcd, 0xb6,
+                0xc4, 0x9b, 0xc4, 0xb7, 0xc2, 0xa9, 0xc7, 0x8e, 0xc3, 0xa0, 0xc3, 0x82, 0xc8, 0x9a,
+                0xce, 0x89, 0xc6, 0xac, 0xc4, 0x94, 0xc3, 0x84, 0xc7, 0xb5, 0xce, 0x85, 0xc8, 0xa8,
+                0xc3, 0x8c, 0xc8, 0x8d, 0xc2, 0xa8, 0xc8, 0x9a, 0xc9, 0x8e, 0xc8, 0xaa, 0xc3, 0x90,
+                0xc7, 0x9d, 0xc8, 0xb3, 0xc4, 0x92, 0xc6, 0x83, 0x77, 0xc5, 0xa8, 0x52, 0xc4, 0xa4,
+                0xc8, 0x91, 0xc6, 0xbd, 0xe1, 0x9a, 0xb6, 0xc7, 0xa8, 0xc3, 0xbf, 0xc7, 0x93, 0xe1,
+                0x9b, 0x87, 0xe1, 0x9b, 0xad, 0x6f, 0xc8, 0xaa, 0xc6, 0xbb, 0xc6, 0xa3, 0xc7, 0xbe,
+                0xc5, 0xb4, 0xe1, 0x9a, 0xab, 0xc7, 0xaa, 0xc7, 0x88, 0xc8, 0x85, 0xc6, 0xaa, 0xce,
+                0x8c, 0xe1, 0x9b, 0x94, 0xc5, 0xb4, 0xc3, 0xa5, 0x66, 0x45, 0xc7, 0x80, 0xc5, 0x8f,
+                0xc2, 0xb4, 0xc9, 0x8f, 0x39, 0xc3, 0x90, 0xc5, 0xa8, 0xc3, 0x91, 0xc6, 0x9e, 0xc8,
+                0xb5, 0x72, 0xc6, 0x99, 0x5d, 0x2b, 0xc8, 0xb4, 0xc7, 0xbb, 0x79, 0xc5, 0xb8, 0xc6,
+                0xb9, 0xc7, 0x9d, 0xc7, 0xb0, 0xe1, 0x9b, 0xa9, 0xe1, 0x9b, 0x92, 0xcd, 0xb6, 0xce,
+                0x85, 0x42, 0xc2, 0xba, 0xc7, 0x99, 0xc7, 0x9c, 0xc5, 0x89, 0xc6, 0xbc, 0x29, 0xc2,
+                0xb4, 0xc3, 0x8a, 0xc8, 0x81, 0xc3, 0x84, 0xc8, 0x92, 0xc3, 0x97, 0xe1, 0x9b, 0x91,
+                0xc8, 0xa7, 0xc6, 0x99, 0xc4, 0x88, 0xe1, 0x9b, 0x9e, 0xc5, 0xab, 0xce, 0x88, 0xc5,
+                0x93, 0xcd, 0xb1, 0xe2, 0xb1, 0xbc, 0xc5, 0xa0, 0xe1, 0x9b, 0x83, 0xc9, 0x80, 0xc4,
+                0xbb, 0x24, 0xc6, 0x90, 0xc3, 0x8c, 0xc7, 0xa0, 0xc8, 0x9d, 0xc3, 0x8a, 0xc4, 0xa0,
+                0xc6, 0xac, 0x72, 0xe1, 0x9b, 0x82, 0xe1, 0x9a, 0xba, 0xc3, 0x8f, 0x6c, 0xe1, 0x9a,
+                0xb4, 0xc4, 0xbe, 0xc4, 0xaf, 0xc4, 0x9a, 0xc5, 0xa7, 0x41, 0xe2, 0xb1, 0xbf, 0xe2,
+                0xb1, 0xb3, 0xc5, 0x8a, 0xe1, 0x9b, 0xa7, 0xc3, 0xa0, 0xc5, 0xaf, 0xc9, 0x8e, 0x35,
+                0x34, 0xc2, 0xa3, 0xc5, 0xa4, 0xc2, 0xb3, 0xcd, 0xb1, 0xc9, 0x85, 0xc4, 0xa3, 0xe1,
+                0x9b, 0x9f, 0xe1, 0x9b, 0x84, 0xc7, 0xa6, 0x5a,
+            ],
+            asset_id: [
+                0x6e, 0x9c, 0x7f, 0x1a, 0x04, 0x56, 0x32, 0x4e, 0x21, 0x55, 0xab, 0x2b, 0x82, 0xd5,
+                0x01, 0x11, 0x4a, 0x02, 0xc2, 0x93, 0x32, 0x96, 0x34, 0x29, 0x8e, 0x73, 0x8a, 0x62,
+                0x62, 0x36, 0xb9, 0x9b,
+            ],
+        },
+        TestVector {
+            key: [
+                0x42, 0x67, 0x81, 0x37, 0x2b, 0x07, 0xac, 0x22, 0x91, 0x58, 0x7f, 0x9f, 0x81, 0xb5,
+                0x4f, 0x8b, 0x96, 0xb4, 0xc8, 0xdd, 0xf8, 0xcd, 0x5b, 0x0d, 0x7d, 0x21, 0xe7, 0xa7,
+                0x46, 0xbb, 0x13, 0x3e,
+            ],
+            description: [
+                0xc2, 0xbd, 0x65, 0x3c, 0xe1, 0x9a, 0xb6, 0xe1, 0x9a, 0xa2, 0xc7, 0x9e, 0xe1, 0x9a,
+                0xb5, 0x5f, 0xe1, 0x9b, 0x97, 0x65, 0xc2, 0xa4, 0xc8, 0xb9, 0xe1, 0x9a, 0xb8, 0xc7,
+                0xbf, 0xc3, 0xb9, 0x52, 0x46, 0xc7, 0x9d, 0xc6, 0x9f, 0xe1, 0x9a, 0xbc, 0xc5, 0x9c,
+                0xe2, 0xb1, 0xb1, 0xc6, 0x8b, 0xc2, 0xa3, 0xc4, 0xa8, 0xc8, 0x9e, 0xc6, 0xaa, 0xc3,
+                0xa2, 0xc3, 0x84, 0xc3, 0x9d, 0xe1, 0x9b, 0x97, 0xc4, 0x81, 0xe2, 0xb1, 0xb0, 0xc5,
+                0xb9, 0x29, 0xc9, 0x89, 0x60, 0xe1, 0x9a, 0xbd, 0x5c, 0xc4, 0xbe, 0xc4, 0xb4, 0xc7,
+                0xa1, 0xc4, 0x93, 0xc4, 0x8c, 0xe1, 0x9a, 0xb9, 0xc2, 0xb0, 0xcd, 0xbd, 0xce, 0x8c,
+                0xc7, 0x88, 0xc6, 0x8c, 0xc6, 0x93, 0xc5, 0xa8, 0xe2, 0xb1, 0xa4, 0xc6, 0x84, 0x39,
+                0xc5, 0x81, 0x53, 0xc4, 0xa9, 0xc2, 0xa7, 0xc4, 0x8f, 0xe1, 0x9a, 0xba, 0xc4, 0xaf,
+                0xe1, 0x9b, 0x9d, 0xc6, 0xbb, 0xc2, 0xbc, 0xc7, 0x95, 0xc6, 0xb0, 0xe1, 0x9b, 0x8f,
+                0x42, 0xc2, 0xbe, 0xc6, 0xa7, 0xc8, 0xbc, 0xcd, 0xb7, 0xc8, 0xa7, 0xc8, 0x8b, 0xc8,
+                0xb7, 0xc6, 0xa1, 0xc4, 0x87, 0xc7, 0xa7, 0xc3, 0xb5, 0xe2, 0xb1, 0xa1, 0xc2, 0xb2,
+                0xe1, 0x9b, 0xa5, 0xc5, 0x87, 0xe1, 0x9a, 0xb3, 0xc7, 0xb3, 0x7a, 0xc6, 0x8b, 0xc4,
+                0xbe, 0xc4, 0x8e, 0x56, 0x2d, 0xc9, 0x84, 0xc4, 0x84, 0xc7, 0xa3, 0xe2, 0xb1, 0xb6,
+                0x5e, 0x46, 0xc3, 0x8f, 0xc7, 0x94, 0xc5, 0xa7, 0xc8, 0xa2, 0xc4, 0xa0, 0xc5, 0xa1,
+                0xe1, 0x9b, 0xa4, 0xe1, 0x9b, 0x9f, 0xc3, 0x87, 0xc3, 0xb4, 0xc3, 0x81, 0xc4, 0x86,
+                0xc7, 0xb7, 0xc4, 0xb3, 0xc2, 0xb5, 0xc6, 0x8c, 0xc8, 0xa0, 0xc4, 0x9c, 0xc7, 0x9e,
+                0x30, 0xcd, 0xb4, 0xc3, 0xb7, 0xe1, 0x9a, 0xb1, 0xe1, 0x9b, 0x86, 0xc5, 0xab, 0xc6,
+                0xa3, 0xc3, 0x9c, 0xc7, 0xbe, 0xc3, 0xbf, 0xc2, 0xa1, 0xe1, 0x9b, 0x89, 0xe1, 0x9a,
+                0xb8, 0xc6, 0xb7, 0xc6, 0x85, 0xc8, 0x93, 0xc3, 0x9f, 0xc7, 0xbe, 0x2e, 0xce, 0x88,
+                0xc9, 0x86, 0xe2, 0xb1, 0xa6, 0xc3, 0x94, 0x58, 0xc5, 0x84, 0xc4, 0xa1, 0x7d, 0xc7,
+                0x92, 0xe1, 0x9b, 0x81, 0xc7, 0xbc, 0xe1, 0x9b, 0x9d, 0xc4, 0xb8, 0xe1, 0x9a, 0xa9,
+                0xe1, 0x9a, 0xa1, 0xc3, 0x8d, 0xc6, 0xb6, 0x51, 0xc4, 0xbc, 0xc5, 0x91, 0xe1, 0x9a,
+                0xb4, 0xc9, 0x8d, 0xe1, 0x9a, 0xaf, 0xc9, 0x84, 0xc7, 0xb7, 0xc6, 0x96, 0x38, 0xc3,
+                0x89, 0xc6, 0xa6, 0xe1, 0x9b, 0x98, 0xc3, 0x83, 0xc3, 0x99, 0xc6, 0x99, 0xe2, 0xb1,
+                0xa1, 0xcd, 0xbd, 0xc3, 0x8d, 0xc9, 0x8f, 0x3a, 0xc4, 0x81, 0xe1, 0x9a, 0xac, 0x4b,
+                0xc6, 0x94, 0xc6, 0x9c, 0xe2, 0xb1, 0xaf, 0xe1, 0x9a, 0xb8, 0xc8, 0xb1, 0x6f, 0x70,
+                0xc3, 0xae, 0xe1, 0x9b, 0x8a, 0xc7, 0xab, 0xc5, 0xad, 0x57, 0xc3, 0xb2, 0x55, 0xc6,
+                0xb1, 0xc6, 0x84, 0xc3, 0xa4, 0x61, 0xc8, 0x9e, 0xc2, 0xb6, 0xc7, 0x8f, 0xc8, 0x95,
+                0x30, 0x29, 0xe1, 0x9a, 0xb8, 0xc6, 0xa5, 0xc8, 0x97, 0xc7, 0xa9, 0xc9, 0x8d, 0xc8,
+                0xa3, 0xc8, 0x98, 0xc2, 0xb4, 0xc7, 0x8d, 0xc7, 0x8b, 0xc7, 0xbc, 0xe2, 0xb1, 0xbf,
+                0xc2, 0xa1, 0x2b, 0xe1, 0x9a, 0xac, 0xc2, 0xb4, 0xc4, 0xa6, 0xc2, 0xa5, 0x6e, 0xc5,
+                0xa5, 0xe1, 0x9b, 0x8f, 0x2d, 0xe1, 0x9a, 0xae, 0x2c, 0x61, 0xe1, 0x9b, 0xb0, 0xc7,
+                0x84, 0xc4, 0x8e, 0x44, 0xc7, 0xb0, 0xce, 0x86, 0xc6, 0x97, 0xc4, 0xa6, 0xc3, 0x94,
+                0xc6, 0xbb, 0x2e, 0xc5, 0x95, 0xc4, 0x86, 0xc8, 0x8f, 0xc7, 0x94, 0xc9, 0x8b, 0x7b,
+                0xc4, 0x9c, 0xc5, 0xb2, 0xc5, 0x8a, 0xc5, 0x8d, 0x4a, 0xe1, 0x9a, 0xbe, 0xc8, 0x90,
+                0xc8, 0x9f, 0x70, 0xe1, 0x9b, 0x93, 0xc7, 0xbe,
+            ],
+            asset_id: [
+                0x54, 0xf5, 0xc9, 0x10, 0x86, 0xc5, 0x19, 0xcf, 0x5a, 0xa9, 0xc7, 0x4f, 0x07, 0x7c,
+                0x07, 0xbc, 0xf7, 0xd7, 0x24, 0x35, 0x20, 0xe1, 0x4d, 0x2e, 0x27, 0x12, 0x79, 0x7c,
+                0x74, 0xd2, 0x0e, 0x22,
+            ],
+        },
+        TestVector {
+            key: [
+                0x76, 0xf4, 0x9c, 0xf8, 0xa3, 0x19, 0x21, 0x85, 0x61, 0x6a, 0x9a, 0x0d, 0xa0, 0xc7,
+                0x6e, 0xc2, 0xc2, 0x75, 0x61, 0x59, 0xbc, 0xe1, 0x86, 0xa1, 0x86, 0x2b, 0x6e, 0x6e,
+                0x59, 0x44, 0x2d, 0x11,
+            ],
+            description: [
+                0xc4, 0xaa, 0xe1, 0x9a, 0xb7, 0xc3, 0x99, 0xc6, 0x90, 0xc6, 0x96, 0xc3, 0x9b, 0x54,
+                0xc9, 0x8c, 0xc8, 0x91, 0xc7, 0xba, 0xc2, 0xb9, 0xc7, 0x9b, 0xe2, 0xb1, 0xa8, 0xc3,
+                0xa5, 0xc3, 0x87, 0xc9, 0x80, 0xc7, 0xbe, 0xe1, 0x9b, 0x97, 0xc5, 0x92, 0xc7, 0xa5,
+                0xc8, 0x8e, 0xc7, 0x97, 0xe2, 0xb1, 0xb9, 0x49, 0xc8, 0xb4, 0xc7, 0xa8, 0x5e, 0xc5,
+                0x8d, 0x5d, 0xc8, 0xbb, 0xce, 0x86, 0x29, 0xe2, 0xb1, 0xa3, 0xe1, 0x9b, 0x91, 0xc3,
+                0x94, 0x46, 0xc8, 0x9a, 0xce, 0x84, 0xc7, 0x96, 0xe2, 0xb1, 0xb8, 0xc8, 0xa7, 0xc8,
+                0xbb, 0xe2, 0xb1, 0xac, 0xe2, 0xb1, 0xbf, 0xc5, 0x80, 0xc2, 0xae, 0xc3, 0x85, 0xc6,
+                0xaf, 0xc8, 0xbe, 0xc6, 0xb9, 0xe2, 0xb1, 0xb4, 0x66, 0xe1, 0x9a, 0xa1, 0x36, 0xc5,
+                0x95, 0xc3, 0xb5, 0xe2, 0xb1, 0xbe, 0xc7, 0x89, 0xe1, 0x9a, 0xa5, 0xc7, 0xa0, 0x34,
+                0xc9, 0x87, 0xe2, 0xb1, 0xac, 0xe2, 0xb1, 0xa9, 0xc7, 0x99, 0xc3, 0xa4, 0xe1, 0x9b,
+                0x89, 0xc3, 0x9e, 0xc9, 0x89, 0xc3, 0xa5, 0xc3, 0xb1, 0xc3, 0x9e, 0xe2, 0xb1, 0xb4,
+                0xc8, 0x87, 0x69, 0xc8, 0x81, 0xc3, 0x81, 0xc8, 0x9c, 0xc7, 0x80, 0xe1, 0x9b, 0x9a,
+                0xe1, 0x9b, 0xa4, 0x49, 0xc7, 0x97, 0x6e, 0x6f, 0xe1, 0x9b, 0x80, 0xc7, 0xa5, 0x5d,
+                0x3d, 0xc3, 0xab, 0xc5, 0x88, 0xc3, 0x8c, 0xe2, 0xb1, 0xb5, 0xc4, 0xa2, 0xe2, 0xb1,
+                0xa7, 0xe1, 0x9b, 0xad, 0xc6, 0xb0, 0xe1, 0x9b, 0x8f, 0xc6, 0x97, 0xe2, 0xb1, 0xb8,
+                0xc2, 0xa9, 0xc7, 0xb0, 0xe2, 0xb1, 0xbd, 0x65, 0xc3, 0xb3, 0xe2, 0xb1, 0xaa, 0xc6,
+                0xb3, 0xc5, 0x96, 0xc5, 0xbd, 0xe2, 0xb1, 0xb6, 0xe2, 0xb1, 0xb5, 0xe1, 0x9a, 0xb2,
+                0xc5, 0xb5, 0x61, 0x28, 0x58, 0xc5, 0x80, 0x74, 0x5b, 0xc8, 0xa8, 0xe2, 0xb1, 0xb7,
+                0x30, 0x6a, 0xc3, 0xaa, 0xe1, 0x9b, 0x9e, 0xc8, 0x9b, 0x33, 0x54, 0xc6, 0xad, 0xc6,
+                0x99, 0xc4, 0x9b, 0xc7, 0x87, 0xe1, 0x9b, 0xb0, 0xc7, 0x9a, 0xc7, 0x99, 0xc6, 0xa4,
+                0xc6, 0xb8, 0xe2, 0xb1, 0xb7, 0xc7, 0x93, 0x60, 0xe1, 0x9b, 0x9e, 0xc7, 0x98, 0xc8,
+                0xa8, 0xce, 0x86, 0xe1, 0x9a, 0xb2, 0xc6, 0xaf, 0xc3, 0xb7, 0xc3, 0x81, 0xc7, 0x89,
+                0xc7, 0x93, 0x25, 0xc7, 0xaf, 0xc4, 0x9c, 0xe2, 0xb1, 0xba, 0xe1, 0x9b, 0x90, 0xe1,
+                0x9b, 0xa8, 0xc7, 0xbe, 0xc3, 0xb9, 0xc7, 0xb4, 0xc5, 0xb1, 0xe2, 0xb1, 0xa3, 0xcd,
+                0xb6, 0xc5, 0x8d, 0x76, 0xc5, 0xb9, 0xe2, 0xb1, 0xae, 0x4e, 0x36, 0xc8, 0xa1, 0x50,
+                0xc6, 0x95, 0xc4, 0x84, 0xc8, 0x94, 0xe1, 0x9b, 0x9f, 0xc8, 0x9e, 0xc7, 0x85, 0xcd,
+                0xb0, 0xc4, 0xb3, 0x58, 0xc6, 0x98, 0xc4, 0xb0, 0xc8, 0x99, 0xe2, 0xb1, 0xb6, 0xc5,
+                0xa4, 0xc6, 0x84, 0xc6, 0xbd, 0xc6, 0x96, 0xe2, 0xb1, 0xb7, 0xc5, 0xb7, 0xc6, 0xaa,
+                0xc8, 0x85, 0x70, 0xc7, 0xbe, 0xc4, 0xb4, 0xe1, 0x9a, 0xba, 0x30, 0xc8, 0xae, 0xe2,
+                0xb1, 0xb3, 0x32, 0xc3, 0x89, 0xe2, 0xb1, 0xa1, 0xc3, 0x90, 0xc5, 0xba, 0xe1, 0x9b,
+                0xa2, 0xc3, 0xb3, 0xe1, 0x9b, 0xa8, 0xce, 0x86, 0xc6, 0xb2, 0x29, 0x5e, 0xc8, 0xb7,
+                0xc5, 0x8a, 0xc3, 0xa1, 0xc7, 0xac, 0xc5, 0x96, 0xc3, 0x8c, 0xc2, 0xaa, 0xc6, 0xb0,
+                0xc8, 0x84, 0x5d, 0xc8, 0x8a, 0xc2, 0xaf, 0xc5, 0x90, 0x51, 0xe1, 0x9b, 0xa3, 0xc7,
+                0x92, 0xc3, 0x9a, 0xc8, 0x81, 0xc8, 0xa5, 0x61, 0xc8, 0x95, 0xc7, 0x96, 0xe2, 0xb1,
+                0xa3, 0xc8, 0xb5, 0xe1, 0x9a, 0xa6, 0xc4, 0xb1, 0xe1, 0x9b, 0xac, 0xc7, 0xaf, 0x2b,
+                0xe1, 0x9b, 0x8b, 0xc4, 0xa0, 0xc7, 0xa1, 0xc7, 0xb6, 0xc6, 0x81, 0xc3, 0xb5, 0xe2,
+                0xb1, 0xb4, 0xc2, 0xa1, 0xe2, 0xb1, 0xb2, 0x5a,
+            ],
+            asset_id: [
+                0x9d, 0xf4, 0x24, 0x6f, 0x24, 0x26, 0xa5, 0xd4, 0x87, 0xb1, 0xc9, 0x7d, 0x71, 0x92,
+                0xf6, 0x90, 0x79, 0x85, 0x5d, 0x30, 0x08, 0xde, 0x89, 0x7b, 0xf0, 0x57, 0x06, 0xb4,
+                0x5b, 0xe3, 0xe3, 0xae,
+            ],
+        },
+    ]
+}
diff --git a/src/test_vectors/note_encryption.rs b/src/test_vectors/note_encryption.rs
index 9501a79b1..f1c6126cc 100644
--- a/src/test_vectors/note_encryption.rs
+++ b/src/test_vectors/note_encryption.rs
@@ -2192,9 +2192,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             ],
             cv_net: [
-                0x09, 0xee, 0x7e, 0xf6, 0x3a, 0xb1, 0xcf, 0x24, 0x2b, 0xaa, 0x76, 0xfc, 0xbf, 0xfb,
-                0xe5, 0x75, 0x5f, 0x13, 0x14, 0x2b, 0x38, 0xb1, 0xa0, 0x40, 0x4d, 0x7d, 0x5a, 0x3f,
-                0x4f, 0x22, 0x1e, 0x96,
+                0xba, 0x69, 0x9c, 0xe4, 0x21, 0x41, 0x85, 0x30, 0x94, 0xe2, 0x84, 0x00, 0x50, 0x17,
+                0x2c, 0x3b, 0x94, 0x21, 0x3e, 0x86, 0x47, 0x3b, 0x5e, 0x2f, 0xdd, 0x70, 0x97, 0x80,
+                0xbc, 0xca, 0x68, 0xb4,
             ],
             rho: [
                 0xf6, 0x5d, 0x22, 0x96, 0x09, 0x58, 0xd7, 0x28, 0x59, 0x60, 0x9c, 0x99, 0x46, 0xd8,
@@ -2314,9 +2314,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xfe, 0x3f, 0xbb, 0x0a, 0x4e, 0x48,
             ],
             ock: [
-                0x17, 0xeb, 0xb4, 0x82, 0xdf, 0x8d, 0x13, 0xc2, 0x0d, 0x9b, 0x4a, 0x03, 0x9f, 0x40,
-                0x5a, 0x93, 0x69, 0x8a, 0xc2, 0x24, 0xf3, 0xea, 0x03, 0xfb, 0x55, 0x8d, 0x5b, 0x53,
-                0x11, 0x46, 0xfb, 0xea,
+                0xc6, 0x7c, 0x23, 0x33, 0xc3, 0xcf, 0x4a, 0xc4, 0x6e, 0xde, 0x34, 0xe3, 0xe3, 0xe0,
+                0xdb, 0xff, 0x1e, 0x96, 0xb7, 0xa7, 0x8f, 0x16, 0xaa, 0xef, 0x1c, 0x74, 0xa3, 0xef,
+                0x07, 0xc5, 0x97, 0x16,
             ],
             op: [
                 0x05, 0x82, 0x53, 0xd4, 0x85, 0x76, 0x44, 0x88, 0x5e, 0x26, 0xa9, 0x09, 0xc8, 0x38,
@@ -2326,12 +2326,12 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xe0, 0xd2, 0x9b, 0x35, 0x9a, 0xc4, 0xfa, 0x2c,
             ],
             c_out: [
-                0x2d, 0x76, 0x57, 0x79, 0x67, 0x44, 0x5f, 0xb9, 0x17, 0xee, 0x72, 0xd3, 0x2d, 0x4b,
-                0x75, 0x3b, 0x25, 0x10, 0xd8, 0x05, 0x5d, 0xec, 0x8b, 0xf1, 0x22, 0x0a, 0x75, 0xf0,
-                0x65, 0xbd, 0x47, 0xe2, 0xcc, 0xb6, 0x03, 0x98, 0x84, 0x50, 0x23, 0x1b, 0xd3, 0x1c,
-                0x15, 0x6f, 0xf2, 0xa7, 0x2a, 0xfd, 0x4a, 0x96, 0x0b, 0x6f, 0x6a, 0x78, 0x84, 0x65,
-                0x13, 0x51, 0xe2, 0x4b, 0x47, 0x02, 0x87, 0xd5, 0x83, 0xba, 0x69, 0x71, 0x18, 0xec,
-                0x07, 0xf6, 0x59, 0x2c, 0x4c, 0xd7, 0xcd, 0x6a, 0xc7, 0x7e,
+                0xe4, 0xba, 0x0e, 0xa2, 0x92, 0x3b, 0x40, 0x19, 0xac, 0x8a, 0xbc, 0xd1, 0x9b, 0xe6,
+                0x1c, 0x90, 0xf1, 0x8e, 0xef, 0xae, 0x87, 0xc4, 0xed, 0x8c, 0x76, 0x70, 0x85, 0xba,
+                0xa8, 0x3b, 0x4d, 0x61, 0x0c, 0xf3, 0x63, 0x70, 0xda, 0x07, 0x90, 0x1e, 0xad, 0x6d,
+                0x4f, 0x4b, 0x71, 0xdc, 0xae, 0x31, 0x1f, 0xa0, 0x36, 0x40, 0x6d, 0x64, 0x7b, 0x7e,
+                0xe1, 0x41, 0x1e, 0xf5, 0xae, 0xe0, 0x34, 0x68, 0xb1, 0x09, 0x13, 0xc9, 0x90, 0xcb,
+                0x61, 0x61, 0x22, 0xeb, 0xbe, 0x49, 0xda, 0x67, 0x81, 0xc2,
             ],
             asset: Some([
                 0xa9, 0x71, 0x5e, 0x65, 0xaf, 0x82, 0x67, 0x37, 0x3d, 0x34, 0x51, 0x67, 0x4f, 0xf0,
@@ -2406,9 +2406,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             ],
             cv_net: [
-                0x54, 0xb6, 0x99, 0x64, 0x13, 0x6b, 0x63, 0xd1, 0x7d, 0x62, 0x44, 0x1a, 0x69, 0x37,
-                0x13, 0x9d, 0x2c, 0xe1, 0x4b, 0xb5, 0x5c, 0x42, 0x07, 0xfe, 0x74, 0xd7, 0x70, 0x83,
-                0x53, 0x51, 0x5b, 0xa8,
+                0x0a, 0x1f, 0x28, 0x15, 0xb7, 0xaf, 0xe2, 0x19, 0x06, 0x87, 0x15, 0xfc, 0x76, 0x6b,
+                0x87, 0x2e, 0xf2, 0x17, 0x35, 0x43, 0xac, 0x81, 0x4c, 0x32, 0xb4, 0xb6, 0x9c, 0x9c,
+                0x34, 0x5e, 0x46, 0x98,
             ],
             rho: [
                 0x27, 0x3c, 0x68, 0xd1, 0x9c, 0xda, 0xa8, 0x62, 0x8b, 0xac, 0x37, 0xa2, 0xd4, 0x2c,
@@ -2528,9 +2528,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x49, 0xaa, 0x90, 0xe6, 0x02, 0xc8,
             ],
             ock: [
-                0x59, 0xf9, 0xcc, 0x26, 0x38, 0x4c, 0x6f, 0x73, 0xce, 0xa9, 0xb9, 0xe0, 0x94, 0x40,
-                0xf8, 0xf0, 0x4c, 0x40, 0x25, 0xb5, 0x59, 0x04, 0x42, 0x3c, 0x35, 0x39, 0xc6, 0x6c,
-                0x75, 0x11, 0x31, 0x23,
+                0x2f, 0x88, 0x37, 0x27, 0xb5, 0x4d, 0x06, 0x25, 0xcf, 0xdc, 0x19, 0x5a, 0xce, 0x10,
+                0xca, 0xc0, 0x26, 0x8a, 0xba, 0x3d, 0xe2, 0x8a, 0xd6, 0x08, 0x88, 0x06, 0x50, 0x6d,
+                0x69, 0xc4, 0xdd, 0x8e,
             ],
             op: [
                 0x7a, 0xfc, 0xa0, 0x5d, 0x04, 0x2c, 0x84, 0x3e, 0xec, 0xdc, 0x37, 0x24, 0x10, 0x52,
@@ -2540,12 +2540,12 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xf5, 0x3b, 0x57, 0xc3, 0x45, 0xa9, 0x87, 0x2f,
             ],
             c_out: [
-                0x21, 0xe3, 0xf8, 0x97, 0xe1, 0xb1, 0x36, 0xe1, 0x74, 0xd7, 0xae, 0x88, 0xd7, 0x85,
-                0xa0, 0x61, 0xe6, 0x71, 0xef, 0xf1, 0x81, 0x98, 0x0a, 0x6f, 0xf5, 0x19, 0xb3, 0xbb,
-                0x6b, 0xbd, 0xaf, 0xea, 0x9d, 0xf9, 0x92, 0xbc, 0xaa, 0xc0, 0x2b, 0xdb, 0xcd, 0x4d,
-                0xb1, 0xc1, 0xd3, 0xf3, 0x2d, 0xef, 0xcd, 0xf7, 0xf4, 0xad, 0x54, 0x1b, 0x6b, 0xee,
-                0xe8, 0x27, 0xdd, 0x43, 0x89, 0xb8, 0x57, 0xd1, 0x6d, 0xb8, 0x24, 0xe7, 0x72, 0xba,
-                0x5a, 0xb5, 0xe2, 0x8d, 0xd6, 0xe9, 0x80, 0x82, 0x6b, 0xed,
+                0x99, 0x96, 0x90, 0xd4, 0xcd, 0xd9, 0xe7, 0x6b, 0x07, 0x2c, 0x3c, 0x4c, 0x41, 0xbf,
+                0xc7, 0x9a, 0xaa, 0xc6, 0x7f, 0xdc, 0x0f, 0x41, 0xe8, 0x0e, 0x95, 0x48, 0x80, 0x0e,
+                0xef, 0xbc, 0x95, 0x74, 0xf1, 0x5d, 0x64, 0xa6, 0x9e, 0x44, 0x47, 0xc4, 0x5b, 0x07,
+                0x0c, 0x6c, 0x9f, 0x50, 0x0a, 0xdd, 0xef, 0x6f, 0x57, 0x14, 0xa5, 0x76, 0x22, 0x1f,
+                0x3f, 0xbc, 0x61, 0x22, 0x8d, 0x95, 0xc3, 0xac, 0xe4, 0x21, 0x4b, 0xb6, 0xcf, 0x5b,
+                0xd9, 0x69, 0x84, 0xd7, 0x78, 0x96, 0x0d, 0xe9, 0x0c, 0x02,
             ],
             asset: Some([
                 0xdf, 0xfd, 0x79, 0xa9, 0xde, 0xd0, 0x5e, 0x88, 0x89, 0x58, 0x19, 0x9e, 0xea, 0x45,
@@ -2620,9 +2620,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             ],
             cv_net: [
-                0x10, 0xb2, 0x33, 0xd2, 0x49, 0x94, 0x68, 0xe0, 0xb0, 0xdf, 0x47, 0x3d, 0x5a, 0x21,
-                0xb9, 0x3f, 0x7d, 0x2b, 0x5d, 0x5f, 0x09, 0x95, 0xa9, 0x55, 0xd0, 0x86, 0x8a, 0x27,
-                0x45, 0x3f, 0x96, 0x82,
+                0xde, 0x2b, 0xfc, 0x89, 0x5b, 0xa8, 0xb5, 0x43, 0x03, 0x93, 0x43, 0x4e, 0x20, 0x92,
+                0xce, 0xe7, 0x81, 0xe4, 0x00, 0x28, 0x5c, 0xc6, 0x66, 0xbc, 0x6c, 0x41, 0x89, 0xdb,
+                0x2d, 0xda, 0x71, 0x92,
             ],
             rho: [
                 0xea, 0x1d, 0x9d, 0x26, 0x5e, 0xf4, 0x8a, 0x18, 0x97, 0x89, 0x70, 0xb1, 0x76, 0x7b,
@@ -2742,9 +2742,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xf1, 0xd7, 0xd3, 0x95, 0x8a, 0x54,
             ],
             ock: [
-                0xdb, 0x1e, 0xf1, 0x9a, 0xf6, 0xdd, 0x1b, 0x7b, 0xf0, 0x64, 0x89, 0xe7, 0xdb, 0x86,
-                0xca, 0xae, 0x27, 0xf6, 0x70, 0x1e, 0x09, 0x16, 0x8c, 0x6e, 0x0d, 0x2b, 0x89, 0x78,
-                0xdf, 0x14, 0xe0, 0x96,
+                0x9c, 0xba, 0xd2, 0xf3, 0x8b, 0xf8, 0x8f, 0x39, 0x47, 0xce, 0xf6, 0x4d, 0xe7, 0xa6,
+                0xf4, 0x3e, 0x4c, 0xbb, 0x41, 0xe6, 0xe0, 0x37, 0xf1, 0x42, 0x01, 0xae, 0xe8, 0xab,
+                0xfd, 0xf8, 0xa2, 0x35,
             ],
             op: [
                 0x84, 0xda, 0x49, 0x6b, 0x16, 0x0a, 0x81, 0x72, 0xc4, 0x8d, 0x76, 0xb4, 0xfb, 0x08,
@@ -2754,12 +2754,12 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x25, 0xec, 0xff, 0x47, 0x72, 0x16, 0x8c, 0x05,
             ],
             c_out: [
-                0x55, 0xdd, 0xba, 0xc4, 0x35, 0x64, 0x19, 0x54, 0xbd, 0xb1, 0xc9, 0x43, 0x4c, 0x36,
-                0x79, 0x32, 0x19, 0x18, 0xbc, 0x1f, 0x29, 0x90, 0x7a, 0xc4, 0x24, 0x43, 0x55, 0x2d,
-                0xfb, 0xe7, 0x05, 0xab, 0x26, 0x19, 0x1b, 0x4e, 0x2b, 0xae, 0xa4, 0xaa, 0xe0, 0x6d,
-                0xa9, 0xf1, 0x38, 0x4e, 0x23, 0x7b, 0xee, 0xab, 0xb1, 0xa2, 0xd8, 0x22, 0x99, 0x5e,
-                0xe7, 0xb9, 0x41, 0x0d, 0x6b, 0xe7, 0x59, 0x2a, 0xed, 0xa9, 0xf5, 0x2d, 0x56, 0xd8,
-                0xc9, 0xf9, 0x3a, 0x0b, 0xe3, 0x8c, 0xfc, 0x8d, 0xc2, 0x94,
+                0xf6, 0x25, 0xcd, 0x3d, 0x19, 0x97, 0xb0, 0xd3, 0xf2, 0x29, 0x5a, 0xac, 0xc0, 0x3a,
+                0xe0, 0xc9, 0x47, 0x28, 0xb3, 0x3c, 0xc4, 0xf1, 0x6f, 0xd4, 0x28, 0xd6, 0x5f, 0x3c,
+                0x78, 0x5e, 0x8c, 0x0b, 0xb4, 0x66, 0xc1, 0x33, 0xd4, 0x83, 0xdf, 0xc5, 0xb1, 0xb3,
+                0x15, 0x1d, 0xa2, 0xd5, 0xf2, 0x4a, 0x2b, 0x32, 0x0d, 0x8e, 0x9c, 0xd3, 0x41, 0x5c,
+                0x25, 0xb6, 0xf9, 0x76, 0x1f, 0x42, 0x70, 0x04, 0xce, 0xe5, 0x4f, 0x75, 0xf1, 0x25,
+                0xbc, 0x50, 0x5e, 0xf6, 0x26, 0xef, 0xc9, 0xdd, 0x63, 0x66,
             ],
             asset: Some([
                 0xa6, 0x33, 0x05, 0x44, 0xe5, 0x46, 0x39, 0xb5, 0x41, 0x87, 0x01, 0xff, 0x4c, 0xc4,
@@ -2834,9 +2834,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             ],
             cv_net: [
-                0x7e, 0xfd, 0xf4, 0x17, 0xcf, 0xd6, 0x44, 0x7d, 0x96, 0x58, 0x1d, 0xd1, 0x7b, 0x82,
-                0x12, 0xee, 0x53, 0x7b, 0x13, 0x4b, 0x05, 0xa5, 0x58, 0x67, 0x4a, 0x39, 0xe6, 0x66,
-                0x97, 0xe6, 0x3a, 0x29,
+                0x45, 0x37, 0x85, 0x3e, 0x18, 0xac, 0x2c, 0xe9, 0x37, 0x79, 0x8c, 0x9b, 0xce, 0xa9,
+                0x80, 0x2d, 0x65, 0x00, 0x74, 0xdb, 0xd7, 0xe0, 0x6a, 0x48, 0x98, 0x03, 0x15, 0x30,
+                0x78, 0xe9, 0x97, 0x0b,
             ],
             rho: [
                 0x9a, 0xd0, 0x7f, 0x1c, 0x28, 0x7b, 0xdd, 0x53, 0x4f, 0x6f, 0x7e, 0xae, 0x08, 0xf7,
@@ -2956,9 +2956,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xcc, 0x22, 0xca, 0x1d, 0x09, 0xd5,
             ],
             ock: [
-                0xcf, 0x22, 0xd2, 0x83, 0x95, 0x98, 0x5d, 0x31, 0x6a, 0xf9, 0x50, 0x19, 0x21, 0xba,
-                0xc1, 0x52, 0x57, 0x11, 0xbb, 0x3f, 0x3c, 0xc3, 0xc3, 0xc2, 0x82, 0xa3, 0xd1, 0x8e,
-                0x43, 0xd4, 0x78, 0x05,
+                0x97, 0x9b, 0x31, 0x5d, 0x3e, 0x1f, 0x5c, 0xa1, 0x8a, 0x92, 0x86, 0xd9, 0x2c, 0xc8,
+                0x8e, 0x63, 0x62, 0x4b, 0x39, 0x9b, 0x29, 0x19, 0xbf, 0x4e, 0x67, 0xda, 0x7c, 0xd3,
+                0x94, 0xf4, 0x5c, 0x49,
             ],
             op: [
                 0x04, 0x47, 0x12, 0x42, 0xe1, 0xf4, 0x2b, 0xf0, 0x81, 0xf0, 0x8e, 0x9d, 0x71, 0xfe,
@@ -2968,12 +2968,12 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xaf, 0x2b, 0xd1, 0xa0, 0x8c, 0x67, 0xd9, 0x3f,
             ],
             c_out: [
-                0x7a, 0xe6, 0x91, 0xd9, 0xbc, 0xd5, 0x38, 0x42, 0x7b, 0x4f, 0x07, 0xe2, 0x38, 0x81,
-                0x94, 0x18, 0xbb, 0xb8, 0x18, 0x31, 0x88, 0x89, 0x93, 0x08, 0xfd, 0x6a, 0xab, 0x2b,
-                0xf4, 0xf0, 0x69, 0x9c, 0xc5, 0x61, 0x9c, 0x8d, 0x4f, 0xc9, 0x95, 0xc2, 0x11, 0x76,
-                0xbf, 0xea, 0x13, 0xee, 0x04, 0x03, 0xc0, 0xce, 0x57, 0x4f, 0xc8, 0xfa, 0x16, 0x81,
-                0xb3, 0x76, 0xcf, 0x33, 0xc9, 0xff, 0x27, 0xa5, 0xaa, 0x01, 0x58, 0x24, 0xe6, 0x78,
-                0x6e, 0x16, 0xe3, 0x7b, 0x35, 0x5c, 0xf7, 0x54, 0x52, 0xdb,
+                0x83, 0xf7, 0xa1, 0xda, 0x72, 0x4d, 0xd1, 0x54, 0xe7, 0xd9, 0x47, 0xc0, 0xfc, 0x83,
+                0x42, 0x87, 0xf3, 0x3c, 0xd4, 0xb3, 0x4a, 0xfa, 0xc0, 0xda, 0x55, 0xe4, 0x37, 0xaf,
+                0xae, 0x67, 0xa9, 0x9c, 0xbd, 0x89, 0x75, 0xc9, 0x54, 0xcf, 0x41, 0xaa, 0x1e, 0x9a,
+                0x8f, 0x99, 0x98, 0x3d, 0x58, 0x6f, 0x5e, 0x35, 0x37, 0xda, 0xb7, 0x2a, 0xe1, 0x82,
+                0x7a, 0xa5, 0xdf, 0xc9, 0xdd, 0xad, 0x06, 0x26, 0x78, 0x84, 0x6f, 0xf8, 0x09, 0x3d,
+                0xfd, 0x15, 0xf6, 0x3d, 0x47, 0xe5, 0xa3, 0xbb, 0x74, 0x39,
             ],
             asset: Some([
                 0x61, 0x16, 0xcf, 0xec, 0x26, 0x47, 0xcc, 0xaa, 0xe1, 0xc7, 0x4b, 0x41, 0x6f, 0x3e,
@@ -3048,9 +3048,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             ],
             cv_net: [
-                0xf5, 0xc1, 0xcf, 0xbc, 0xb9, 0x2d, 0x34, 0xe4, 0x66, 0x1d, 0x58, 0x25, 0x42, 0xf7,
-                0x0d, 0x05, 0x99, 0x09, 0x15, 0x20, 0xfe, 0x2a, 0xfa, 0xd8, 0xe8, 0x75, 0xca, 0x3b,
-                0xcc, 0x70, 0x8a, 0x11,
+                0x71, 0x00, 0xa7, 0x52, 0x93, 0xf4, 0xae, 0xfd, 0x89, 0xa1, 0x66, 0xa5, 0xf8, 0x4d,
+                0x34, 0xda, 0xf4, 0xe5, 0x98, 0x34, 0xcd, 0x65, 0xd7, 0x9f, 0xfc, 0x41, 0xdd, 0xf0,
+                0x68, 0x2d, 0xc2, 0xab,
             ],
             rho: [
                 0x31, 0x70, 0x5e, 0xfb, 0xf8, 0x0c, 0x7a, 0x7a, 0xb7, 0x81, 0xdf, 0x53, 0x77, 0xf8,
@@ -3170,9 +3170,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xcc, 0x53, 0x03, 0xc5, 0xf3, 0xf0,
             ],
             ock: [
-                0xe3, 0xf2, 0x74, 0x2e, 0xa1, 0x97, 0x55, 0xa7, 0x99, 0x73, 0x1a, 0xcf, 0xe9, 0x98,
-                0x86, 0xfb, 0x9f, 0xbb, 0x80, 0x48, 0xb5, 0x3a, 0x77, 0x72, 0xa2, 0x80, 0xd8, 0x17,
-                0x19, 0xff, 0xfd, 0x28,
+                0x55, 0x0e, 0xbf, 0x98, 0x83, 0x6c, 0xce, 0x43, 0x52, 0x25, 0xa1, 0x4b, 0xa6, 0x52,
+                0xa7, 0xd5, 0x58, 0xcf, 0x5f, 0x3f, 0x7a, 0xfb, 0x00, 0xb0, 0x24, 0x70, 0xe8, 0xe4,
+                0xd2, 0x6d, 0xb7, 0x9c,
             ],
             op: [
                 0x49, 0x19, 0x01, 0x2e, 0x40, 0x43, 0x82, 0xeb, 0xee, 0x8e, 0x60, 0xe9, 0xd4, 0xf1,
@@ -3182,12 +3182,12 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x44, 0x72, 0x83, 0xf9, 0x4e, 0xd5, 0x95, 0x3d,
             ],
             c_out: [
-                0x92, 0xe7, 0x7c, 0x9b, 0x69, 0x92, 0xee, 0x85, 0x06, 0x30, 0x6a, 0x96, 0xc8, 0xa5,
-                0x1c, 0xc9, 0xa8, 0x96, 0x18, 0xc6, 0x36, 0x6f, 0xce, 0x78, 0xb2, 0x9a, 0xdb, 0x10,
-                0x9b, 0x4a, 0x3b, 0x17, 0x48, 0x49, 0x13, 0x4f, 0x7a, 0xa2, 0x9c, 0x79, 0x1b, 0x91,
-                0x5f, 0xd7, 0x5a, 0x6f, 0xfc, 0x57, 0x42, 0x78, 0xef, 0x50, 0x2b, 0x84, 0x02, 0x46,
-                0x9a, 0xb5, 0xa7, 0xce, 0x77, 0x2b, 0x52, 0x2c, 0x4b, 0xaa, 0x12, 0x95, 0xd8, 0x8f,
-                0x15, 0xdc, 0x75, 0x1d, 0xdf, 0x7d, 0x20, 0x8d, 0xd5, 0x17,
+                0x9a, 0x01, 0xb7, 0x5e, 0x27, 0xea, 0x97, 0x51, 0x45, 0x5d, 0x54, 0xf2, 0xa5, 0x2b,
+                0x88, 0x4b, 0x45, 0x6a, 0x6f, 0xc3, 0xda, 0xdb, 0xec, 0x79, 0xbf, 0x4d, 0x10, 0xbe,
+                0x06, 0x7b, 0xef, 0x3e, 0xa2, 0xa5, 0xc0, 0x59, 0x81, 0xd4, 0x06, 0x05, 0x6a, 0x2f,
+                0xf6, 0x4c, 0xb4, 0xc6, 0xfd, 0x46, 0x7d, 0xa8, 0x0b, 0xa1, 0x17, 0x48, 0xe9, 0xe2,
+                0xae, 0x07, 0xb7, 0x62, 0xdf, 0x9d, 0x4a, 0x23, 0x58, 0x77, 0xf5, 0x8f, 0x43, 0x24,
+                0xd8, 0x00, 0x3c, 0x32, 0x4f, 0xd9, 0xc6, 0x39, 0xbc, 0xa6,
             ],
             asset: Some([
                 0x29, 0x8a, 0xc0, 0xaf, 0xdc, 0x52, 0x87, 0xd7, 0xad, 0x12, 0x4c, 0xd9, 0x40, 0x5a,
@@ -3262,9 +3262,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             ],
             cv_net: [
-                0x65, 0x73, 0x3c, 0x9d, 0x97, 0xea, 0x82, 0xf6, 0xde, 0xf3, 0xde, 0x1f, 0xe8, 0x7e,
-                0x12, 0x37, 0x6a, 0x92, 0x49, 0xdc, 0x86, 0x14, 0x67, 0x2d, 0x5e, 0xda, 0x15, 0xf3,
-                0xca, 0xf4, 0x5b, 0x8c,
+                0x5d, 0xd1, 0x3d, 0xcf, 0x9a, 0xf3, 0x52, 0xf5, 0xfe, 0x0b, 0x2b, 0xcb, 0xd0, 0xdb,
+                0xd7, 0xda, 0xfb, 0xbe, 0x53, 0xb0, 0xa9, 0x6b, 0x08, 0x1c, 0x90, 0xba, 0xde, 0xd9,
+                0xbe, 0x4b, 0x4f, 0x87,
             ],
             rho: [
                 0x56, 0xbc, 0x48, 0x21, 0xa5, 0x3d, 0x5e, 0x9e, 0x6d, 0x7a, 0x04, 0x44, 0x44, 0x45,
@@ -3384,9 +3384,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x71, 0xb8, 0xaa, 0x9f, 0x69, 0xf0,
             ],
             ock: [
-                0x42, 0x46, 0x14, 0xa3, 0xb5, 0x79, 0x96, 0xef, 0xb1, 0x24, 0xb7, 0xf4, 0x50, 0xae,
-                0x2a, 0xf7, 0xf6, 0xdc, 0x8c, 0x8c, 0xee, 0xa9, 0x4f, 0x17, 0x74, 0x77, 0x72, 0x1b,
-                0x84, 0x61, 0x3b, 0x23,
+                0x53, 0x29, 0x6e, 0xed, 0x43, 0xb4, 0xeb, 0x30, 0xa4, 0x3d, 0x88, 0x90, 0x2f, 0x74,
+                0x04, 0x26, 0x62, 0x1d, 0x85, 0x21, 0x3a, 0x36, 0xc5, 0x20, 0xa1, 0x84, 0xa4, 0x3a,
+                0xfb, 0xd4, 0x89, 0x6d,
             ],
             op: [
                 0x64, 0xce, 0xac, 0xec, 0x3c, 0x2e, 0xa7, 0x9c, 0x4c, 0xd3, 0xe2, 0xf0, 0xfb, 0xb9,
@@ -3396,12 +3396,12 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x86, 0x48, 0x56, 0x2c, 0xbd, 0x86, 0x3f, 0x09,
             ],
             c_out: [
-                0x8b, 0x94, 0x8b, 0x33, 0xf5, 0x55, 0xcd, 0x45, 0x5f, 0xaa, 0x36, 0x51, 0x7b, 0x8e,
-                0xab, 0x29, 0xe1, 0xa5, 0x1f, 0x6c, 0xec, 0x21, 0x79, 0xd9, 0xea, 0xe4, 0xea, 0xca,
-                0x92, 0x50, 0xbb, 0x9b, 0x55, 0xe4, 0xb5, 0x49, 0x49, 0x15, 0xc1, 0xf0, 0x01, 0x65,
-                0xf8, 0x9d, 0x7c, 0x02, 0xa0, 0x25, 0x45, 0xb9, 0xd5, 0x98, 0x08, 0x6e, 0xeb, 0x96,
-                0x1e, 0x58, 0x7e, 0x43, 0xfd, 0xfc, 0x65, 0xfe, 0x52, 0xf1, 0xe0, 0xc6, 0xa0, 0x46,
-                0x46, 0x48, 0xcd, 0x1f, 0xc8, 0x9e, 0x80, 0xbd, 0x78, 0x0f,
+                0x38, 0xee, 0x14, 0xef, 0xb0, 0x63, 0x94, 0x64, 0x44, 0x6f, 0x5f, 0xb8, 0x79, 0x5d,
+                0x23, 0xf8, 0x8c, 0xf5, 0x65, 0x37, 0xe6, 0x4e, 0x1a, 0x46, 0x63, 0x17, 0xb3, 0x6f,
+                0x22, 0x2e, 0x00, 0x5b, 0x92, 0x4c, 0xc9, 0x10, 0xd6, 0x29, 0x06, 0x6e, 0x05, 0x07,
+                0xcb, 0x91, 0x2b, 0x0b, 0xc1, 0xd3, 0x16, 0xc2, 0x00, 0xb1, 0xa9, 0x56, 0x49, 0xc0,
+                0xc5, 0x30, 0xb4, 0xf3, 0xd0, 0x43, 0x06, 0x8e, 0xf6, 0xf4, 0x2d, 0xcb, 0xef, 0xd0,
+                0x2a, 0x34, 0x80, 0xe3, 0x2a, 0xa4, 0x5e, 0x33, 0xce, 0x25,
             ],
             asset: Some([
                 0xf9, 0x78, 0x1e, 0xbe, 0x31, 0x7a, 0x07, 0x10, 0xae, 0x54, 0x61, 0xe3, 0x4f, 0xe6,
@@ -3476,9 +3476,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             ],
             cv_net: [
-                0x81, 0xa8, 0xbb, 0x76, 0xf2, 0x62, 0x73, 0x62, 0x8b, 0x9f, 0x9b, 0x66, 0x04, 0x94,
-                0xb3, 0x45, 0xb7, 0x9d, 0x45, 0x16, 0x3c, 0x7b, 0x4c, 0xc5, 0x5a, 0x49, 0xff, 0x3f,
-                0xc6, 0xb8, 0x1d, 0xaa,
+                0x43, 0x94, 0x47, 0xab, 0x14, 0x5a, 0x6f, 0x0e, 0x5a, 0x3b, 0x43, 0x63, 0x04, 0x4c,
+                0x73, 0x07, 0x93, 0xf4, 0x36, 0x33, 0x1f, 0xfe, 0x66, 0x30, 0xc7, 0xca, 0x2d, 0x9b,
+                0x23, 0x2a, 0xe1, 0x98,
             ],
             rho: [
                 0xd6, 0xff, 0xc4, 0x74, 0x88, 0xad, 0x05, 0x93, 0x89, 0x70, 0xc4, 0xb1, 0x56, 0xd0,
@@ -3598,9 +3598,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xd8, 0x2e, 0x93, 0x3c, 0x89, 0xe1,
             ],
             ock: [
-                0x71, 0x5c, 0x9a, 0x01, 0x87, 0xab, 0x90, 0xb2, 0x4d, 0x3c, 0xbb, 0xa3, 0xf1, 0xab,
-                0x30, 0x67, 0xc5, 0x63, 0x06, 0x04, 0x48, 0xc0, 0x0e, 0xf2, 0x74, 0xb7, 0xea, 0x66,
-                0x11, 0x13, 0x0d, 0x26,
+                0x2a, 0x2e, 0x0d, 0x99, 0x69, 0xf0, 0x2e, 0xbd, 0xb6, 0xd9, 0xc8, 0xe7, 0xe6, 0xfd,
+                0xde, 0x20, 0x85, 0x12, 0x4b, 0x19, 0xad, 0x70, 0x90, 0xcc, 0x26, 0x15, 0x1d, 0x4d,
+                0xa4, 0x2a, 0x00, 0x3e,
             ],
             op: [
                 0x9a, 0xe4, 0x94, 0xa9, 0xfc, 0xff, 0x9b, 0x74, 0x49, 0x14, 0x53, 0x31, 0x04, 0x4f,
@@ -3610,12 +3610,12 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xa9, 0xec, 0x88, 0x17, 0x18, 0x65, 0x40, 0x33,
             ],
             c_out: [
-                0x22, 0xce, 0xb6, 0x94, 0x21, 0xab, 0x9e, 0xd0, 0x29, 0x97, 0x3f, 0xf2, 0x2e, 0xc9,
-                0x5f, 0x23, 0x36, 0x56, 0xbe, 0x41, 0xd2, 0x25, 0x1a, 0x76, 0x77, 0xce, 0xb0, 0xd3,
-                0x14, 0x22, 0x11, 0x6f, 0x8c, 0xa5, 0xf0, 0xae, 0x23, 0x12, 0xd4, 0xec, 0x60, 0x0c,
-                0x5d, 0x7c, 0x56, 0x44, 0x5b, 0x6d, 0x8d, 0xc4, 0xb8, 0x0b, 0x47, 0x0b, 0xb1, 0xf6,
-                0x51, 0xa5, 0x38, 0x28, 0x0d, 0xaa, 0x94, 0x20, 0x3a, 0xb5, 0x02, 0xa8, 0x15, 0x09,
-                0xe4, 0x3a, 0x61, 0xa6, 0x98, 0x56, 0x57, 0xd9, 0xe8, 0x4e,
+                0x74, 0x6a, 0xae, 0x9d, 0xa6, 0x1c, 0x02, 0xae, 0xaa, 0x8b, 0xed, 0xbe, 0x2b, 0x6c,
+                0x84, 0x1b, 0xc4, 0x36, 0x17, 0x3c, 0x7c, 0x91, 0x13, 0x66, 0x3a, 0x39, 0xc1, 0x74,
+                0x69, 0x29, 0x0b, 0xd2, 0x19, 0xea, 0xdc, 0x4a, 0x97, 0x5a, 0xd0, 0x52, 0xd0, 0x5d,
+                0xc0, 0xa3, 0x08, 0xf3, 0x63, 0xf9, 0x22, 0x68, 0x2d, 0x75, 0x21, 0x9d, 0xaa, 0x33,
+                0x6f, 0x69, 0xb5, 0x9e, 0x86, 0x7c, 0x85, 0xd9, 0x37, 0x34, 0x4c, 0x19, 0xd3, 0x88,
+                0x01, 0x63, 0x19, 0xb3, 0xf6, 0x0f, 0x76, 0xd0, 0x28, 0x93,
             ],
             asset: Some([
                 0x76, 0xba, 0x24, 0x3f, 0x28, 0x42, 0xb7, 0xb5, 0xfc, 0x74, 0x6a, 0xe5, 0x1b, 0x0b,
@@ -3690,9 +3690,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             ],
             cv_net: [
-                0x40, 0x21, 0x95, 0x68, 0x0e, 0x02, 0x27, 0x30, 0x2c, 0x3a, 0x75, 0x6a, 0x34, 0xdf,
-                0xdb, 0x13, 0x6b, 0xbd, 0x28, 0x7d, 0x7d, 0xc1, 0x25, 0x81, 0xd0, 0x8e, 0x2a, 0x63,
-                0xb9, 0xc3, 0x92, 0x3e,
+                0xf4, 0x5c, 0xba, 0x14, 0x6a, 0xe7, 0x18, 0x85, 0xfd, 0x61, 0xb4, 0xa0, 0xf3, 0x6b,
+                0x95, 0x26, 0xa6, 0xe9, 0x4a, 0x49, 0x70, 0x10, 0xe3, 0x2a, 0x8a, 0x76, 0xbc, 0xdf,
+                0xa7, 0x20, 0xb8, 0xa6,
             ],
             rho: [
                 0x85, 0x2f, 0x5c, 0x39, 0xd3, 0xf3, 0x55, 0xa3, 0x85, 0xe2, 0xab, 0xd2, 0x54, 0x3a,
@@ -3812,9 +3812,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x7e, 0x44, 0x16, 0x70, 0x64, 0xc9,
             ],
             ock: [
-                0xbc, 0x1b, 0xa7, 0xae, 0x73, 0xe7, 0x39, 0x7a, 0x64, 0xe0, 0xbd, 0x98, 0x63, 0xf1,
-                0x33, 0x95, 0xdc, 0x0b, 0x15, 0xd4, 0x4e, 0x86, 0x70, 0xf1, 0x85, 0x5b, 0x68, 0xc2,
-                0x9f, 0x97, 0x9a, 0xd2,
+                0x67, 0x1c, 0xed, 0xd6, 0xf5, 0x73, 0xa4, 0x6f, 0xf1, 0xea, 0xd0, 0x48, 0x21, 0x98,
+                0x56, 0x36, 0xe2, 0x3f, 0xb1, 0x5c, 0x6f, 0x48, 0x05, 0xfd, 0x57, 0x63, 0x12, 0xc2,
+                0x07, 0x02, 0xa4, 0x24,
             ],
             op: [
                 0xcc, 0x18, 0xe4, 0xb6, 0x5f, 0x89, 0x34, 0x06, 0x31, 0x5d, 0xb7, 0x1f, 0xac, 0x06,
@@ -3824,12 +3824,12 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x6a, 0x72, 0xcb, 0x74, 0xfb, 0x18, 0xd1, 0x17,
             ],
             c_out: [
-                0xe2, 0x76, 0x3c, 0x2c, 0xd3, 0x04, 0x29, 0x45, 0x25, 0xf6, 0x6d, 0x17, 0xcd, 0xb4,
-                0x2a, 0x6d, 0xaf, 0xd7, 0x47, 0x38, 0x37, 0x71, 0x52, 0x35, 0x62, 0xb2, 0x71, 0xbb,
-                0xf5, 0xb2, 0x88, 0x41, 0xb5, 0xca, 0x65, 0xfd, 0xd3, 0x42, 0xee, 0x80, 0x2f, 0xee,
-                0x12, 0x12, 0x47, 0x22, 0xcf, 0xf5, 0xe1, 0x99, 0xd6, 0xd9, 0x5c, 0x2f, 0x88, 0xc4,
-                0xe2, 0x31, 0x31, 0xf4, 0xe7, 0x6b, 0xa7, 0x6b, 0x9d, 0x64, 0x66, 0x78, 0xd8, 0x53,
-                0xd1, 0xdc, 0xaf, 0x81, 0xb8, 0x0e, 0x2e, 0xfd, 0xf0, 0x60,
+                0x59, 0x97, 0x53, 0xe4, 0x0a, 0xda, 0xea, 0xff, 0x6f, 0xaa, 0xf5, 0xa6, 0xf3, 0x0e,
+                0x39, 0x13, 0x8f, 0xde, 0x82, 0x0f, 0x7b, 0xec, 0x7c, 0x8d, 0x0f, 0xd8, 0x4b, 0x48,
+                0x36, 0x94, 0xe5, 0x0c, 0x4b, 0xdd, 0xee, 0x2f, 0xb1, 0xa4, 0xf9, 0x95, 0xb1, 0xa3,
+                0xba, 0x40, 0xf4, 0x66, 0xb4, 0x2e, 0x8b, 0x5d, 0x01, 0x38, 0xfd, 0x30, 0xbf, 0xf6,
+                0xae, 0x8c, 0xb1, 0x55, 0xf4, 0x0c, 0xdc, 0x37, 0x39, 0xfa, 0xbf, 0x2f, 0x00, 0xda,
+                0x3a, 0xc6, 0xa7, 0x36, 0x3b, 0xc2, 0xf4, 0xaa, 0x10, 0xfe,
             ],
             asset: Some([
                 0x64, 0xd0, 0x87, 0x40, 0x89, 0x86, 0xe7, 0x3d, 0x6e, 0x28, 0x4f, 0xea, 0x9a, 0x23,
@@ -3904,9 +3904,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             ],
             cv_net: [
-                0x50, 0xaf, 0x90, 0x31, 0xf4, 0xe0, 0x4b, 0x79, 0xd7, 0xda, 0xb5, 0xe8, 0x5b, 0x51,
-                0xee, 0x9b, 0xea, 0x56, 0xf7, 0xc5, 0x6b, 0x52, 0x22, 0x73, 0xd2, 0x30, 0xaa, 0x51,
-                0x2b, 0xa9, 0xe7, 0x06,
+                0x1a, 0xa2, 0x3d, 0x96, 0x79, 0xbc, 0x66, 0x04, 0xb6, 0x25, 0x2c, 0x4f, 0x48, 0x1b,
+                0x3a, 0x2a, 0xf5, 0x46, 0x32, 0xf8, 0x30, 0x08, 0x14, 0x68, 0x29, 0x65, 0x94, 0x5e,
+                0x7e, 0x33, 0x2a, 0x0d,
             ],
             rho: [
                 0x09, 0x1d, 0x83, 0x73, 0x3a, 0x9f, 0xfb, 0x18, 0xc1, 0x7a, 0xd1, 0x93, 0x8d, 0xd2,
@@ -4026,9 +4026,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xcc, 0xac, 0xba, 0xd9, 0xa2, 0xfa,
             ],
             ock: [
-                0xc7, 0x5b, 0x5b, 0xfa, 0x9f, 0x2e, 0xeb, 0xd9, 0x99, 0x80, 0x78, 0xf1, 0x8f, 0x0e,
-                0x9b, 0x79, 0xf1, 0xe2, 0x13, 0xe8, 0x25, 0x61, 0x6f, 0xeb, 0x26, 0x08, 0xe9, 0xc7,
-                0x81, 0xb5, 0x00, 0x95,
+                0x57, 0x97, 0xef, 0x48, 0x70, 0xb0, 0x86, 0x50, 0xfa, 0x99, 0xad, 0xae, 0x58, 0x85,
+                0x19, 0x9e, 0x3b, 0x04, 0x4b, 0x2a, 0x0a, 0x8c, 0xe1, 0x61, 0x43, 0x42, 0xb5, 0xdc,
+                0xb2, 0x8e, 0x6e, 0x09,
             ],
             op: [
                 0x6f, 0xce, 0x26, 0xab, 0xe6, 0xc0, 0xb6, 0x84, 0x37, 0x36, 0x96, 0x46, 0xee, 0xe1,
@@ -4038,12 +4038,12 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xb9, 0x5f, 0xc8, 0x7e, 0xa7, 0x37, 0x3e, 0x2f,
             ],
             c_out: [
-                0xca, 0x4d, 0x6e, 0xb3, 0xea, 0x95, 0xc5, 0x5a, 0x91, 0x16, 0x85, 0x66, 0xe6, 0x67,
-                0x63, 0xd1, 0x9e, 0x9c, 0x44, 0x33, 0x07, 0x3c, 0x08, 0x9a, 0x7d, 0xb9, 0x5b, 0x93,
-                0xc8, 0xc4, 0x55, 0x0e, 0xb0, 0x8e, 0x28, 0xdd, 0xef, 0xba, 0x64, 0xe0, 0x58, 0xac,
-                0x68, 0x44, 0xad, 0x77, 0x20, 0x67, 0xa1, 0x7c, 0x32, 0x53, 0xc3, 0x9a, 0x72, 0x4d,
-                0xd8, 0x15, 0xf7, 0x29, 0x8c, 0x1d, 0x59, 0x09, 0x1f, 0x1b, 0x38, 0x7a, 0x26, 0x46,
-                0xe7, 0xfe, 0x36, 0x3a, 0xde, 0x83, 0x63, 0xa9, 0x2a, 0xde,
+                0xb8, 0xb4, 0x6c, 0x7e, 0xc4, 0xa8, 0x74, 0x2a, 0x22, 0xd3, 0xcd, 0x11, 0x74, 0x1c,
+                0x23, 0x04, 0x22, 0x1c, 0xa5, 0x97, 0x29, 0x4e, 0x08, 0xa4, 0xc7, 0x1b, 0x17, 0xc7,
+                0x26, 0x5d, 0x4d, 0xa7, 0x7c, 0xfe, 0x84, 0xb8, 0x7e, 0x76, 0xed, 0xaa, 0xec, 0xc2,
+                0x24, 0xb8, 0x36, 0xde, 0x22, 0x4c, 0x73, 0x58, 0x13, 0x19, 0xa0, 0xba, 0x27, 0x88,
+                0xdb, 0xf8, 0x3b, 0xcf, 0x47, 0xa4, 0x8e, 0xeb, 0x02, 0xb4, 0x3a, 0x18, 0x02, 0x7b,
+                0x8f, 0x59, 0x11, 0x65, 0xc2, 0x86, 0xe8, 0xb6, 0x54, 0xec,
             ],
             asset: Some([
                 0xc3, 0xcc, 0x4f, 0x43, 0xfa, 0x01, 0x88, 0x52, 0x1b, 0xc6, 0x1b, 0x21, 0xdd, 0x04,
@@ -4118,9 +4118,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             ],
             cv_net: [
-                0x72, 0xd8, 0x2a, 0xd6, 0x89, 0xd2, 0x9f, 0x9b, 0x18, 0x9d, 0x5b, 0x44, 0x78, 0x9f,
-                0x55, 0xfe, 0x1e, 0x9b, 0xab, 0x78, 0x8f, 0xf8, 0x7e, 0xbe, 0x9f, 0xc8, 0x59, 0x50,
-                0x4f, 0xb2, 0x3c, 0x8a,
+                0x91, 0x6d, 0xc3, 0x82, 0x2a, 0x4e, 0x3b, 0xb4, 0x1f, 0xa8, 0x33, 0xc2, 0x73, 0xa9,
+                0xd3, 0x7d, 0x17, 0x17, 0xa4, 0x8d, 0x8f, 0x00, 0x6c, 0x1f, 0xf5, 0x86, 0x21, 0x46,
+                0x29, 0x55, 0x39, 0x1c,
             ],
             rho: [
                 0x57, 0x87, 0x18, 0x97, 0x6d, 0xa3, 0xdc, 0xb4, 0x30, 0x32, 0x71, 0x52, 0x20, 0x72,
@@ -4240,9 +4240,9 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xf4, 0x76, 0x11, 0x41, 0xd4, 0xa6,
             ],
             ock: [
-                0xdc, 0xf9, 0x34, 0xcf, 0x6a, 0x64, 0x90, 0x3f, 0x2d, 0x99, 0xa3, 0x07, 0xe1, 0x55,
-                0xfb, 0x90, 0xe9, 0x7a, 0xc9, 0x0c, 0x38, 0x7f, 0x1b, 0xa5, 0xa6, 0xea, 0x43, 0xb5,
-                0x91, 0xb0, 0x5d, 0x69,
+                0x95, 0x83, 0xf1, 0x0f, 0xed, 0x70, 0xa4, 0x1e, 0x45, 0x8c, 0x65, 0x5c, 0xc0, 0x14,
+                0xe2, 0x35, 0x5a, 0x7f, 0x99, 0xae, 0xbc, 0xfe, 0xf7, 0x4a, 0x55, 0x9a, 0xcd, 0x24,
+                0x25, 0xfa, 0x21, 0xcf,
             ],
             op: [
                 0x3e, 0x5e, 0x46, 0xeb, 0x0f, 0xe8, 0xe6, 0xf0, 0xcf, 0x6a, 0xab, 0x2b, 0x41, 0xfb,
@@ -4252,12 +4252,12 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xc4, 0x69, 0x2d, 0x0c, 0x1b, 0x30, 0x33, 0x01,
             ],
             c_out: [
-                0x25, 0xf4, 0xbb, 0x9f, 0xb4, 0x45, 0x06, 0x78, 0x9c, 0xf5, 0x1d, 0xc3, 0xf6, 0x5f,
-                0x17, 0xaf, 0xee, 0xe0, 0x34, 0x92, 0x79, 0xc7, 0x89, 0x28, 0x9b, 0x03, 0xd3, 0x8c,
-                0x2e, 0x20, 0xd3, 0x12, 0x5d, 0xe7, 0xc5, 0x6e, 0x18, 0x29, 0x2d, 0xec, 0xc6, 0x41,
-                0x81, 0xa7, 0xe9, 0xa7, 0xbc, 0x12, 0xeb, 0x97, 0x85, 0xf0, 0xdd, 0x51, 0xd5, 0x88,
-                0x62, 0x00, 0xfb, 0x18, 0x7d, 0x2c, 0x16, 0x90, 0x65, 0xaf, 0x84, 0xcc, 0x02, 0x3d,
-                0x6d, 0x63, 0xce, 0x05, 0x83, 0x28, 0xe2, 0x47, 0xb5, 0x98,
+                0xb8, 0x3b, 0x74, 0x5c, 0x9c, 0x0b, 0x04, 0xdd, 0xc7, 0xf1, 0x38, 0x16, 0x94, 0x38,
+                0x99, 0x55, 0x3a, 0x30, 0x6a, 0x4a, 0xd0, 0xf2, 0xf5, 0x70, 0x92, 0x2a, 0x89, 0x9b,
+                0xab, 0xb9, 0xda, 0xca, 0xd2, 0xbb, 0xc9, 0x5c, 0xf6, 0x5b, 0x73, 0x08, 0x55, 0x0d,
+                0xce, 0xdb, 0x64, 0x9e, 0xf1, 0x5e, 0x0b, 0x1a, 0x09, 0x1f, 0xad, 0x5a, 0x93, 0x92,
+                0xd0, 0x71, 0xb7, 0x5a, 0xb5, 0x1a, 0x7e, 0x35, 0x06, 0xad, 0x58, 0xd1, 0x71, 0x95,
+                0xc9, 0x9f, 0x29, 0x8a, 0xc3, 0x14, 0xec, 0x05, 0xa6, 0x6a,
             ],
             asset: Some([
                 0x96, 0x86, 0xaa, 0x36, 0x36, 0xbd, 0x37, 0x5b, 0xd3, 0x13, 0x6b, 0xee, 0x0b, 0xda,

From babf1da44b91a8030d9eb31f99bb8d22756bb72c Mon Sep 17 00:00:00 2001
From: Paul <3682187+PaulLaux@users.noreply.github.com>
Date: Wed, 21 Dec 2022 11:40:08 +0200
Subject: [PATCH 15/17] CI-Badge (#37)

Added CI badge to README
---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4d4ac85eb..f761aa914 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
-# orchard [![Crates.io](https://img.shields.io/crates/v/orchard.svg)](https://crates.io/crates/orchard) #
+# orchard [![Crates.io](https://img.shields.io/crates/v/orchard.svg)](https://crates.io/crates/orchard) [![CI checks](https://github.com/QED-it/orchard/actions/workflows/ci.yml/badge.svg?branch=zsa1)](https://github.com/QED-it/orchard/actions/workflows/ci.yml)
+#
 
 Requires Rust 1.61+.
 

From 4681cc212a78104ea43387b37f85af7a437ca2cf Mon Sep 17 00:00:00 2001
From: Alexey <alexey.koren@gmail.com>
Date: Fri, 23 Dec 2022 11:29:01 +0100
Subject: [PATCH 16/17] Use different random nullifiers in dummy notes (#39)

---
 src/builder.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 9dfaa9efb..cd452b946 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -403,10 +403,13 @@ impl Builder {
             //     || SpendInfo::dummy(asset, &mut rng),
             //     |s| s.create_split_spend(),
             // );
-            let dummy_spend = SpendInfo::dummy(asset, &mut rng);
+            // spends.extend(iter::repeat_with(|| dummy_spend.clone()).take(num_actions - num_spends));
 
             // Extend the spends and recipients with dummy values.
-            spends.extend(iter::repeat_with(|| dummy_spend.clone()).take(num_actions - num_spends));
+            spends.extend(
+                iter::repeat_with(|| SpendInfo::dummy(asset, &mut rng))
+                    .take(num_actions - num_spends),
+            );
 
             recipients.extend(
                 iter::repeat_with(|| RecipientInfo::dummy(&mut rng, asset))

From cec48d72a15ad44c0c5a8c6a7846946ba1347e79 Mon Sep 17 00:00:00 2001
From: Paul <3682187+PaulLaux@users.noreply.github.com>
Date: Tue, 31 Jan 2023 15:51:29 +0200
Subject: [PATCH 17/17] V3 encryption (#38)

Added `OrchardDomainV3` on top of the encryption generalization (QED-it/librustzcash#18).

not for review: note_encryption.rs, note_encryptionv2v3.rs and src/test_vectors/note_encryption.rs. These files represent two possible approaches for backward compatibility and will be finalized down the road. (the files were excluded from the build).
---
 Cargo.toml                             |    3 +
 benches/note_decryption.rs             |    8 +-
 src/action.rs                          |    4 +-
 src/builder.rs                         |   20 +-
 src/bundle.rs                          |   18 +-
 src/bundle/commitments.rs              |    6 +-
 src/issuance.rs                        |   38 +-
 src/lib.rs                             |    3 +-
 src/note.rs                            |   27 +-
 src/note/asset_id.rs                   |   15 +-
 src/note_encryption.rs                 |  328 +-
 src/note_encryption_v2v3.rs            |  717 ++++
 src/note_encryption_v3.rs              |  634 ++++
 src/test_vectors.rs                    |    1 +
 src/test_vectors/note_encryption.rs    | 2155 +-----------
 src/test_vectors/note_encryption_v3.rs | 4389 ++++++++++++++++++++++++
 src/value.rs                           |    5 +-
 tests/builder.rs                       |    4 +-
 tests/zsa.rs                           |    4 +-
 19 files changed, 6028 insertions(+), 2351 deletions(-)
 create mode 100644 src/note_encryption_v2v3.rs
 create mode 100644 src/note_encryption_v3.rs
 create mode 100644 src/test_vectors/note_encryption_v3.rs

diff --git a/Cargo.toml b/Cargo.toml
index cb7508702..b5461be1e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -84,3 +84,6 @@ debug = true
 
 [profile.bench]
 debug = true
+
+[patch.crates-io]
+zcash_note_encryption = { git = "https://github.com/QED-it/librustzcash.git", rev = "07c377ddedf71ab7c7a266d284b054a2dafc2ed4" }
diff --git a/benches/note_decryption.rs b/benches/note_decryption.rs
index 1417a2b6c..244de4378 100644
--- a/benches/note_decryption.rs
+++ b/benches/note_decryption.rs
@@ -5,7 +5,7 @@ use orchard::{
     circuit::ProvingKey,
     keys::{FullViewingKey, PreparedIncomingViewingKey, Scope, SpendingKey},
     note::AssetId,
-    note_encryption::{CompactAction, OrchardDomain},
+    note_encryption_v3::{CompactAction, OrchardDomainV3},
     value::NoteValue,
     Anchor, Bundle,
 };
@@ -79,7 +79,7 @@ fn bench_note_decryption(c: &mut Criterion) {
     };
     let action = bundle.actions().first();
 
-    let domain = OrchardDomain::for_action(action);
+    let domain = OrchardDomainV3::for_action(action);
 
     let compact = {
         let mut group = c.benchmark_group("note-decryption");
@@ -120,12 +120,12 @@ fn bench_note_decryption(c: &mut Criterion) {
         let ivks = 2;
         let valid_ivks = vec![valid_ivk; ivks];
         let actions: Vec<_> = (0..100)
-            .map(|_| (OrchardDomain::for_action(action), action.clone()))
+            .map(|_| (OrchardDomainV3::for_action(action), action.clone()))
             .collect();
         let compact: Vec<_> = (0..100)
             .map(|_| {
                 (
-                    OrchardDomain::for_action(action),
+                    OrchardDomainV3::for_action(action),
                     CompactAction::from(action),
                 )
             })
diff --git a/src/action.rs b/src/action.rs
index 94fe4f3f4..ed3fe1661 100644
--- a/src/action.rs
+++ b/src/action.rs
@@ -158,7 +158,7 @@ pub(crate) mod testing {
             // FIXME: make a real one from the note.
             let encrypted_note = TransmittedNoteCiphertext {
                 epk_bytes: [0u8; 32],
-                enc_ciphertext: [0u8; 580],
+                enc_ciphertext: [0u8; 612],
                 out_ciphertext: [0u8; 80]
             };
             Action {
@@ -192,7 +192,7 @@ pub(crate) mod testing {
             // FIXME: make a real one from the note.
             let encrypted_note = TransmittedNoteCiphertext {
                 epk_bytes: [0u8; 32],
-                enc_ciphertext: [0u8; 580],
+                enc_ciphertext: [0u8; 612],
                 out_ciphertext: [0u8; 80]
             };
 
diff --git a/src/builder.rs b/src/builder.rs
index cd452b946..d420d742e 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -20,7 +20,7 @@ use crate::{
         SpendingKey,
     },
     note::{Note, TransmittedNoteCiphertext},
-    note_encryption::OrchardNoteEncryption,
+    note_encryption_v3::OrchardNoteEncryption,
     primitives::redpallas::{self, Binding, SpendAuth},
     tree::{Anchor, MerklePath},
     value::{self, NoteValue, OverflowError, ValueCommitTrapdoor, ValueCommitment, ValueSum},
@@ -79,7 +79,12 @@ impl SpendInfo {
     /// Returns `None` if the `fvk` does not own the `note`.
     ///
     /// [`Builder::add_spend`]: Builder::add_spend
-    pub fn new(fvk: FullViewingKey, note: Note, merkle_path: MerklePath) -> Option<Self> {
+    pub fn new(
+        fvk: FullViewingKey,
+        note: Note,
+        merkle_path: MerklePath,
+        split_flag: bool,
+    ) -> Option<Self> {
         let scope = fvk.scope_for_address(&note.recipient())?;
         Some(SpendInfo {
             dummy_sk: None,
@@ -87,7 +92,7 @@ impl SpendInfo {
             scope,
             note,
             merkle_path,
-            split_flag: false,
+            split_flag,
         })
     }
 
@@ -112,10 +117,7 @@ impl SpendInfo {
 
     /// Return a copy of this note with the split flag set to `true`.
     fn create_split_spend(&self) -> Self {
-        let mut split_spend = SpendInfo::new(self.fvk.clone(), self.note, self.merkle_path.clone())
-            .expect("The spend info is valid");
-        split_spend.split_flag = true;
-        split_spend
+        SpendInfo::new(self.fvk.clone(), self.note, self.merkle_path.clone(), true).unwrap()
     }
 }
 
@@ -224,7 +226,7 @@ impl ActionInfo {
 
         let encrypted_note = TransmittedNoteCiphertext {
             epk_bytes: encryptor.epk().to_bytes().0,
-            enc_ciphertext: encryptor.encrypt_note_plaintext(),
+            enc_ciphertext: encryptor.encrypt_note_plaintext().0,
             out_ciphertext: encryptor.encrypt_outgoing_plaintext(&cv_net, &cmx, &mut rng),
         };
 
@@ -278,7 +280,7 @@ impl Builder {
     /// Returns an error if the given Merkle path does not have the required anchor for
     /// the given note.
     ///
-    /// [`OrchardDomain`]: crate::note_encryption::OrchardDomain
+    /// [`OrchardDomain`]: crate::note_encryption_v3::OrchardDomainV3
     /// [`MerkleHashOrchard`]: crate::tree::MerkleHashOrchard
     pub fn add_spend(
         &mut self,
diff --git a/src/bundle.rs b/src/bundle.rs
index cbc66e796..1d1363daf 100644
--- a/src/bundle.rs
+++ b/src/bundle.rs
@@ -20,7 +20,7 @@ use crate::{
     circuit::{Instance, Proof, VerifyingKey},
     keys::{IncomingViewingKey, OutgoingViewingKey, PreparedIncomingViewingKey},
     note::Note,
-    note_encryption::OrchardDomain,
+    note_encryption_v3::OrchardDomainV3,
     primitives::redpallas::{self, Binding, SpendAuth},
     tree::Anchor,
     value::{ValueCommitTrapdoor, ValueCommitment, ValueSum},
@@ -305,7 +305,7 @@ impl<T: Authorization, V> Bundle<T, V> {
             .iter()
             .enumerate()
             .filter_map(|(idx, action)| {
-                let domain = OrchardDomain::for_action(action);
+                let domain = OrchardDomainV3::for_action(action);
                 prepared_keys.iter().find_map(|(ivk, prepared_ivk)| {
                     try_note_decryption(&domain, prepared_ivk, action)
                         .map(|(n, a, m)| (idx, (*ivk).clone(), n, a, m))
@@ -324,7 +324,7 @@ impl<T: Authorization, V> Bundle<T, V> {
     ) -> Option<(Note, Address, [u8; 512])> {
         let prepared_ivk = PreparedIncomingViewingKey::new(key);
         self.actions.get(action_idx).and_then(move |action| {
-            let domain = OrchardDomain::for_action(action);
+            let domain = OrchardDomainV3::for_action(action);
             try_note_decryption(&domain, &prepared_ivk, action)
         })
     }
@@ -341,7 +341,7 @@ impl<T: Authorization, V> Bundle<T, V> {
             .iter()
             .enumerate()
             .filter_map(|(idx, action)| {
-                let domain = OrchardDomain::for_action(action);
+                let domain = OrchardDomainV3::for_action(action);
                 keys.iter().find_map(move |key| {
                     try_output_recovery_with_ovk(
                         &domain,
@@ -365,7 +365,7 @@ impl<T: Authorization, V> Bundle<T, V> {
         key: &OutgoingViewingKey,
     ) -> Option<(Note, Address, [u8; 512])> {
         self.actions.get(action_idx).and_then(move |action| {
-            let domain = OrchardDomain::for_action(action);
+            let domain = OrchardDomainV3::for_action(action);
             try_output_recovery_with_ovk(
                 &domain,
                 key,
@@ -527,7 +527,7 @@ pub mod testing {
     use super::{Action, Authorization, Authorized, Bundle, Flags};
 
     pub use crate::action::testing::{arb_action, arb_unauthorized_action};
-    use crate::note::asset_id::testing::zsa_asset_id;
+    use crate::note::asset_id::testing::arb_zsa_asset_id;
     use crate::note::AssetId;
     use crate::value::testing::arb_value_sum;
 
@@ -591,7 +591,11 @@ pub mod testing {
 
     prop_compose! {
         /// Create an arbitrary vector of assets to burn.
-        pub fn arb_asset_to_burn()(asset_id in zsa_asset_id(), value in arb_value_sum()) -> (AssetId, ValueSum) {
+        pub fn arb_asset_to_burn()
+        (
+            asset_id in arb_zsa_asset_id(),
+            value in arb_value_sum()
+        ) -> (AssetId, ValueSum) {
             (asset_id, value)
         }
     }
diff --git a/src/bundle/commitments.rs b/src/bundle/commitments.rs
index 285ba31f7..dc6a0b65a 100644
--- a/src/bundle/commitments.rs
+++ b/src/bundle/commitments.rs
@@ -42,13 +42,13 @@ pub(crate) fn hash_bundle_txid_data<A: Authorization, V: Copy + Into<i64>>(
         ch.update(&action.nullifier().to_bytes());
         ch.update(&action.cmx().to_bytes());
         ch.update(&action.encrypted_note().epk_bytes);
-        ch.update(&action.encrypted_note().enc_ciphertext[..52]);
+        ch.update(&action.encrypted_note().enc_ciphertext[..84]); // TODO: make sure it is backward compatible with Orchard [..52]
 
-        mh.update(&action.encrypted_note().enc_ciphertext[52..564]);
+        mh.update(&action.encrypted_note().enc_ciphertext[84..596]);
 
         nh.update(&action.cv_net().to_bytes());
         nh.update(&<[u8; 32]>::from(action.rk()));
-        nh.update(&action.encrypted_note().enc_ciphertext[564..]);
+        nh.update(&action.encrypted_note().enc_ciphertext[596..]);
         nh.update(&action.encrypted_note().out_ciphertext);
     }
 
diff --git a/src/issuance.rs b/src/issuance.rs
index 9f15d638f..74247f928 100644
--- a/src/issuance.rs
+++ b/src/issuance.rs
@@ -344,7 +344,7 @@ impl IssueBundle<Signed> {
 ///     * Asset description size is collect.
 ///     * `AssetId` for the `IssueAction` has not been previously finalized.
 /// * For each `Note` inside an `IssueAction`:
-///     * All notes have the same, correct `NoteType`.
+///     * All notes have the same, correct `AssetId`.
 pub fn verify_issue_bundle(
     bundle: &IssueBundle<Signed>,
     sighash: [u8; 32],
@@ -356,7 +356,6 @@ pub fn verify_issue_bundle(
 
     let s = &mut HashSet::<AssetId>::new();
 
-    // An IssueAction could have just one properly derived AssetId.
     let newly_finalized = bundle
         .actions()
         .iter()
@@ -373,7 +372,7 @@ pub fn verify_issue_bundle(
                 return Err(IssueActionPreviouslyFinalizedNoteType(asset));
             }
 
-            // Add to finalization set, if needed.
+            // Add to the finalization set, if needed.
             if action.is_finalized() {
                 newly_finalized.insert(asset);
             }
@@ -1025,30 +1024,31 @@ mod tests {
 pub mod testing {
     use crate::issuance::{IssueAction, IssueBundle, Prepared, Signed, Unauthorized};
     use crate::keys::testing::{arb_issuance_authorizing_key, arb_issuance_validating_key};
+    use crate::note::asset_id::testing::zsa_asset_id;
     use crate::note::testing::arb_zsa_note;
     use proptest::collection::vec;
     use proptest::prelude::*;
     use proptest::prop_compose;
-    use proptest::string::string_regex;
     use rand::{rngs::StdRng, SeedableRng};
 
     prop_compose! {
-        /// Generate an issue action given note value
-        pub fn arb_issue_action()(
-            note in arb_zsa_note(),
-            asset_descr in string_regex(".{1,512}").unwrap()
-        ) -> IssueAction {
-            IssueAction::new(asset_descr, &note)
+        /// Generate an issue action
+        pub fn arb_issue_action(asset_desc: String)
+        (
+            asset in zsa_asset_id(asset_desc.clone()),
+        )
+        (
+            note in arb_zsa_note(asset),
+        )-> IssueAction {
+            IssueAction::new(asset_desc.clone(), &note)
         }
     }
 
     prop_compose! {
-        /// Generate an arbitrary issue bundle with fake authorization data. This bundle does not
-        /// necessarily respect consensus rules; for that use
-        /// [`crate::builder::testing::arb_issue_bundle`]
+        /// Generate an arbitrary issue bundle with fake authorization data.
         pub fn arb_unathorized_issue_bundle(n_actions: usize)
         (
-            actions in vec(arb_issue_action(), n_actions),
+            actions in vec(arb_issue_action("asset_desc".to_string()), n_actions),
             ik in arb_issuance_validating_key()
         ) -> IssueBundle<Unauthorized> {
             IssueBundle {
@@ -1061,11 +1061,10 @@ pub mod testing {
 
     prop_compose! {
         /// Generate an arbitrary issue bundle with fake authorization data. This bundle does not
-        /// necessarily respect consensus rules; for that use
-        /// [`crate::builder::testing::arb_issue_bundle`]
+        /// necessarily respect consensus rules
         pub fn arb_prepared_issue_bundle(n_actions: usize)
         (
-            actions in vec(arb_issue_action(), n_actions),
+            actions in vec(arb_issue_action("asset_desc".to_string()), n_actions),
             ik in arb_issuance_validating_key(),
             fake_sighash in prop::array::uniform32(prop::num::u8::ANY)
         ) -> IssueBundle<Prepared> {
@@ -1079,11 +1078,10 @@ pub mod testing {
 
     prop_compose! {
         /// Generate an arbitrary issue bundle with fake authorization data. This bundle does not
-        /// necessarily respect consensus rules; for that use
-        /// [`crate::builder::testing::arb_issue_bundle`]
+        /// necessarily respect consensus rules
         pub fn arb_signed_issue_bundle(n_actions: usize)
         (
-            actions in vec(arb_issue_action(), n_actions),
+            actions in vec(arb_issue_action("asset_desc".to_string()), n_actions),
             ik in arb_issuance_validating_key(),
             isk in arb_issuance_authorizing_key(),
             rng_seed in prop::array::uniform32(prop::num::u8::ANY),
diff --git a/src/lib.rs b/src/lib.rs
index c0e63ce9b..76d9c41c0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -25,7 +25,8 @@ mod constants;
 pub mod issuance;
 pub mod keys;
 pub mod note;
-pub mod note_encryption;
+// pub mod note_encryption; // disabled until backward compatability is implemented.
+pub mod note_encryption_v3;
 pub mod primitives;
 mod spec;
 pub mod tree;
diff --git a/src/note.rs b/src/note.rs
index d5a58a838..7eeffe096 100644
--- a/src/note.rs
+++ b/src/note.rs
@@ -279,7 +279,7 @@ pub struct TransmittedNoteCiphertext {
     /// The serialization of the ephemeral public key
     pub epk_bytes: [u8; 32],
     /// The encrypted note ciphertext
-    pub enc_ciphertext: [u8; 580],
+    pub enc_ciphertext: [u8; 612],
     /// An encrypted value that allows the holder of the outgoing cipher
     /// key for the note to recover the note plaintext.
     pub out_ciphertext: [u8; 80],
@@ -302,7 +302,7 @@ pub mod testing {
     use proptest::prelude::*;
 
     use crate::note::asset_id::testing::arb_asset_id;
-    use crate::note::asset_id::testing::zsa_asset_id;
+    use crate::note::AssetId;
     use crate::value::testing::arb_note_value;
     use crate::{
         address::testing::arb_address, note::nullifier::testing::arb_nullifier, value::NoteValue,
@@ -336,13 +336,30 @@ pub mod testing {
     }
 
     prop_compose! {
-        /// Generate an arbitrary ZSA note
-        pub fn arb_zsa_note()(
+        /// Generate an arbitrary native note
+        pub fn arb_native_note()(
+            recipient in arb_address(),
+            value in arb_note_value(),
+            rho in arb_nullifier(),
+            rseed in arb_rseed(),
+        ) -> Note {
+            Note {
+                recipient,
+                value,
+                asset: AssetId::native(),
+                rho,
+                rseed,
+            }
+        }
+    }
+
+    prop_compose! {
+        /// Generate an arbitrary zsa note
+        pub fn arb_zsa_note(asset: AssetId)(
             recipient in arb_address(),
             value in arb_note_value(),
             rho in arb_nullifier(),
             rseed in arb_rseed(),
-            asset in zsa_asset_id(),
         ) -> Note {
             Note {
                 recipient,
diff --git a/src/note/asset_id.rs b/src/note/asset_id.rs
index 074e59364..93993c47b 100644
--- a/src/note/asset_id.rs
+++ b/src/note/asset_id.rs
@@ -120,8 +120,8 @@ pub mod testing {
     }
 
     prop_compose! {
-        /// Generate the ZSA note type
-        pub fn zsa_asset_id()(
+        /// Generate an asset ID
+        pub fn arb_zsa_asset_id()(
             sk in arb_spending_key(),
             str in "[A-Za-z]{255}"
         ) -> AssetId {
@@ -130,6 +130,17 @@ pub mod testing {
         }
     }
 
+    prop_compose! {
+        /// Generate an asset ID using a specific description
+        pub fn zsa_asset_id(asset_desc: String)(
+            sk in arb_spending_key(),
+        ) -> AssetId {
+            assert!(super::is_asset_desc_of_valid_size(&asset_desc));
+            let isk = IssuanceAuthorizingKey::from(&sk);
+            AssetId::derive(&IssuanceValidatingKey::from(&isk), &asset_desc)
+        }
+    }
+
     #[test]
     fn test_vectors() {
         let test_vectors = crate::test_vectors::asset_id::test_vectors();
diff --git a/src/note_encryption.rs b/src/note_encryption.rs
index 48456e261..4beb99528 100644
--- a/src/note_encryption.rs
+++ b/src/note_encryption.rs
@@ -1,12 +1,11 @@
 //! In-band secret distribution for Orchard bundles.
 
 use blake2b_simd::{Hash, Params};
-use core::fmt;
 use group::ff::PrimeField;
+use std::fmt;
 use zcash_note_encryption::{
-    BatchDomain, Domain, EphemeralKeyBytes, NotePlaintextBytes, OutPlaintextBytes,
-    OutgoingCipherKey, ShieldedOutput, COMPACT_NOTE_SIZE, ENC_CIPHERTEXT_SIZE, NOTE_PLAINTEXT_SIZE,
-    OUT_PLAINTEXT_SIZE,
+    BatchDomain, Domain, EphemeralKeyBytes, OutPlaintextBytes, OutgoingCipherKey, ShieldedOutput,
+    AEAD_TAG_SIZE, MEMO_SIZE, OUT_PLAINTEXT_SIZE,
 };
 
 use crate::note::AssetId;
@@ -24,14 +23,82 @@ use crate::{
 
 const PRF_OCK_ORCHARD_PERSONALIZATION: &[u8; 16] = b"Zcash_Orchardock";
 
-/// The size of the encoding of a ZSA asset type.
-const ZSA_TYPE_SIZE: usize = 32;
-/// The size of the ZSA variant of COMPACT_NOTE_SIZE.
-const COMPACT_ZSA_NOTE_SIZE: usize = COMPACT_NOTE_SIZE + ZSA_TYPE_SIZE;
-/// The size of the memo.
-const MEMO_SIZE: usize = NOTE_PLAINTEXT_SIZE - COMPACT_NOTE_SIZE;
-/// The size of the ZSA variant of the memo.
-const ZSA_MEMO_SIZE: usize = NOTE_PLAINTEXT_SIZE - COMPACT_ZSA_NOTE_SIZE;
+/// The size of a v2 compact note.
+pub const COMPACT_NOTE_SIZE_V2: usize = 1 + // version
+    11 + // diversifier
+    8  + // value
+    32; // rseed (or rcm prior to ZIP 212)
+/// The size of [`NotePlaintextBytes`] for V2.
+pub const NOTE_PLAINTEXT_SIZE_V2: usize = COMPACT_NOTE_SIZE_V2 + MEMO_SIZE;
+/// The size of an encrypted note plaintext.
+pub const ENC_CIPHERTEXT_SIZE_V2: usize = NOTE_PLAINTEXT_SIZE_V2 + AEAD_TAG_SIZE;
+
+/// a type to represent the raw bytes of a note plaintext.
+#[derive(Clone, Debug)]
+pub struct NotePlaintextBytes(pub [u8; NOTE_PLAINTEXT_SIZE_V2]);
+
+/// a type to represent the raw bytes of an encrypted note plaintext.
+#[derive(Clone, Debug)]
+pub struct NoteCiphertextBytes(pub [u8; ENC_CIPHERTEXT_SIZE_V2]);
+
+/// a type to represent the raw bytes of a compact note.
+#[derive(Clone, Debug)]
+pub struct CompactNotePlaintextBytes(pub [u8; COMPACT_NOTE_SIZE_V2]);
+
+/// a type to represent the raw bytes of an encrypted compact note.
+#[derive(Clone, Debug)]
+pub struct CompactNoteCiphertextBytes(pub [u8; COMPACT_NOTE_SIZE_V2]);
+
+impl AsMut<[u8]> for NotePlaintextBytes {
+    fn as_mut(&mut self) -> &mut [u8] {
+        self.0.as_mut()
+    }
+}
+
+impl From<&[u8]> for NotePlaintextBytes {
+    fn from(s: &[u8]) -> Self
+    where
+        Self: Sized,
+    {
+        NotePlaintextBytes(s.try_into().unwrap())
+    }
+}
+
+impl AsRef<[u8]> for NoteCiphertextBytes {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+impl From<&[u8]> for NoteCiphertextBytes {
+    fn from(s: &[u8]) -> Self
+    where
+        Self: Sized,
+    {
+        NoteCiphertextBytes(s.try_into().unwrap())
+    }
+}
+
+impl AsMut<[u8]> for CompactNotePlaintextBytes {
+    fn as_mut(&mut self) -> &mut [u8] {
+        self.0.as_mut()
+    }
+}
+
+impl From<&[u8]> for CompactNotePlaintextBytes {
+    fn from(s: &[u8]) -> Self
+    where
+        Self: Sized,
+    {
+        CompactNotePlaintextBytes(s.try_into().unwrap())
+    }
+}
+
+impl AsRef<[u8]> for CompactNoteCiphertextBytes {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
 
 /// Defined in [Zcash Protocol Spec § 5.4.2: Pseudo Random Functions][concreteprfs].
 ///
@@ -58,59 +125,58 @@ pub(crate) fn prf_ock_orchard(
     )
 }
 
-/// Domain-specific requirements:
-/// - If the note version is 3, the `plaintext` must contain a valid encoding of a ZSA asset type.
+/// note_version will return the version of the note plaintext.
+pub fn note_version(plaintext: &[u8]) -> Option<u8> {
+    match plaintext[0] {
+        0x02 => Some(0x02),
+        0x03 => Some(0x03),
+        _ => None,
+    }
+}
+
 fn orchard_parse_note_plaintext_without_memo<F>(
-    domain: &OrchardDomain,
-    plaintext: &[u8],
+    domain: &OrchardDomainV2,
+    plaintext: &[u8], // TODO: replace with CompactNotePlaintextBytes
     get_validated_pk_d: F,
 ) -> Option<(Note, Address)>
 where
     F: FnOnce(&Diversifier) -> Option<DiversifiedTransmissionKey>,
 {
-    assert!(plaintext.len() >= COMPACT_NOTE_SIZE);
+    assert!(plaintext.len() >= COMPACT_NOTE_SIZE_V2);
 
     // Check note plaintext version
-    // and parse the asset type accordingly.
-    let asset = parse_version_and_asset_type(plaintext)?;
+    if note_version(plaintext).unwrap() != 0x02 {
+        return None;
+    }
 
     // The unwraps below are guaranteed to succeed by the assertion above
     let diversifier = Diversifier::from_bytes(plaintext[1..12].try_into().unwrap());
     let value = NoteValue::from_bytes(plaintext[12..20].try_into().unwrap());
     let rseed = Option::from(RandomSeed::from_bytes(
-        plaintext[20..COMPACT_NOTE_SIZE].try_into().unwrap(),
+        plaintext[20..COMPACT_NOTE_SIZE_V2].try_into().unwrap(),
         &domain.rho,
     ))?;
 
     let pk_d = get_validated_pk_d(&diversifier)?;
 
     let recipient = Address::from_parts(diversifier, pk_d);
-
-    let note = Option::from(Note::from_parts(recipient, value, asset, domain.rho, rseed))?;
+    let note = Option::from(Note::from_parts(
+        recipient,
+        value,
+        AssetId::native(), //V2 notes are always native.
+        domain.rho,
+        rseed,
+    ))?;
     Some((note, recipient))
 }
 
-fn parse_version_and_asset_type(plaintext: &[u8]) -> Option<AssetId> {
-    // TODO: make this constant-time?
-    match plaintext[0] {
-        0x02 => Some(AssetId::native()),
-        0x03 if plaintext.len() >= COMPACT_ZSA_NOTE_SIZE => {
-            let bytes = &plaintext[COMPACT_NOTE_SIZE..COMPACT_ZSA_NOTE_SIZE]
-                .try_into()
-                .unwrap();
-            AssetId::from_bytes(bytes).into()
-        }
-        _ => None,
-    }
-}
-
 /// Orchard-specific note encryption logic.
 #[derive(Debug)]
-pub struct OrchardDomain {
+pub struct OrchardDomainV2 {
     rho: Nullifier,
 }
 
-impl memuse::DynamicUsage for OrchardDomain {
+impl memuse::DynamicUsage for OrchardDomainV2 {
     fn dynamic_usage(&self) -> usize {
         self.rho.dynamic_usage()
     }
@@ -120,21 +186,21 @@ impl memuse::DynamicUsage for OrchardDomain {
     }
 }
 
-impl OrchardDomain {
+impl OrchardDomainV2 {
     /// Constructs a domain that can be used to trial-decrypt this action's output note.
     pub fn for_action<T>(act: &Action<T>) -> Self {
-        OrchardDomain {
+        OrchardDomainV2 {
             rho: *act.nullifier(),
         }
     }
 
     /// Constructs a domain from a nullifier.
     pub fn for_nullifier(nullifier: Nullifier) -> Self {
-        OrchardDomain { rho: nullifier }
+        OrchardDomainV2 { rho: nullifier }
     }
 }
 
-impl Domain for OrchardDomain {
+impl Domain for OrchardDomainV2 {
     type EphemeralSecretKey = EphemeralSecretKey;
     type EphemeralPublicKey = EphemeralPublicKey;
     type PreparedEphemeralPublicKey = PreparedEphemeralPublicKey;
@@ -150,6 +216,11 @@ impl Domain for OrchardDomain {
     type ExtractedCommitmentBytes = [u8; 32];
     type Memo = [u8; MEMO_SIZE]; // TODO use a more interesting type
 
+    type NotePlaintextBytes = NotePlaintextBytes;
+    type NoteCiphertextBytes = NoteCiphertextBytes;
+    type CompactNotePlaintextBytes = CompactNotePlaintextBytes;
+    type CompactNoteCiphertextBytes = CompactNoteCiphertextBytes;
+
     fn derive_esk(note: &Self::Note) -> Option<Self::EphemeralSecretKey> {
         Some(note.esk())
     }
@@ -192,23 +263,12 @@ impl Domain for OrchardDomain {
         _: &Self::Recipient,
         memo: &Self::Memo,
     ) -> NotePlaintextBytes {
-        let is_native: bool = note.asset().is_native().into();
-
-        let mut np = [0; NOTE_PLAINTEXT_SIZE];
-        np[0] = if is_native { 0x02 } else { 0x03 };
+        let mut np = [0; NOTE_PLAINTEXT_SIZE_V2];
+        np[0] = 0x02;
         np[1..12].copy_from_slice(note.recipient().diversifier().as_array());
         np[12..20].copy_from_slice(&note.value().to_bytes());
-        // todo: add asset_id
         np[20..52].copy_from_slice(note.rseed().as_bytes());
-        if is_native {
-            np[52..].copy_from_slice(memo);
-        } else {
-            let zsa_type = note.asset().to_bytes();
-            np[52..84].copy_from_slice(&zsa_type);
-            let short_memo = &memo[0..memo.len() - ZSA_TYPE_SIZE];
-            np[84..].copy_from_slice(short_memo);
-            // TODO: handle full-size memo or make short_memo explicit.
-        };
+        np[52..].copy_from_slice(memo);
         NotePlaintextBytes(np)
     }
 
@@ -246,9 +306,9 @@ impl Domain for OrchardDomain {
     fn parse_note_plaintext_without_memo_ivk(
         &self,
         ivk: &Self::IncomingViewingKey,
-        plaintext: &[u8],
+        plaintext: &CompactNotePlaintextBytes,
     ) -> Option<(Self::Note, Self::Recipient)> {
-        orchard_parse_note_plaintext_without_memo(self, plaintext, |diversifier| {
+        orchard_parse_note_plaintext_without_memo(self, &plaintext.0, |diversifier| {
             Some(DiversifiedTransmissionKey::derive(ivk, diversifier))
         })
     }
@@ -258,7 +318,7 @@ impl Domain for OrchardDomain {
         pk_d: &Self::DiversifiedTransmissionKey,
         esk: &Self::EphemeralSecretKey,
         ephemeral_key: &EphemeralKeyBytes,
-        plaintext: &NotePlaintextBytes,
+        plaintext: &CompactNotePlaintextBytes,
     ) -> Option<(Self::Note, Self::Recipient)> {
         orchard_parse_note_plaintext_without_memo(self, &plaintext.0, |diversifier| {
             if esk
@@ -274,21 +334,12 @@ impl Domain for OrchardDomain {
         })
     }
 
-    fn extract_memo(&self, plaintext: &NotePlaintextBytes) -> Self::Memo {
-        let mut memo = [0; MEMO_SIZE];
-        match get_note_plaintext_version(plaintext) {
-            0x02 => {
-                let full_memo = &plaintext.0[COMPACT_NOTE_SIZE..NOTE_PLAINTEXT_SIZE];
-                memo.copy_from_slice(full_memo);
-            }
-            0x03 => {
-                // ZSA note plaintexts have a shorter memo.
-                let short_memo = &plaintext.0[COMPACT_ZSA_NOTE_SIZE..NOTE_PLAINTEXT_SIZE];
-                memo[..ZSA_MEMO_SIZE].copy_from_slice(short_memo);
-            }
-            _ => {}
-        };
-        memo
+    fn extract_memo(
+        &self,
+        plaintext: &NotePlaintextBytes,
+    ) -> (Self::CompactNotePlaintextBytes, Self::Memo) {
+        let (compact, memo) = plaintext.0.split_at(COMPACT_NOTE_SIZE_V2);
+        (compact.try_into().unwrap(), memo.try_into().unwrap())
     }
 
     fn extract_pk_d(out_plaintext: &OutPlaintextBytes) -> Option<Self::DiversifiedTransmissionKey> {
@@ -301,7 +352,7 @@ impl Domain for OrchardDomain {
     }
 }
 
-impl BatchDomain for OrchardDomain {
+impl BatchDomain for OrchardDomainV2 {
     fn batch_kdf<'a>(
         items: impl Iterator<Item = (Option<Self::SharedSecret>, &'a EphemeralKeyBytes)>,
     ) -> Vec<Option<Self::SymmetricKey>> {
@@ -316,14 +367,10 @@ impl BatchDomain for OrchardDomain {
     }
 }
 
-fn get_note_plaintext_version(plaintext: &NotePlaintextBytes) -> u8 {
-    plaintext.0[0]
-}
-
 /// Implementation of in-band secret distribution for Orchard bundles.
-pub type OrchardNoteEncryption = zcash_note_encryption::NoteEncryption<OrchardDomain>;
+pub type OrchardNoteEncryption = zcash_note_encryption::NoteEncryption<OrchardDomainV2>;
 
-impl<T> ShieldedOutput<OrchardDomain, ENC_CIPHERTEXT_SIZE> for Action<T> {
+impl<T> ShieldedOutput<OrchardDomainV2> for Action<T> {
     fn ephemeral_key(&self) -> EphemeralKeyBytes {
         EphemeralKeyBytes(self.encrypted_note().epk_bytes)
     }
@@ -332,8 +379,16 @@ impl<T> ShieldedOutput<OrchardDomain, ENC_CIPHERTEXT_SIZE> for Action<T> {
         self.cmx().to_bytes()
     }
 
-    fn enc_ciphertext(&self) -> &[u8; ENC_CIPHERTEXT_SIZE] {
-        &self.encrypted_note().enc_ciphertext
+    fn enc_ciphertext(&self) -> Option<NoteCiphertextBytes> {
+        Some(NoteCiphertextBytes(self.encrypted_note().enc_ciphertext))
+    }
+
+    fn enc_ciphertext_compact(&self) -> CompactNoteCiphertextBytes {
+        CompactNoteCiphertextBytes(
+            self.encrypted_note().enc_ciphertext[..COMPACT_NOTE_SIZE_V2]
+                .try_into()
+                .unwrap(),
+        )
     }
 }
 
@@ -342,7 +397,7 @@ pub struct CompactAction {
     nullifier: Nullifier,
     cmx: ExtractedNoteCommitment,
     ephemeral_key: EphemeralKeyBytes,
-    enc_ciphertext: [u8; COMPACT_NOTE_SIZE],
+    enc_ciphertext: CompactNoteCiphertextBytes,
 }
 
 impl fmt::Debug for CompactAction {
@@ -351,20 +406,25 @@ impl fmt::Debug for CompactAction {
     }
 }
 
-impl<T> From<&Action<T>> for CompactAction {
+impl<T> From<&Action<T>> for CompactAction
+where
+    Action<T>: ShieldedOutput<OrchardDomainV2>,
+{
     fn from(action: &Action<T>) -> Self {
         CompactAction {
             nullifier: *action.nullifier(),
             cmx: *action.cmx(),
             ephemeral_key: action.ephemeral_key(),
-            enc_ciphertext: action.encrypted_note().enc_ciphertext[..COMPACT_NOTE_SIZE]
-                .try_into()
-                .unwrap(),
+            enc_ciphertext: CompactNoteCiphertextBytes(
+                action.encrypted_note().enc_ciphertext[..COMPACT_NOTE_SIZE_V2]
+                    .try_into()
+                    .unwrap(),
+            ),
         }
     }
 }
 
-impl ShieldedOutput<OrchardDomain, COMPACT_NOTE_SIZE> for CompactAction {
+impl ShieldedOutput<OrchardDomainV2> for CompactAction {
     fn ephemeral_key(&self) -> EphemeralKeyBytes {
         EphemeralKeyBytes(self.ephemeral_key.0)
     }
@@ -373,8 +433,12 @@ impl ShieldedOutput<OrchardDomain, COMPACT_NOTE_SIZE> for CompactAction {
         self.cmx.to_bytes()
     }
 
-    fn enc_ciphertext(&self) -> &[u8; COMPACT_NOTE_SIZE] {
-        &self.enc_ciphertext
+    fn enc_ciphertext(&self) -> Option<NoteCiphertextBytes> {
+        None
+    }
+
+    fn enc_ciphertext_compact(&self) -> CompactNoteCiphertextBytes {
+        self.enc_ciphertext.clone()
     }
 }
 
@@ -384,7 +448,7 @@ impl CompactAction {
         nullifier: Nullifier,
         cmx: ExtractedNoteCommitment,
         ephemeral_key: EphemeralKeyBytes,
-        enc_ciphertext: [u8; 52],
+        enc_ciphertext: CompactNoteCiphertextBytes,
     ) -> Self {
         Self {
             nullifier,
@@ -402,14 +466,14 @@ impl CompactAction {
 
 #[cfg(test)]
 mod tests {
-    use proptest::prelude::*;
+    use proptest::proptest;
     use rand::rngs::OsRng;
     use zcash_note_encryption::{
         try_compact_note_decryption, try_note_decryption, try_output_recovery_with_ovk, Domain,
         EphemeralKeyBytes,
     };
 
-    use super::{prf_ock_orchard, CompactAction, OrchardDomain, OrchardNoteEncryption};
+    use super::{prf_ock_orchard, CompactAction, OrchardDomainV2, OrchardNoteEncryption};
     use crate::note::AssetId;
     use crate::{
         action::Action,
@@ -418,53 +482,46 @@ mod tests {
             OutgoingViewingKey, PreparedIncomingViewingKey,
         },
         note::{
-            testing::arb_note, ExtractedNoteCommitment, Nullifier, RandomSeed,
+            testing::arb_native_note, ExtractedNoteCommitment, Nullifier, RandomSeed,
             TransmittedNoteCiphertext,
         },
+        note_encryption::{
+            note_version, orchard_parse_note_plaintext_without_memo, NoteCiphertextBytes,
+        },
         primitives::redpallas,
         value::{NoteValue, ValueCommitment},
         Address, Note,
     };
 
-    use super::{get_note_plaintext_version, orchard_parse_note_plaintext_without_memo};
-
     proptest! {
-    #[test]
-    fn test_encoding_roundtrip(
-        note in arb_note(NoteValue::from_raw(10)),
-    ) {
-        let memo = &crate::test_vectors::note_encryption::test_vectors()[0].memo;
-
-        // Encode.
-        let plaintext = OrchardDomain::note_plaintext_bytes(&note, &note.recipient(), memo);
-
-        // Decode.
-        let domain = OrchardDomain { rho: note.rho() };
-        let parsed_version = get_note_plaintext_version(&plaintext);
-        let parsed_memo = domain.extract_memo(&plaintext);
-
-        let (parsed_note, parsed_recipient) = orchard_parse_note_plaintext_without_memo(&domain, &plaintext.0,
-            |diversifier| {
-                assert_eq!(diversifier, &note.recipient().diversifier());
-                Some(*note.recipient().pk_d())
-            }
-        ).expect("Plaintext parsing failed");
-
-        // Check.
-        assert_eq!(parsed_note, note);
-        assert_eq!(parsed_recipient, note.recipient());
+        #[test]
+        fn test_encoding_roundtrip(
+            note in arb_native_note(),
+        ) {
+            let memo = &crate::test_vectors::note_encryption::test_vectors()[0].memo;
+
+            // Encode.
+            let mut plaintext = OrchardDomainV2::note_plaintext_bytes(&note, &note.recipient(), memo);
+
+            // Decode.
+            let domain = OrchardDomainV2 { rho: note.rho() };
+            let parsed_version = note_version(plaintext.as_mut()).unwrap();
+            let (compact,parsed_memo) = domain.extract_memo(&plaintext);
+
+            let (parsed_note, parsed_recipient) = orchard_parse_note_plaintext_without_memo(&domain, &compact.0,
+                |diversifier| {
+                    assert_eq!(diversifier, &note.recipient().diversifier());
+                    Some(*note.recipient().pk_d())
+                }
+            ).expect("Plaintext parsing failed");
 
-        if parsed_note.asset().is_native().into() {
-            assert_eq!(parsed_version, 0x02);
+            // Check.
+            assert_eq!(parsed_note, note);
+            assert_eq!(parsed_recipient, note.recipient());
             assert_eq!(&parsed_memo, memo);
-        } else {
-            assert_eq!(parsed_version, 0x03);
-            let mut short_memo = *memo;
-            short_memo[512 - 32..].copy_from_slice(&[0; 32]);
-            assert_eq!(parsed_memo, short_memo);
+            assert_eq!(parsed_version, 0x02);
         }
     }
-    }
 
     #[test]
     fn test_vectors() {
@@ -509,13 +566,7 @@ mod tests {
             assert_eq!(ock.as_ref(), tv.ock);
 
             let recipient = Address::from_parts(d, pk_d);
-
-            let asset = match tv.asset {
-                None => AssetId::native(),
-                Some(type_bytes) => AssetId::from_bytes(&type_bytes).unwrap(),
-            };
-
-            let note = Note::from_parts(recipient, value, asset, rho, rseed).unwrap();
+            let note = Note::from_parts(recipient, value, AssetId::native(), rho, rseed).unwrap();
             assert_eq!(ExtractedNoteCommitment::from(note.commitment()), cmx);
 
             let action = Action::from_parts(
@@ -538,7 +589,7 @@ mod tests {
             // (Tested first because it only requires immutable references.)
             //
 
-            let domain = OrchardDomain { rho };
+            let domain = OrchardDomainV2 { rho };
 
             match try_note_decryption(&domain, &ivk, &action) {
                 Some((decrypted_note, decrypted_to, decrypted_memo)) => {
@@ -554,8 +605,7 @@ mod tests {
                     assert_eq!(decrypted_note, note);
                     assert_eq!(decrypted_to, recipient);
                 }
-                None => assert!(tv.asset.is_some(), "Compact note decryption failed"),
-                // Ignore that ZSA notes are not detected in compact decryption.
+                None => panic!("Compact note decryption failed"),
             }
 
             match try_output_recovery_with_ovk(&domain, &ovk, &action, &cv_net, &tv.c_out) {
diff --git a/src/note_encryption_v2v3.rs b/src/note_encryption_v2v3.rs
new file mode 100644
index 000000000..bef34e06e
--- /dev/null
+++ b/src/note_encryption_v2v3.rs
@@ -0,0 +1,717 @@
+//! In-band secret distribution for Orchard bundles.
+
+use blake2b_simd::{Hash, Params};
+use core::fmt;
+use group::ff::PrimeField;
+use zcash_note_encryption::{
+    BatchDomain, Domain, EphemeralKeyBytes, OutPlaintextBytes, OutgoingCipherKey, ShieldedOutput,
+    AEAD_TAG_SIZE, MEMO_SIZE, OUT_PLAINTEXT_SIZE,
+};
+
+use crate::note::AssetId;
+use crate::{
+    action::Action,
+    keys::{
+        DiversifiedTransmissionKey, Diversifier, EphemeralPublicKey, EphemeralSecretKey,
+        IncomingViewingKey, OutgoingViewingKey, SharedSecret,
+    },
+    note::{ExtractedNoteCommitment, Nullifier, RandomSeed},
+    spec::diversify_hash,
+    value::{NoteValue, ValueCommitment},
+    Address, Note,
+};
+
+const PRF_OCK_ORCHARD_PERSONALIZATION: &[u8; 16] = b"Zcash_Orchardock";
+
+/// The size of a v2 compact note.
+pub const COMPACT_NOTE_SIZE_V2: usize = 1 + // version
+    11 + // diversifier
+    8  + // value
+    32; // rseed (or rcm prior to ZIP 212)
+/// The size of [`NotePlaintextBytes`] for V2.
+pub const NOTE_PLAINTEXT_SIZE_V2: usize = COMPACT_NOTE_SIZE_V2 + MEMO_SIZE;
+/// The size of an encrypted note plaintext.
+pub const ENC_CIPHERTEXT_SIZE_V2: usize = NOTE_PLAINTEXT_SIZE_V2 + AEAD_TAG_SIZE;
+
+/// The size of the encoding of a ZSA asset id.
+const ZSA_ASSET_SIZE: usize = 32;
+/// The size of a v3 compact note.
+const COMPACT_NOTE_SIZE_V3: usize = COMPACT_NOTE_SIZE_V2 + ZSA_ASSET_SIZE;
+/// The size of [`NotePlaintextBytes`] for V3.
+const NOTE_PLAINTEXT_SIZE_V3: usize = COMPACT_NOTE_SIZE_V3 + MEMO_SIZE;
+/// The size of the encrypted ciphertext of the ZSA variant of a note.
+const ENC_CIPHERTEXT_SIZE_V3: usize = NOTE_PLAINTEXT_SIZE_V3 + AEAD_TAG_SIZE;
+
+/// Defined in [Zcash Protocol Spec § 5.4.2: Pseudo Random Functions][concreteprfs].
+///
+/// [concreteprfs]: https://zips.z.cash/protocol/nu5.pdf#concreteprfs
+pub(crate) fn prf_ock_orchard(
+    ovk: &OutgoingViewingKey,
+    cv: &ValueCommitment,
+    cmx_bytes: &[u8; 32],
+    ephemeral_key: &EphemeralKeyBytes,
+) -> OutgoingCipherKey {
+    OutgoingCipherKey(
+        Params::new()
+            .hash_length(32)
+            .personal(PRF_OCK_ORCHARD_PERSONALIZATION)
+            .to_state()
+            .update(ovk.as_ref())
+            .update(&cv.to_bytes())
+            .update(cmx_bytes)
+            .update(ephemeral_key.as_ref())
+            .finalize()
+            .as_bytes()
+            .try_into()
+            .unwrap(),
+    )
+}
+
+// TODO: VA: Needs updating
+/// Domain-specific requirements:
+/// - If the note version is 3, the `plaintext` must contain a valid encoding of a ZSA asset type.
+fn orchard_parse_note_plaintext_without_memo<F>(
+    domain: &OrchardDomain,
+    plaintext: &CompactNotePlaintextBytes,
+    get_validated_pk_d: F,
+) -> Option<(Note, Address)>
+where
+    F: FnOnce(&Diversifier) -> Option<DiversifiedTransmissionKey>,
+{
+    // Check note plaintext version
+    // and parse the asset type accordingly.
+    let asset = parse_version_and_asset_type(plaintext)?;
+
+    let mut plaintext_inner = [0u8; COMPACT_NOTE_SIZE_V2];
+    match plaintext {
+        CompactNotePlaintextBytes::V2(x) => {
+            plaintext_inner.copy_from_slice(&x[..COMPACT_NOTE_SIZE_V2])
+        }
+        CompactNotePlaintextBytes::V3(x) => {
+            plaintext_inner.copy_from_slice(&x[..COMPACT_NOTE_SIZE_V2])
+        }
+    }
+
+    // The unwraps below are guaranteed to succeed by the assertion above
+    let diversifier = Diversifier::from_bytes(plaintext_inner[1..12].try_into().unwrap());
+    let value = NoteValue::from_bytes(plaintext_inner[12..20].try_into().unwrap());
+    let rseed = Option::from(RandomSeed::from_bytes(
+        plaintext_inner[20..COMPACT_NOTE_SIZE_V2]
+            .try_into()
+            .unwrap(),
+        &domain.rho,
+    ))?;
+
+    let pk_d = get_validated_pk_d(&diversifier)?;
+
+    let recipient = Address::from_parts(diversifier, pk_d);
+    let note = Option::from(Note::from_parts(recipient, value, asset, domain.rho, rseed))?;
+    Some((note, recipient))
+}
+
+fn parse_version_and_asset_type(plaintext: &CompactNotePlaintextBytes) -> Option<AssetId> {
+    match plaintext {
+        CompactNotePlaintextBytes::V2(x) if x[0] == 0x02 => Some(AssetId::native()),
+        CompactNotePlaintextBytes::V3(x) if x[0] == 0x03 => {
+            let bytes = x[COMPACT_NOTE_SIZE_V2..COMPACT_NOTE_SIZE_V3]
+                .try_into()
+                .unwrap();
+            AssetId::from_bytes(bytes).into()
+        }
+        _ => None,
+    }
+}
+
+/// Orchard-specific note encryption logic.
+#[derive(Debug)]
+pub struct OrchardDomain {
+    rho: Nullifier,
+}
+
+/// Newtype for encoding the note plaintext post ZSA.
+// pub struct NotePlaintextZSA (pub [u8; ZSA_NOTE_PLAINTEXT_SIZE]);
+#[derive(Clone, Debug)]
+pub enum NotePlaintextBytes {
+    /// Variant for old note plaintexts.
+    V2([u8; NOTE_PLAINTEXT_SIZE_V2]),
+    /// Variant for the new note plaintexts post ZSA.
+    V3([u8; NOTE_PLAINTEXT_SIZE_V3]),
+}
+
+impl AsMut<[u8]> for NotePlaintextBytes {
+    fn as_mut(&mut self) -> &mut [u8] {
+        match self {
+            NotePlaintextBytes::V2(x) => x.as_mut(),
+            NotePlaintextBytes::V3(x) => x.as_mut(),
+        }
+    }
+}
+
+impl From<&[u8]> for NotePlaintextBytes {
+    fn from(s: &[u8]) -> Self
+    where
+        Self: Sized,
+    {
+        match s.len() {
+            NOTE_PLAINTEXT_SIZE_V2 => NotePlaintextBytes::V2(s.try_into().unwrap()),
+            NOTE_PLAINTEXT_SIZE_V3 => NotePlaintextBytes::V3(s.try_into().unwrap()),
+            _ => panic!("Invalid note plaintext size"),
+        }
+    }
+}
+
+/// Newtype for encoding the encrypted note ciphertext post ZSA.
+// pub struct EncNoteCiphertextZSA (pub [u8; ZSA_ENC_CIPHERTEXT_SIZE]);
+#[derive(Clone, Debug)]
+pub enum NoteCiphertextBytes {
+    /// Variant for old encrypted note ciphertexts.
+    V2([u8; ENC_CIPHERTEXT_SIZE_V2]),
+    /// Variant for new encrypted note ciphertexts post ZSA.
+    V3([u8; ENC_CIPHERTEXT_SIZE_V3]),
+}
+
+impl AsRef<[u8]> for NoteCiphertextBytes {
+    fn as_ref(&self) -> &[u8] {
+        match self {
+            NoteCiphertextBytes::V2(x) => x,
+            NoteCiphertextBytes::V3(x) => x,
+        }
+    }
+}
+
+/// Panics if the given slice is not `ENC_CIPHERTEXT_SIZE_V2` or `ENC_CIPHERTEXT_SIZE_V3` bytes long.
+impl From<&[u8]> for NoteCiphertextBytes {
+    fn from(s: &[u8]) -> Self
+    where
+        Self: Sized,
+    {
+        match s.len() {
+            ENC_CIPHERTEXT_SIZE_V2 => NoteCiphertextBytes::V2(s.try_into().unwrap()),
+            ENC_CIPHERTEXT_SIZE_V3 => NoteCiphertextBytes::V3(s.try_into().unwrap()),
+            _ => panic!("Invalid length for compact note plaintext"),
+        }
+    }
+}
+
+/// Newtype for encoding a compact note
+#[derive(Clone, Debug)]
+pub enum CompactNotePlaintextBytes {
+    /// Variant for old compact notes.
+    V2([u8; COMPACT_NOTE_SIZE_V2]),
+    /// Variant for new compact notes post ZSA.
+    V3([u8; COMPACT_NOTE_SIZE_V3]),
+}
+
+impl AsMut<[u8]> for CompactNotePlaintextBytes {
+    fn as_mut(&mut self) -> &mut [u8] {
+        match self {
+            CompactNotePlaintextBytes::V2(x) => x,
+            CompactNotePlaintextBytes::V3(x) => x,
+        }
+    }
+}
+
+/// Panics if the given slice is not `COMPACT_NOTE_SIZE_V2` or `COMPACT_NOTE_SIZE_V3` bytes long.
+impl From<&[u8]> for CompactNotePlaintextBytes {
+    fn from(s: &[u8]) -> Self
+    where
+        Self: Sized,
+    {
+        match s.len() {
+            COMPACT_NOTE_SIZE_V2 => CompactNotePlaintextBytes::V2(s.try_into().unwrap()),
+            COMPACT_NOTE_SIZE_V3 => CompactNotePlaintextBytes::V3(s.try_into().unwrap()),
+            _ => panic!("Invalid length for compact note plaintext"),
+        }
+    }
+}
+
+/// Newtype for encoding a compact note
+#[derive(Clone, Debug)]
+pub enum CompactNoteCiphertextBytes {
+    /// Variant for old compact notes.
+    V2([u8; COMPACT_NOTE_SIZE_V2]),
+    /// Variant for new compact notes post ZSA.
+    V3([u8; COMPACT_NOTE_SIZE_V3]),
+}
+
+impl AsRef<[u8]> for CompactNoteCiphertextBytes {
+    fn as_ref(&self) -> &[u8] {
+        match self {
+            CompactNoteCiphertextBytes::V2(x) => x,
+            CompactNoteCiphertextBytes::V3(x) => x,
+        }
+    }
+}
+
+impl OrchardDomain {
+    /// Constructs a domain that can be used to trial-decrypt this action's output note.
+    pub fn for_action<T>(act: &Action<T>) -> Self {
+        OrchardDomain {
+            rho: *act.nullifier(),
+        }
+    }
+
+    /// Constructs a domain from a nullifier.
+    pub fn for_nullifier(nullifier: Nullifier) -> Self {
+        OrchardDomain { rho: nullifier }
+    }
+}
+
+impl Domain for OrchardDomain {
+    type EphemeralSecretKey = EphemeralSecretKey;
+    type EphemeralPublicKey = EphemeralPublicKey;
+    type PreparedEphemeralPublicKey = EphemeralPublicKey;
+    type SharedSecret = SharedSecret;
+    type SymmetricKey = Hash;
+    type Note = Note;
+    type Recipient = Address;
+    type DiversifiedTransmissionKey = DiversifiedTransmissionKey;
+    type IncomingViewingKey = IncomingViewingKey;
+    type OutgoingViewingKey = OutgoingViewingKey;
+    type ValueCommitment = ValueCommitment;
+    type ExtractedCommitment = ExtractedNoteCommitment;
+    type ExtractedCommitmentBytes = [u8; 32];
+    type Memo = [u8; MEMO_SIZE]; // TODO use a more interesting type
+
+    type NotePlaintextBytes = NotePlaintextBytes;
+    type NoteCiphertextBytes = NoteCiphertextBytes;
+    type CompactNotePlaintextBytes = CompactNotePlaintextBytes;
+    type CompactNoteCiphertextBytes = CompactNoteCiphertextBytes;
+
+    fn derive_esk(note: &Self::Note) -> Option<Self::EphemeralSecretKey> {
+        Some(note.esk())
+    }
+
+    fn get_pk_d(note: &Self::Note) -> Self::DiversifiedTransmissionKey {
+        *note.recipient().pk_d()
+    }
+
+    fn prepare_epk(epk: Self::EphemeralPublicKey) -> Self::PreparedEphemeralPublicKey {
+        epk
+    }
+
+    fn ka_derive_public(
+        note: &Self::Note,
+        esk: &Self::EphemeralSecretKey,
+    ) -> Self::EphemeralPublicKey {
+        esk.derive_public(note.recipient().g_d())
+    }
+
+    fn ka_agree_enc(
+        esk: &Self::EphemeralSecretKey,
+        pk_d: &Self::DiversifiedTransmissionKey,
+    ) -> Self::SharedSecret {
+        esk.agree(pk_d)
+    }
+
+    fn ka_agree_dec(
+        ivk: &Self::IncomingViewingKey,
+        epk: &Self::PreparedEphemeralPublicKey,
+    ) -> Self::SharedSecret {
+        epk.agree(ivk)
+    }
+
+    fn kdf(secret: Self::SharedSecret, ephemeral_key: &EphemeralKeyBytes) -> Self::SymmetricKey {
+        secret.kdf_orchard(ephemeral_key)
+    }
+
+    fn note_plaintext_bytes(
+        note: &Self::Note,
+        _: &Self::Recipient,
+        memo: &Self::Memo,
+    ) -> NotePlaintextBytes {
+        let mut np = [0u8; NOTE_PLAINTEXT_SIZE_V3];
+        np[0] = 0x03;
+        np[1..12].copy_from_slice(note.recipient().diversifier().as_array());
+        np[12..20].copy_from_slice(&note.value().to_bytes());
+        np[20..52].copy_from_slice(note.rseed().as_bytes());
+        let zsa_type = note.asset().to_bytes();
+        np[52..84].copy_from_slice(&zsa_type);
+        np[84..].copy_from_slice(memo);
+        NotePlaintextBytes::V3(np)
+    }
+
+    fn derive_ock(
+        ovk: &Self::OutgoingViewingKey,
+        cv: &Self::ValueCommitment,
+        cmstar_bytes: &Self::ExtractedCommitmentBytes,
+        ephemeral_key: &EphemeralKeyBytes,
+    ) -> OutgoingCipherKey {
+        prf_ock_orchard(ovk, cv, cmstar_bytes, ephemeral_key)
+    }
+
+    fn outgoing_plaintext_bytes(
+        note: &Self::Note,
+        esk: &Self::EphemeralSecretKey,
+    ) -> OutPlaintextBytes {
+        let mut op = [0; OUT_PLAINTEXT_SIZE];
+        op[..32].copy_from_slice(&note.recipient().pk_d().to_bytes());
+        op[32..].copy_from_slice(&esk.0.to_repr());
+        OutPlaintextBytes(op)
+    }
+
+    fn epk_bytes(epk: &Self::EphemeralPublicKey) -> EphemeralKeyBytes {
+        epk.to_bytes()
+    }
+
+    fn epk(ephemeral_key: &EphemeralKeyBytes) -> Option<Self::EphemeralPublicKey> {
+        EphemeralPublicKey::from_bytes(&ephemeral_key.0).into()
+    }
+
+    fn cmstar(note: &Self::Note) -> Self::ExtractedCommitment {
+        note.commitment().into()
+    }
+
+    fn parse_note_plaintext_without_memo_ivk(
+        &self,
+        ivk: &Self::IncomingViewingKey,
+        plaintext: &CompactNotePlaintextBytes,
+    ) -> Option<(Self::Note, Self::Recipient)> {
+        orchard_parse_note_plaintext_without_memo(self, plaintext, |diversifier| {
+            Some(DiversifiedTransmissionKey::derive(ivk, diversifier))
+        })
+    }
+
+    fn parse_note_plaintext_without_memo_ovk(
+        &self,
+        pk_d: &Self::DiversifiedTransmissionKey,
+        esk: &Self::EphemeralSecretKey,
+        ephemeral_key: &EphemeralKeyBytes,
+        plaintext: &CompactNotePlaintextBytes,
+    ) -> Option<(Self::Note, Self::Recipient)> {
+        orchard_parse_note_plaintext_without_memo(self, plaintext, |diversifier| {
+            if esk
+                .derive_public(diversify_hash(diversifier.as_array()))
+                .to_bytes()
+                .0
+                == ephemeral_key.0
+            {
+                Some(*pk_d)
+            } else {
+                None
+            }
+        })
+    }
+
+    fn extract_memo(
+        &self,
+        plaintext: &NotePlaintextBytes,
+    ) -> (Self::CompactNotePlaintextBytes, Self::Memo) {
+        match plaintext {
+            NotePlaintextBytes::V2(np) => {
+                let (compact, memo) = np.split_at(COMPACT_NOTE_SIZE_V2);
+                (
+                    CompactNotePlaintextBytes::V2(compact.try_into().unwrap()),
+                    memo.try_into().unwrap(),
+                )
+            }
+            NotePlaintextBytes::V3(np) => {
+                let (compact, memo) = np.split_at(COMPACT_NOTE_SIZE_V3);
+                (
+                    CompactNotePlaintextBytes::V3(compact.try_into().unwrap()),
+                    memo.try_into().unwrap(),
+                )
+            }
+        }
+    }
+
+    fn extract_pk_d(out_plaintext: &OutPlaintextBytes) -> Option<Self::DiversifiedTransmissionKey> {
+        DiversifiedTransmissionKey::from_bytes(out_plaintext.0[0..32].try_into().unwrap()).into()
+    }
+
+    fn extract_esk(out_plaintext: &OutPlaintextBytes) -> Option<Self::EphemeralSecretKey> {
+        EphemeralSecretKey::from_bytes(out_plaintext.0[32..OUT_PLAINTEXT_SIZE].try_into().unwrap())
+            .into()
+    }
+}
+
+impl BatchDomain for OrchardDomain {
+    fn batch_kdf<'a>(
+        items: impl Iterator<Item = (Option<Self::SharedSecret>, &'a EphemeralKeyBytes)>,
+    ) -> Vec<Option<Self::SymmetricKey>> {
+        let (shared_secrets, ephemeral_keys): (Vec<_>, Vec<_>) = items.unzip();
+
+        SharedSecret::batch_to_affine(shared_secrets)
+            .zip(ephemeral_keys.into_iter())
+            .map(|(secret, ephemeral_key)| {
+                secret.map(|dhsecret| SharedSecret::kdf_orchard_inner(dhsecret, ephemeral_key))
+            })
+            .collect()
+    }
+}
+
+
+/// Implementation of in-band secret distribution for Orchard bundles.
+pub type OrchardNoteEncryption = zcash_note_encryption::NoteEncryption<OrchardDomain>;
+
+impl<T> ShieldedOutput<OrchardDomain> for Action<T> {
+    fn ephemeral_key(&self) -> EphemeralKeyBytes {
+        EphemeralKeyBytes(self.encrypted_note().epk_bytes)
+    }
+
+    fn cmstar_bytes(&self) -> [u8; 32] {
+        self.cmx().to_bytes()
+    }
+
+    fn enc_ciphertext(&self) -> Option<NoteCiphertextBytes> {
+        let result = self.encrypted_note().enc_ciphertext.clone();
+        Some(result)
+    }
+
+    fn enc_ciphertext_compact(&self) -> CompactNoteCiphertextBytes {
+        match self.encrypted_note().enc_ciphertext {
+            NoteCiphertextBytes::V2(ncx) => {
+                CompactNoteCiphertextBytes::V2(ncx[..COMPACT_NOTE_SIZE_V2].try_into().unwrap())
+            }
+            NoteCiphertextBytes::V3(ncx) => {
+                CompactNoteCiphertextBytes::V3(ncx[..COMPACT_NOTE_SIZE_V3].try_into().unwrap())
+            }
+        }
+    }
+}
+
+/// A compact Action for light clients.
+pub struct CompactAction {
+    nullifier: Nullifier,
+    cmx: ExtractedNoteCommitment,
+    ephemeral_key: EphemeralKeyBytes,
+    enc_ciphertext: CompactNoteCiphertextBytes,
+}
+
+impl fmt::Debug for CompactAction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "CompactAction")
+    }
+}
+
+impl<T> From<&Action<T>> for CompactAction {
+    fn from(action: &Action<T>) -> Self {
+        let comp_ciphertext: CompactNoteCiphertextBytes =
+            match action.encrypted_note().enc_ciphertext {
+                NoteCiphertextBytes::V2(ncx) => {
+                    CompactNoteCiphertextBytes::V2(ncx[..COMPACT_NOTE_SIZE_V2].try_into().unwrap())
+                }
+                NoteCiphertextBytes::V3(ncx) => {
+                    CompactNoteCiphertextBytes::V3(ncx[..COMPACT_NOTE_SIZE_V3].try_into().unwrap())
+                }
+            };
+        CompactAction {
+            nullifier: *action.nullifier(),
+            cmx: *action.cmx(),
+            ephemeral_key: action.ephemeral_key(),
+            enc_ciphertext: comp_ciphertext,
+        }
+    }
+}
+
+impl ShieldedOutput<OrchardDomain> for CompactAction {
+    fn ephemeral_key(&self) -> EphemeralKeyBytes {
+        EphemeralKeyBytes(self.ephemeral_key.0)
+    }
+
+    fn cmstar_bytes(&self) -> [u8; 32] {
+        self.cmx.to_bytes()
+    }
+
+    fn enc_ciphertext(&self) -> Option<NoteCiphertextBytes> {
+        None
+    }
+
+    fn enc_ciphertext_compact(&self) -> CompactNoteCiphertextBytes {
+        &self.enc_ciphertext
+    }
+}
+
+impl CompactAction {
+    /// Create a CompactAction from its constituent parts
+    pub fn from_parts(
+        nullifier: Nullifier,
+        cmx: ExtractedNoteCommitment,
+        ephemeral_key: EphemeralKeyBytes,
+        enc_ciphertext: CompactNoteCiphertextBytes,
+    ) -> Self {
+        Self {
+            nullifier,
+            cmx,
+            ephemeral_key,
+            enc_ciphertext,
+        }
+    }
+
+    ///Returns the nullifier of the note being spent.
+    pub fn nullifier(&self) -> Nullifier {
+        self.nullifier
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use proptest::prelude::*;
+    use rand::rngs::OsRng;
+    use zcash_note_encryption::{
+        try_compact_note_decryption, try_note_decryption, try_output_recovery_with_ovk, Domain,
+        EphemeralKeyBytes,
+    };
+
+    use super::{prf_ock_orchard, CompactAction, OrchardDomain, OrchardNoteEncryption};
+    use crate::note::AssetId;
+    use crate::note_encryption::NoteCiphertextBytes;
+    use crate::{
+        action::Action,
+        keys::{
+            DiversifiedTransmissionKey, Diversifier, EphemeralSecretKey, IncomingViewingKey,
+            OutgoingViewingKey,
+        },
+        note::{
+            testing::arb_note, ExtractedNoteCommitment, Nullifier, RandomSeed,
+            TransmittedNoteCiphertext,
+        },
+        primitives::redpallas,
+        value::{NoteValue, ValueCommitment},
+        Address, Note,
+    };
+
+    use super::{version, orchard_parse_note_plaintext_without_memo};
+
+    proptest! {
+        #[test]
+        fn test_encoding_roundtrip(
+            note in arb_note(NoteValue::from_raw(100)),
+        ) {
+            let memo = &crate::test_vectors::note_encryption::test_vectors()[0].memo;
+
+            // Encode.
+            let mut plaintext = OrchardDomain::note_plaintext_bytes(&note, &note.recipient(), memo);
+
+            // Decode.
+            let domain = OrchardDomain { rho: note.rho() };
+            let parsed_version = version(plaintext.as_mut()).unwrap();
+            let (mut compact,parsed_memo) = domain.extract_memo(&plaintext);
+
+            let (parsed_note, parsed_recipient) = orchard_parse_note_plaintext_without_memo(&domain, &compact.as_mut(),
+                |diversifier| {
+                    assert_eq!(diversifier, &note.recipient().diversifier());
+                    Some(*note.recipient().pk_d())
+                }
+            ).expect("Plaintext parsing failed");
+
+            // Check.
+            assert_eq!(parsed_note, note);
+            assert_eq!(parsed_recipient, note.recipient());
+            assert_eq!(&parsed_memo, memo);
+            assert_eq!(parsed_version, 0x03);
+        }
+    }
+
+    #[test]
+    fn test_vectors() {
+        let test_vectors = crate::test_vectors::note_encryption::test_vectors();
+
+        for tv in test_vectors {
+            //
+            // Load the test vector components
+            //
+
+            // Recipient key material
+            let ivk = IncomingViewingKey::from_bytes(&tv.incoming_viewing_key).unwrap();
+            let ovk = OutgoingViewingKey::from(tv.ovk);
+            let d = Diversifier::from_bytes(tv.default_d);
+            let pk_d = DiversifiedTransmissionKey::from_bytes(&tv.default_pk_d).unwrap();
+
+            // Received Action
+            let cv_net = ValueCommitment::from_bytes(&tv.cv_net).unwrap();
+            let rho = Nullifier::from_bytes(&tv.rho).unwrap();
+            let cmx = ExtractedNoteCommitment::from_bytes(&tv.cmx).unwrap();
+
+            let esk = EphemeralSecretKey::from_bytes(&tv.esk).unwrap();
+            let ephemeral_key = EphemeralKeyBytes(tv.ephemeral_key);
+
+            // Details about the expected note
+            let value = NoteValue::from_raw(tv.v);
+            let rseed = RandomSeed::from_bytes(tv.rseed, &rho).unwrap();
+
+            //
+            // Test the individual components
+            //
+
+            let shared_secret = esk.agree(&pk_d);
+            assert_eq!(shared_secret.to_bytes(), tv.shared_secret);
+
+            let k_enc = shared_secret.kdf_orchard(&ephemeral_key);
+            assert_eq!(k_enc.as_bytes(), tv.k_enc);
+
+            let ock = prf_ock_orchard(&ovk, &cv_net, &cmx.to_bytes(), &ephemeral_key);
+            assert_eq!(ock.as_ref(), tv.ock);
+
+            let recipient = Address::from_parts(d, pk_d);
+
+            let asset = match tv.asset {
+                None => AssetId::native(),
+                Some(type_bytes) => AssetId::from_bytes(&type_bytes).unwrap(),
+            };
+
+            let note = Note::from_parts(recipient, value, asset, rho, rseed).unwrap();
+            assert_eq!(ExtractedNoteCommitment::from(note.commitment()), cmx);
+
+            let action = Action::from_parts(
+                // rho is the nullifier in the receiving Action.
+                rho,
+                // We don't need a valid rk for this test.
+                redpallas::VerificationKey::dummy(),
+                cmx,
+                TransmittedNoteCiphertext {
+                    epk_bytes: ephemeral_key.0,
+                    enc_ciphertext: NoteCiphertextBytes::V3(tv.c_enc), // TODO: VA: Would need a mix of V2 and V3 eventually
+                    out_ciphertext: tv.c_out,
+                },
+                cv_net.clone(),
+                (),
+            );
+
+            //
+            // Test decryption
+            // (Tested first because it only requires immutable references.)
+            //
+
+            let domain = OrchardDomain { rho };
+
+            match try_note_decryption(&domain, &ivk, &action) {
+                Some((decrypted_note, decrypted_to, decrypted_memo)) => {
+                    assert_eq!(decrypted_note, note);
+                    assert_eq!(decrypted_to, recipient);
+                    assert_eq!(&decrypted_memo[..], &tv.memo[..]);
+                }
+                None => panic!("Note decryption failed"),
+            }
+
+            match try_compact_note_decryption(&domain, &ivk, &CompactAction::from(&action)) {
+                Some((decrypted_note, decrypted_to)) => {
+                    assert_eq!(decrypted_note, note);
+                    assert_eq!(decrypted_to, recipient);
+                }
+                None => panic!("Compact note decryption failed"),
+            }
+
+            match try_output_recovery_with_ovk(&domain, &ovk, &action, &cv_net, &tv.c_out) {
+                Some((decrypted_note, decrypted_to, decrypted_memo)) => {
+                    assert_eq!(decrypted_note, note);
+                    assert_eq!(decrypted_to, recipient);
+                    assert_eq!(&decrypted_memo[..], &tv.memo[..]);
+                }
+                None => panic!("Output recovery failed"),
+            }
+
+            //
+            // Test encryption
+            //
+
+            let ne = OrchardNoteEncryption::new_with_esk(esk, Some(ovk), note, recipient, tv.memo);
+
+            // assert_eq!(ne.encrypt_note_plaintext().as_ref(), &tv.c_enc[..]);
+            assert_eq!(
+                &ne.encrypt_outgoing_plaintext(&cv_net, &cmx, &mut OsRng)[..],
+                &tv.c_out[..]
+            );
+        }
+    }
+}
diff --git a/src/note_encryption_v3.rs b/src/note_encryption_v3.rs
new file mode 100644
index 000000000..c8a772ffe
--- /dev/null
+++ b/src/note_encryption_v3.rs
@@ -0,0 +1,634 @@
+//! In-band secret distribution for Orchard bundles.
+
+use blake2b_simd::{Hash, Params};
+use core::fmt;
+use group::ff::PrimeField;
+use zcash_note_encryption::{
+    BatchDomain, Domain, EphemeralKeyBytes, OutPlaintextBytes, OutgoingCipherKey, ShieldedOutput,
+    AEAD_TAG_SIZE, MEMO_SIZE, OUT_PLAINTEXT_SIZE,
+};
+
+use crate::note::AssetId;
+use crate::{
+    action::Action,
+    keys::{
+        DiversifiedTransmissionKey, Diversifier, EphemeralPublicKey, EphemeralSecretKey,
+        OutgoingViewingKey, PreparedEphemeralPublicKey, PreparedIncomingViewingKey, SharedSecret,
+    },
+    note::{ExtractedNoteCommitment, Nullifier, RandomSeed},
+    spec::diversify_hash,
+    value::{NoteValue, ValueCommitment},
+    Address, Note,
+};
+
+const PRF_OCK_ORCHARD_PERSONALIZATION: &[u8; 16] = b"Zcash_Orchardock";
+
+/// The size of a v2 compact note.
+pub const COMPACT_NOTE_SIZE_V2: usize = 1 + // version
+    11 + // diversifier
+    8  + // value
+    32; // rseed (or rcm prior to ZIP 212)
+/// The size of [`NotePlaintextBytes`] for V2.
+
+/// The size of the encoding of a ZSA asset id.
+const ZSA_ASSET_SIZE: usize = 32;
+/// The size of a v3 compact note.
+pub const COMPACT_NOTE_SIZE_V3: usize = COMPACT_NOTE_SIZE_V2 + ZSA_ASSET_SIZE;
+/// The size of [`NotePlaintextBytes`] for V3.
+pub const NOTE_PLAINTEXT_SIZE_V3: usize = COMPACT_NOTE_SIZE_V3 + MEMO_SIZE;
+/// The size of the encrypted ciphertext of the ZSA variant of a note.
+pub const ENC_CIPHERTEXT_SIZE_V3: usize = NOTE_PLAINTEXT_SIZE_V3 + AEAD_TAG_SIZE;
+
+/// a type to represent the raw bytes of a note plaintext.
+#[derive(Clone, Debug)]
+pub struct NotePlaintextBytes(pub [u8; NOTE_PLAINTEXT_SIZE_V3]);
+
+/// a type to represent the raw bytes of an encrypted note plaintext.
+#[derive(Clone, Debug)]
+pub struct NoteCiphertextBytes(pub [u8; ENC_CIPHERTEXT_SIZE_V3]);
+
+/// a type to represent the raw bytes of a compact note.
+#[derive(Clone, Debug)]
+pub struct CompactNotePlaintextBytes(pub [u8; COMPACT_NOTE_SIZE_V3]);
+
+/// a type to represent the raw bytes of an encrypted compact note.
+#[derive(Clone, Debug)]
+pub struct CompactNoteCiphertextBytes(pub [u8; COMPACT_NOTE_SIZE_V3]);
+
+impl AsMut<[u8]> for NotePlaintextBytes {
+    fn as_mut(&mut self) -> &mut [u8] {
+        self.0.as_mut()
+    }
+}
+
+impl From<&[u8]> for NotePlaintextBytes {
+    fn from(s: &[u8]) -> Self
+    where
+        Self: Sized,
+    {
+        NotePlaintextBytes(s.try_into().unwrap())
+    }
+}
+
+impl AsRef<[u8]> for NoteCiphertextBytes {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+impl From<&[u8]> for NoteCiphertextBytes {
+    fn from(s: &[u8]) -> Self
+    where
+        Self: Sized,
+    {
+        NoteCiphertextBytes(s.try_into().unwrap())
+    }
+}
+
+impl AsMut<[u8]> for CompactNotePlaintextBytes {
+    fn as_mut(&mut self) -> &mut [u8] {
+        self.0.as_mut()
+    }
+}
+
+impl From<&[u8]> for CompactNotePlaintextBytes {
+    fn from(s: &[u8]) -> Self
+    where
+        Self: Sized,
+    {
+        CompactNotePlaintextBytes(s.try_into().unwrap())
+    }
+}
+
+impl AsRef<[u8]> for CompactNoteCiphertextBytes {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+/// Defined in [Zcash Protocol Spec § 5.4.2: Pseudo Random Functions][concreteprfs].
+///
+/// [concreteprfs]: https://zips.z.cash/protocol/nu5.pdf#concreteprfs
+pub(crate) fn prf_ock_orchard(
+    ovk: &OutgoingViewingKey,
+    cv: &ValueCommitment,
+    cmx_bytes: &[u8; 32],
+    ephemeral_key: &EphemeralKeyBytes,
+) -> OutgoingCipherKey {
+    OutgoingCipherKey(
+        Params::new()
+            .hash_length(32)
+            .personal(PRF_OCK_ORCHARD_PERSONALIZATION)
+            .to_state()
+            .update(ovk.as_ref())
+            .update(&cv.to_bytes())
+            .update(cmx_bytes)
+            .update(ephemeral_key.as_ref())
+            .finalize()
+            .as_bytes()
+            .try_into()
+            .unwrap(),
+    )
+}
+
+/// note_version will return the version of the note plaintext.
+pub fn note_version(plaintext: &[u8]) -> Option<u8> {
+    match plaintext[0] {
+        0x02 => Some(0x02),
+        0x03 => Some(0x03),
+        _ => None,
+    }
+}
+
+/// Domain-specific requirements:
+/// - If the note version is 3, the `plaintext` must contain a valid encoding of a ZSA asset type.
+fn orchard_parse_note_plaintext_without_memo<F>(
+    domain: &OrchardDomainV3,
+    plaintext: &CompactNotePlaintextBytes,
+    get_validated_pk_d: F,
+) -> Option<(Note, Address)>
+where
+    F: FnOnce(&Diversifier) -> Option<DiversifiedTransmissionKey>,
+{
+    // The unwraps below are guaranteed to succeed by the assertion above
+    let diversifier = Diversifier::from_bytes(plaintext.0[1..12].try_into().unwrap());
+    let value = NoteValue::from_bytes(plaintext.0[12..20].try_into().unwrap());
+    let rseed = Option::from(RandomSeed::from_bytes(
+        plaintext.0[20..COMPACT_NOTE_SIZE_V2].try_into().unwrap(),
+        &domain.rho,
+    ))?;
+    let pk_d = get_validated_pk_d(&diversifier)?;
+    let recipient = Address::from_parts(diversifier, pk_d);
+
+    let asset = match note_version(plaintext.0.as_ref())? {
+        0x02 => AssetId::native(),
+        0x03 => {
+            let bytes = plaintext.0[COMPACT_NOTE_SIZE_V2..COMPACT_NOTE_SIZE_V3]
+                .try_into()
+                .unwrap();
+            AssetId::from_bytes(bytes).unwrap()
+        }
+        _ => panic!("invalid note version"),
+    };
+
+    let note = Option::from(Note::from_parts(recipient, value, asset, domain.rho, rseed))?;
+    Some((note, recipient))
+}
+
+/// Orchard-specific note encryption logic.
+#[derive(Debug)]
+pub struct OrchardDomainV3 {
+    rho: Nullifier,
+}
+
+impl OrchardDomainV3 {
+    /// Constructs a domain that can be used to trial-decrypt this action's output note.
+    pub fn for_action<T>(act: &Action<T>) -> Self {
+        OrchardDomainV3 {
+            rho: *act.nullifier(),
+        }
+    }
+
+    /// Constructs a domain from a nullifier.
+    pub fn for_nullifier(nullifier: Nullifier) -> Self {
+        OrchardDomainV3 { rho: nullifier }
+    }
+}
+
+impl Domain for OrchardDomainV3 {
+    type EphemeralSecretKey = EphemeralSecretKey;
+    type EphemeralPublicKey = EphemeralPublicKey;
+    type PreparedEphemeralPublicKey = PreparedEphemeralPublicKey;
+    type SharedSecret = SharedSecret;
+    type SymmetricKey = Hash;
+    type Note = Note;
+    type Recipient = Address;
+    type DiversifiedTransmissionKey = DiversifiedTransmissionKey;
+    type IncomingViewingKey = PreparedIncomingViewingKey;
+    type OutgoingViewingKey = OutgoingViewingKey;
+    type ValueCommitment = ValueCommitment;
+    type ExtractedCommitment = ExtractedNoteCommitment;
+    type ExtractedCommitmentBytes = [u8; 32];
+    type Memo = [u8; MEMO_SIZE];
+
+    type NotePlaintextBytes = NotePlaintextBytes;
+    type NoteCiphertextBytes = NoteCiphertextBytes;
+    type CompactNotePlaintextBytes = CompactNotePlaintextBytes;
+    type CompactNoteCiphertextBytes = CompactNoteCiphertextBytes;
+
+    fn derive_esk(note: &Self::Note) -> Option<Self::EphemeralSecretKey> {
+        Some(note.esk())
+    }
+
+    fn get_pk_d(note: &Self::Note) -> Self::DiversifiedTransmissionKey {
+        *note.recipient().pk_d()
+    }
+
+    fn prepare_epk(epk: Self::EphemeralPublicKey) -> Self::PreparedEphemeralPublicKey {
+        PreparedEphemeralPublicKey::new(epk)
+    }
+
+    fn ka_derive_public(
+        note: &Self::Note,
+        esk: &Self::EphemeralSecretKey,
+    ) -> Self::EphemeralPublicKey {
+        esk.derive_public(note.recipient().g_d())
+    }
+
+    fn ka_agree_enc(
+        esk: &Self::EphemeralSecretKey,
+        pk_d: &Self::DiversifiedTransmissionKey,
+    ) -> Self::SharedSecret {
+        esk.agree(pk_d)
+    }
+
+    fn ka_agree_dec(
+        ivk: &Self::IncomingViewingKey,
+        epk: &Self::PreparedEphemeralPublicKey,
+    ) -> Self::SharedSecret {
+        epk.agree(ivk)
+    }
+
+    fn kdf(secret: Self::SharedSecret, ephemeral_key: &EphemeralKeyBytes) -> Self::SymmetricKey {
+        secret.kdf_orchard(ephemeral_key)
+    }
+
+    fn note_plaintext_bytes(
+        note: &Self::Note,
+        _: &Self::Recipient,
+        memo: &Self::Memo,
+    ) -> NotePlaintextBytes {
+        let mut np = [0u8; NOTE_PLAINTEXT_SIZE_V3];
+        np[0] = 0x03;
+        np[1..12].copy_from_slice(note.recipient().diversifier().as_array());
+        np[12..20].copy_from_slice(&note.value().to_bytes());
+        np[20..52].copy_from_slice(note.rseed().as_bytes());
+        np[52..84].copy_from_slice(&note.asset().to_bytes());
+        np[84..].copy_from_slice(memo);
+        NotePlaintextBytes(np)
+    }
+
+    fn derive_ock(
+        ovk: &Self::OutgoingViewingKey,
+        cv: &Self::ValueCommitment,
+        cmstar_bytes: &Self::ExtractedCommitmentBytes,
+        ephemeral_key: &EphemeralKeyBytes,
+    ) -> OutgoingCipherKey {
+        prf_ock_orchard(ovk, cv, cmstar_bytes, ephemeral_key)
+    }
+
+    fn outgoing_plaintext_bytes(
+        note: &Self::Note,
+        esk: &Self::EphemeralSecretKey,
+    ) -> OutPlaintextBytes {
+        let mut op = [0; OUT_PLAINTEXT_SIZE];
+        op[..32].copy_from_slice(&note.recipient().pk_d().to_bytes());
+        op[32..].copy_from_slice(&esk.0.to_repr());
+        OutPlaintextBytes(op)
+    }
+
+    fn epk_bytes(epk: &Self::EphemeralPublicKey) -> EphemeralKeyBytes {
+        epk.to_bytes()
+    }
+
+    fn epk(ephemeral_key: &EphemeralKeyBytes) -> Option<Self::EphemeralPublicKey> {
+        EphemeralPublicKey::from_bytes(&ephemeral_key.0).into()
+    }
+
+    fn cmstar(note: &Self::Note) -> Self::ExtractedCommitment {
+        note.commitment().into()
+    }
+
+    fn parse_note_plaintext_without_memo_ivk(
+        &self,
+        ivk: &Self::IncomingViewingKey,
+        plaintext: &CompactNotePlaintextBytes,
+    ) -> Option<(Self::Note, Self::Recipient)> {
+        orchard_parse_note_plaintext_without_memo(self, plaintext, |diversifier| {
+            Some(DiversifiedTransmissionKey::derive(ivk, diversifier))
+        })
+    }
+
+    fn parse_note_plaintext_without_memo_ovk(
+        &self,
+        pk_d: &Self::DiversifiedTransmissionKey,
+        esk: &Self::EphemeralSecretKey,
+        ephemeral_key: &EphemeralKeyBytes,
+        plaintext: &CompactNotePlaintextBytes,
+    ) -> Option<(Self::Note, Self::Recipient)> {
+        orchard_parse_note_plaintext_without_memo(self, plaintext, |diversifier| {
+            if esk
+                .derive_public(diversify_hash(diversifier.as_array()))
+                .to_bytes()
+                .0
+                == ephemeral_key.0
+            {
+                Some(*pk_d)
+            } else {
+                None
+            }
+        })
+    }
+
+    fn extract_memo(
+        &self,
+        plaintext: &NotePlaintextBytes,
+    ) -> (Self::CompactNotePlaintextBytes, Self::Memo) {
+        let (compact, memo) = plaintext.0.split_at(COMPACT_NOTE_SIZE_V3);
+        (
+            CompactNotePlaintextBytes(compact.try_into().unwrap()),
+            memo.try_into().unwrap(),
+        )
+    }
+
+    fn extract_pk_d(out_plaintext: &OutPlaintextBytes) -> Option<Self::DiversifiedTransmissionKey> {
+        DiversifiedTransmissionKey::from_bytes(out_plaintext.0[0..32].try_into().unwrap()).into()
+    }
+
+    fn extract_esk(out_plaintext: &OutPlaintextBytes) -> Option<Self::EphemeralSecretKey> {
+        EphemeralSecretKey::from_bytes(out_plaintext.0[32..OUT_PLAINTEXT_SIZE].try_into().unwrap())
+            .into()
+    }
+}
+
+impl BatchDomain for OrchardDomainV3 {
+    fn batch_kdf<'a>(
+        items: impl Iterator<Item = (Option<Self::SharedSecret>, &'a EphemeralKeyBytes)>,
+    ) -> Vec<Option<Self::SymmetricKey>> {
+        let (shared_secrets, ephemeral_keys): (Vec<_>, Vec<_>) = items.unzip();
+
+        SharedSecret::batch_to_affine(shared_secrets)
+            .zip(ephemeral_keys.into_iter())
+            .map(|(secret, ephemeral_key)| {
+                secret.map(|dhsecret| SharedSecret::kdf_orchard_inner(dhsecret, ephemeral_key))
+            })
+            .collect()
+    }
+}
+
+/// Implementation of in-band secret distribution for Orchard bundles.
+pub type OrchardNoteEncryption = zcash_note_encryption::NoteEncryption<OrchardDomainV3>;
+
+impl<T> ShieldedOutput<OrchardDomainV3> for Action<T> {
+    fn ephemeral_key(&self) -> EphemeralKeyBytes {
+        EphemeralKeyBytes(self.encrypted_note().epk_bytes)
+    }
+
+    fn cmstar_bytes(&self) -> [u8; 32] {
+        self.cmx().to_bytes()
+    }
+
+    fn enc_ciphertext(&self) -> Option<NoteCiphertextBytes> {
+        Some(NoteCiphertextBytes(self.encrypted_note().enc_ciphertext))
+    }
+
+    fn enc_ciphertext_compact(&self) -> CompactNoteCiphertextBytes {
+        CompactNoteCiphertextBytes(
+            self.encrypted_note().enc_ciphertext[..COMPACT_NOTE_SIZE_V3]
+                .try_into()
+                .unwrap(),
+        )
+    }
+}
+
+/// A compact Action for light clients.
+pub struct CompactAction {
+    nullifier: Nullifier,
+    cmx: ExtractedNoteCommitment,
+    ephemeral_key: EphemeralKeyBytes,
+    enc_ciphertext: CompactNoteCiphertextBytes,
+}
+
+impl fmt::Debug for CompactAction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "CompactAction")
+    }
+}
+
+impl<T> From<&Action<T>> for CompactAction
+where
+    Action<T>: ShieldedOutput<OrchardDomainV3>,
+{
+    fn from(action: &Action<T>) -> Self {
+        CompactAction {
+            nullifier: *action.nullifier(),
+            cmx: *action.cmx(),
+            ephemeral_key: action.ephemeral_key(),
+            enc_ciphertext: CompactNoteCiphertextBytes(
+                action.encrypted_note().enc_ciphertext[..COMPACT_NOTE_SIZE_V3]
+                    .try_into()
+                    .unwrap(),
+            ),
+        }
+    }
+}
+
+impl ShieldedOutput<OrchardDomainV3> for CompactAction {
+    fn ephemeral_key(&self) -> EphemeralKeyBytes {
+        EphemeralKeyBytes(self.ephemeral_key.0)
+    }
+
+    fn cmstar_bytes(&self) -> [u8; 32] {
+        self.cmx.to_bytes()
+    }
+
+    fn enc_ciphertext(&self) -> Option<NoteCiphertextBytes> {
+        None
+    }
+
+    fn enc_ciphertext_compact(&self) -> CompactNoteCiphertextBytes {
+        self.enc_ciphertext.clone()
+    }
+}
+
+impl CompactAction {
+    /// Create a CompactAction from its constituent parts
+    pub fn from_parts(
+        nullifier: Nullifier,
+        cmx: ExtractedNoteCommitment,
+        ephemeral_key: EphemeralKeyBytes,
+        enc_ciphertext: CompactNoteCiphertextBytes,
+    ) -> Self {
+        Self {
+            nullifier,
+            cmx,
+            ephemeral_key,
+            enc_ciphertext,
+        }
+    }
+
+    ///Returns the nullifier of the note being spent.
+    pub fn nullifier(&self) -> Nullifier {
+        self.nullifier
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use proptest::prelude::*;
+    use rand::rngs::OsRng;
+    use zcash_note_encryption::{
+        try_compact_note_decryption, try_note_decryption, try_output_recovery_with_ovk, Domain,
+        EphemeralKeyBytes,
+    };
+
+    use super::{
+        note_version, orchard_parse_note_plaintext_without_memo, prf_ock_orchard, CompactAction,
+        OrchardDomainV3, OrchardNoteEncryption,
+    };
+    use crate::{
+        action::Action,
+        keys::{
+            DiversifiedTransmissionKey, Diversifier, EphemeralSecretKey, IncomingViewingKey,
+            OutgoingViewingKey, PreparedIncomingViewingKey,
+        },
+        note::{
+            testing::arb_note, AssetId, ExtractedNoteCommitment, Nullifier, RandomSeed,
+            TransmittedNoteCiphertext,
+        },
+        primitives::redpallas,
+        value::{NoteValue, ValueCommitment},
+        Address, Note,
+    };
+
+    proptest! {
+        #[test]
+        fn test_encoding_roundtrip(
+            note in arb_note(NoteValue::from_raw(100)),
+        ) {
+            let memo = &crate::test_vectors::note_encryption::test_vectors()[0].memo;
+
+            // Encode.
+            let mut plaintext = OrchardDomainV3::note_plaintext_bytes(&note, &note.recipient(), memo);
+
+            // Decode.
+            let domain = OrchardDomainV3 { rho: note.rho() };
+            let parsed_version = note_version(plaintext.as_mut()).unwrap();
+            let (compact,parsed_memo) = domain.extract_memo(&plaintext);
+
+            let (parsed_note, parsed_recipient) = orchard_parse_note_plaintext_without_memo(&domain, &compact,
+                |diversifier| {
+                    assert_eq!(diversifier, &note.recipient().diversifier());
+                    Some(*note.recipient().pk_d())
+                }
+            ).expect("Plaintext parsing failed");
+
+            // Check.
+            assert_eq!(parsed_note, note);
+            assert_eq!(parsed_recipient, note.recipient());
+            assert_eq!(&parsed_memo, memo);
+            assert_eq!(parsed_version, 0x03);
+        }
+    }
+
+    #[test]
+    fn test_vectors() {
+        let test_vectors = crate::test_vectors::note_encryption_v3::test_vectors();
+
+        for tv in test_vectors {
+            //
+            // Load the test vector components
+            //
+
+            // Recipient key material
+            let ivk = PreparedIncomingViewingKey::new(
+                &IncomingViewingKey::from_bytes(&tv.incoming_viewing_key).unwrap(),
+            );
+            let ovk = OutgoingViewingKey::from(tv.ovk);
+            let d = Diversifier::from_bytes(tv.default_d);
+            let pk_d = DiversifiedTransmissionKey::from_bytes(&tv.default_pk_d).unwrap();
+
+            // Received Action
+            let cv_net = ValueCommitment::from_bytes(&tv.cv_net).unwrap();
+            let rho = Nullifier::from_bytes(&tv.rho).unwrap();
+            let cmx = ExtractedNoteCommitment::from_bytes(&tv.cmx).unwrap();
+
+            let esk = EphemeralSecretKey::from_bytes(&tv.esk).unwrap();
+            let ephemeral_key = EphemeralKeyBytes(tv.ephemeral_key);
+
+            // Details about the expected note
+            let value = NoteValue::from_raw(tv.v);
+            let rseed = RandomSeed::from_bytes(tv.rseed, &rho).unwrap();
+
+            //
+            // Test the individual components
+            //
+
+            let shared_secret = esk.agree(&pk_d);
+            assert_eq!(shared_secret.to_bytes(), tv.shared_secret);
+
+            let k_enc = shared_secret.kdf_orchard(&ephemeral_key);
+            assert_eq!(k_enc.as_bytes(), tv.k_enc);
+
+            let ock = prf_ock_orchard(&ovk, &cv_net, &cmx.to_bytes(), &ephemeral_key);
+            assert_eq!(ock.as_ref(), tv.ock);
+
+            let recipient = Address::from_parts(d, pk_d);
+
+            let asset = AssetId::from_bytes(&tv.asset).unwrap();
+
+            let note = Note::from_parts(recipient, value, asset, rho, rseed).unwrap();
+            assert_eq!(ExtractedNoteCommitment::from(note.commitment()), cmx);
+
+            let action = Action::from_parts(
+                // rho is the nullifier in the receiving Action.
+                rho,
+                // We don't need a valid rk for this test.
+                redpallas::VerificationKey::dummy(),
+                cmx,
+                TransmittedNoteCiphertext {
+                    epk_bytes: ephemeral_key.0,
+                    enc_ciphertext: tv.c_enc,
+                    out_ciphertext: tv.c_out,
+                },
+                cv_net.clone(),
+                (),
+            );
+
+            //
+            // Test decryption
+            // (Tested first because it only requires immutable references.)
+            //
+
+            let domain = OrchardDomainV3 { rho };
+
+            match try_note_decryption(&domain, &ivk, &action) {
+                Some((decrypted_note, decrypted_to, decrypted_memo)) => {
+                    assert_eq!(decrypted_note, note);
+                    assert_eq!(decrypted_to, recipient);
+                    assert_eq!(&decrypted_memo[..], &tv.memo[..]);
+                }
+                None => panic!("Note decryption failed"),
+            }
+
+            match try_compact_note_decryption(&domain, &ivk, &CompactAction::from(&action)) {
+                Some((decrypted_note, decrypted_to)) => {
+                    assert_eq!(decrypted_note, note);
+                    assert_eq!(decrypted_to, recipient);
+                }
+                None => panic!("Compact note decryption failed"),
+            }
+
+            match try_output_recovery_with_ovk(&domain, &ovk, &action, &cv_net, &tv.c_out) {
+                Some((decrypted_note, decrypted_to, decrypted_memo)) => {
+                    assert_eq!(decrypted_note, note);
+                    assert_eq!(decrypted_to, recipient);
+                    assert_eq!(&decrypted_memo[..], &tv.memo[..]);
+                }
+                None => panic!("Output recovery failed"),
+            }
+
+            //
+            // Test encryption
+            //
+
+            let ne = OrchardNoteEncryption::new_with_esk(esk, Some(ovk), note, recipient, tv.memo);
+
+            assert_eq!(ne.encrypt_note_plaintext().as_ref(), &tv.c_enc[..]);
+            assert_eq!(
+                &ne.encrypt_outgoing_plaintext(&cv_net, &cmx, &mut OsRng)[..],
+                &tv.c_out[..]
+            );
+        }
+    }
+}
diff --git a/src/test_vectors.rs b/src/test_vectors.rs
index b70b56e56..945cfc2b7 100644
--- a/src/test_vectors.rs
+++ b/src/test_vectors.rs
@@ -3,3 +3,4 @@ pub(crate) mod commitment_tree;
 pub(crate) mod keys;
 pub(crate) mod merkle_path;
 pub(crate) mod note_encryption;
+pub(crate) mod note_encryption_v3;
diff --git a/src/test_vectors/note_encryption.rs b/src/test_vectors/note_encryption.rs
index f1c6126cc..7a5a73a56 100644
--- a/src/test_vectors/note_encryption.rs
+++ b/src/test_vectors/note_encryption.rs
@@ -1,6 +1,5 @@
-// From https://github.com/zcash-hackworks/zcash-test-vectors/ (orchard_note_encryption)
-
 pub(crate) struct TestVector {
+    // make all fields public so we can use them in the test
     pub(crate) incoming_viewing_key: [u8; 64],
     pub(crate) ovk: [u8; 32],
     pub(crate) default_d: [u8; 11],
@@ -20,9 +19,9 @@ pub(crate) struct TestVector {
     pub(crate) ock: [u8; 32],
     pub(crate) op: [u8; 64],
     pub(crate) c_out: [u8; 80],
-    pub(crate) asset: Option<[u8; 32]>,
 }
 
+// From https://github.com/zcash-hackworks/zcash-test-vectors/blob/master/orchard_note_encryption.py
 pub(crate) fn test_vectors() -> Vec<TestVector> {
     vec![
         TestVector {
@@ -233,7 +232,6 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x2d, 0xb5, 0x96, 0x9d, 0x8d, 0x2f, 0x32, 0x25, 0x91, 0x9c, 0xe3, 0x88, 0x26, 0x41,
                 0x5c, 0xc6, 0xb3, 0x38, 0x94, 0x4b, 0x48, 0x99, 0x54, 0x8b,
             ],
-            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -443,7 +441,6 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x4d, 0xde, 0x70, 0x49, 0x48, 0x72, 0xb2, 0x20, 0x8a, 0x7c, 0x58, 0x02, 0xdf, 0xe9,
                 0xbd, 0x1c, 0xa1, 0x9b, 0xef, 0x4b, 0x37, 0xc6, 0x13, 0xb2,
             ],
-            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -653,7 +650,6 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x0e, 0x01, 0x86, 0x45, 0x32, 0xa3, 0x57, 0x2c, 0x68, 0xaf, 0xe4, 0x0a, 0xc3, 0xc0,
                 0x95, 0x7b, 0x7a, 0xfc, 0x23, 0xfd, 0x5e, 0x05, 0x17, 0xaa,
             ],
-            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -863,7 +859,6 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xd1, 0x4c, 0xf8, 0xe8, 0xe2, 0x8e, 0xa2, 0x5c, 0x18, 0x62, 0x7a, 0x84, 0xa2, 0xbe,
                 0x96, 0x1f, 0x44, 0x72, 0x67, 0x67, 0xe9, 0xf8, 0x43, 0x1b,
             ],
-            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1073,7 +1068,6 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x2e, 0xe8, 0x86, 0x8b, 0x2d, 0xa0, 0x7d, 0xa2, 0x99, 0x2c, 0x6d, 0x9f, 0xb8, 0xbd,
                 0x59, 0x0b, 0x8d, 0xa0, 0x28, 0x11, 0xb5, 0x09, 0xe8, 0xc6,
             ],
-            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1283,7 +1277,6 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x87, 0x01, 0x0c, 0x8d, 0x13, 0x5c, 0x32, 0xd5, 0x6e, 0xe2, 0x84, 0x68, 0x65, 0xa2,
                 0x61, 0xde, 0x14, 0x25, 0xd2, 0x3b, 0xcc, 0x51, 0xb8, 0xa0,
             ],
-            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1493,7 +1486,6 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x5d, 0x1b, 0x04, 0x3e, 0xb1, 0x2a, 0x0e, 0xfa, 0xb5, 0x16, 0x09, 0x34, 0xbc, 0x75,
                 0x9e, 0x02, 0x01, 0xd8, 0x66, 0xad, 0xa7, 0x44, 0x35, 0x71,
             ],
-            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1703,7 +1695,6 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x61, 0x33, 0x92, 0x59, 0x28, 0x3e, 0x3a, 0x95, 0x3c, 0x57, 0xdf, 0x3a, 0x48, 0xca,
                 0x82, 0x71, 0xfc, 0x5f, 0x26, 0x4d, 0x6f, 0x15, 0xb6, 0xb3,
             ],
-            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -1913,7 +1904,6 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0x97, 0x4c, 0x26, 0xb5, 0x1b, 0x85, 0x9f, 0xab, 0xe0, 0x2e, 0xab, 0xae, 0x96, 0x8a,
                 0xab, 0x2e, 0x5e, 0x61, 0xef, 0xc2, 0xd4, 0x46, 0x2c, 0x1e,
             ],
-            asset: None,
         },
         TestVector {
             incoming_viewing_key: [
@@ -2123,2147 +2113,6 @@ pub(crate) fn test_vectors() -> Vec<TestVector> {
                 0xba, 0xfe, 0x80, 0x4d, 0x46, 0x6e, 0xd0, 0x79, 0x82, 0x7f, 0xc1, 0x41, 0x91, 0xeb,
                 0xb5, 0x99, 0x17, 0x87, 0x49, 0xe9, 0xc4, 0x06, 0xaf, 0x26,
             ],
-            asset: None,
-        },
-        TestVector {
-            incoming_viewing_key: [
-                0xdc, 0x10, 0x95, 0x20, 0x57, 0xc4, 0xbe, 0xaa, 0xd8, 0xaf, 0x37, 0xce, 0x4e, 0xee,
-                0x9b, 0x10, 0xed, 0x84, 0xf4, 0x6b, 0xad, 0xd4, 0x8e, 0x0a, 0x22, 0x9b, 0xe8, 0x41,
-                0x54, 0xa9, 0xbf, 0x75, 0x6b, 0xe0, 0x2e, 0xcf, 0xa9, 0xad, 0x6d, 0x9c, 0x02, 0xc8,
-                0xf9, 0x54, 0xcb, 0x15, 0x71, 0x7b, 0x79, 0x46, 0x1f, 0x00, 0x4b, 0xf1, 0xbc, 0x5c,
-                0x7e, 0x3f, 0xda, 0x73, 0x53, 0x7c, 0x1a, 0x0a,
-            ],
-            ovk: [
-                0x97, 0x74, 0x85, 0xcd, 0xdf, 0xbe, 0xd5, 0x93, 0x2f, 0x50, 0x7b, 0x79, 0x94, 0x7a,
-                0xdb, 0x2f, 0xad, 0x37, 0x61, 0x5a, 0xa7, 0x17, 0xdb, 0x5f, 0x29, 0x80, 0x99, 0xf2,
-                0x0f, 0x26, 0x3b, 0x35,
-            ],
-            default_d: [
-                0xf6, 0xb0, 0x18, 0xdf, 0xa7, 0x26, 0x31, 0x5b, 0x44, 0xcf, 0x9e,
-            ],
-            default_pk_d: [
-                0x05, 0x82, 0x53, 0xd4, 0x85, 0x76, 0x44, 0x88, 0x5e, 0x26, 0xa9, 0x09, 0xc8, 0x38,
-                0x59, 0x25, 0x23, 0x5a, 0x75, 0x29, 0x85, 0x44, 0x6e, 0x11, 0x69, 0x5f, 0x36, 0xc2,
-                0xe6, 0x84, 0x45, 0xbb,
-            ],
-            v: 2111628168871420429,
-            rseed: [
-                0xcc, 0x57, 0x9a, 0x7a, 0x8f, 0xff, 0x7c, 0xa7, 0xcf, 0x14, 0x5d, 0xfc, 0x13, 0xea,
-                0xfc, 0x34, 0x15, 0x3b, 0x2c, 0x3e, 0x8a, 0xfb, 0xe5, 0x34, 0x44, 0xd0, 0xc7, 0x3b,
-                0x3b, 0xd5, 0xbc, 0x87,
-            ],
-            memo: [
-                0xff, 0x0b, 0x01, 0xcd, 0x45, 0x79, 0x11, 0xe3, 0x56, 0x31, 0x3f, 0xd1, 0xda, 0xfb,
-                0x4c, 0x81, 0x51, 0x63, 0x4a, 0x01, 0xaf, 0xf7, 0xcf, 0x11, 0x6d, 0x43, 0x3c, 0x3d,
-                0x2b, 0x3a, 0xdd, 0xa9, 0xce, 0xbe, 0x18, 0xf7, 0xd1, 0x72, 0x44, 0x3e, 0x5e, 0x7b,
-                0x5a, 0xc9, 0xab, 0xe8, 0xdb, 0x22, 0x56, 0xd7, 0xeb, 0xe2, 0xff, 0x28, 0x02, 0x09,
-                0x39, 0x50, 0x38, 0x70, 0x59, 0x7b, 0x9a, 0x95, 0x58, 0x92, 0xc7, 0x38, 0x96, 0x50,
-                0xa2, 0xd4, 0x2e, 0xc9, 0x2b, 0xe7, 0x23, 0xfe, 0xdf, 0x2f, 0x2e, 0xde, 0x5a, 0x47,
-                0x2a, 0xa1, 0xe7, 0x4f, 0x33, 0xad, 0x41, 0x90, 0x15, 0x44, 0xed, 0xbb, 0xe3, 0xac,
-                0x46, 0x4c, 0xf4, 0x39, 0x19, 0x60, 0x15, 0xf4, 0xf2, 0x2a, 0xc2, 0xb8, 0xfc, 0x01,
-                0x49, 0x6b, 0xea, 0xb4, 0xd4, 0x59, 0x07, 0xf4, 0x79, 0x81, 0x2a, 0x25, 0x94, 0x31,
-                0xa2, 0xcb, 0xc9, 0x3d, 0x4f, 0x3b, 0x84, 0xe4, 0xdd, 0x36, 0x60, 0x20, 0x27, 0x3a,
-                0x67, 0x52, 0xe5, 0x01, 0xaf, 0x6f, 0xf1, 0xb7, 0x8d, 0xdc, 0x81, 0x7e, 0x6e, 0xa3,
-                0x51, 0xd6, 0x00, 0x6b, 0xec, 0xf8, 0xd2, 0xff, 0xb0, 0x39, 0x90, 0xf6, 0x77, 0x74,
-                0xa8, 0x1e, 0x05, 0xb7, 0xf4, 0xbb, 0xad, 0x85, 0x77, 0xfa, 0x27, 0xc9, 0xde, 0x64,
-                0xe1, 0xb1, 0x1d, 0xcf, 0x38, 0x4f, 0x59, 0x56, 0x44, 0x37, 0x48, 0x75, 0x5a, 0x9f,
-                0xc6, 0xf2, 0xa0, 0x0b, 0x10, 0xc3, 0x65, 0x7e, 0xba, 0xc0, 0x3b, 0xfc, 0x0b, 0x58,
-                0x7b, 0xef, 0x2f, 0x45, 0xec, 0x8a, 0xcd, 0xaa, 0x51, 0xc1, 0x43, 0xb0, 0xcb, 0x25,
-                0xb9, 0x14, 0x2c, 0x61, 0xbd, 0x79, 0x0a, 0x80, 0xd7, 0xc2, 0x3f, 0x90, 0xcc, 0x03,
-                0x49, 0x5b, 0x51, 0xe4, 0xd2, 0x84, 0x3e, 0x55, 0x7f, 0x9e, 0x25, 0x45, 0x10, 0x8c,
-                0x6c, 0x6f, 0xae, 0x35, 0x9f, 0x64, 0x5c, 0x27, 0x68, 0x91, 0xc0, 0xdc, 0xab, 0x3f,
-                0xaf, 0x18, 0x77, 0x00, 0xc0, 0x82, 0xdc, 0x47, 0x77, 0x40, 0xfb, 0x3f, 0x2c, 0xd7,
-                0xbb, 0x59, 0xfb, 0x35, 0x85, 0x54, 0xe9, 0x4c, 0x7e, 0x67, 0x8c, 0xe0, 0x1a, 0xeb,
-                0xf9, 0x4e, 0x51, 0x5e, 0x49, 0x72, 0x29, 0x67, 0x99, 0x5a, 0xea, 0x85, 0x8d, 0x64,
-                0xe7, 0x78, 0x9f, 0xf3, 0x06, 0x36, 0x95, 0x77, 0x22, 0x81, 0x80, 0x32, 0x6a, 0x5b,
-                0x0a, 0xf4, 0x75, 0xe2, 0x7a, 0x54, 0xb2, 0x07, 0xb4, 0x1f, 0x92, 0xe3, 0x76, 0x17,
-                0x0e, 0x3f, 0xb0, 0x05, 0x02, 0x82, 0x61, 0xc9, 0x9c, 0x2d, 0xbd, 0x0e, 0xed, 0xee,
-                0x87, 0x1c, 0x1c, 0x0f, 0x48, 0xb8, 0xe9, 0xb8, 0xe4, 0xbe, 0x77, 0xd1, 0xb7, 0x37,
-                0xfe, 0x21, 0xf0, 0xfa, 0x5a, 0x18, 0xeb, 0xb5, 0x27, 0x55, 0xb5, 0xa6, 0xcf, 0x61,
-                0x30, 0xfb, 0x56, 0x94, 0x4c, 0xfa, 0xb8, 0x75, 0x27, 0xc2, 0x50, 0xd1, 0x13, 0xb2,
-                0x9b, 0xca, 0xc9, 0xaa, 0xa1, 0x0c, 0x2e, 0x7d, 0xe4, 0x15, 0xed, 0xb0, 0x80, 0x6c,
-                0x6d, 0xa0, 0x30, 0x20, 0xa1, 0x34, 0xca, 0x7e, 0xcd, 0xc8, 0xda, 0x1b, 0xd5, 0x7a,
-                0x37, 0xf5, 0x5a, 0x46, 0x94, 0x0b, 0x45, 0xb2, 0x41, 0xb1, 0xc1, 0x6e, 0xe1, 0x00,
-                0x92, 0x7d, 0x1b, 0xd8, 0x60, 0xd4, 0x45, 0xa9, 0xde, 0x50, 0xd4, 0xc3, 0x84, 0xd6,
-                0xe1, 0xd0, 0x01, 0x08, 0x02, 0x6c, 0x0e, 0xa5, 0xeb, 0xbf, 0x0b, 0x72, 0xfb, 0xf5,
-                0xc3, 0x70, 0xbc, 0xe1, 0x8d, 0x3a, 0xcb, 0xc4, 0x65, 0x99, 0x09, 0x9b, 0xaa, 0xe1,
-                0xd8, 0x02, 0xf7, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ],
-            cv_net: [
-                0xba, 0x69, 0x9c, 0xe4, 0x21, 0x41, 0x85, 0x30, 0x94, 0xe2, 0x84, 0x00, 0x50, 0x17,
-                0x2c, 0x3b, 0x94, 0x21, 0x3e, 0x86, 0x47, 0x3b, 0x5e, 0x2f, 0xdd, 0x70, 0x97, 0x80,
-                0xbc, 0xca, 0x68, 0xb4,
-            ],
-            rho: [
-                0xf6, 0x5d, 0x22, 0x96, 0x09, 0x58, 0xd7, 0x28, 0x59, 0x60, 0x9c, 0x99, 0x46, 0xd8,
-                0xa9, 0x4a, 0x06, 0x04, 0xb8, 0x00, 0x6c, 0xc7, 0x94, 0xbc, 0xab, 0x57, 0x73, 0x49,
-                0xbc, 0xf8, 0x63, 0x37,
-            ],
-            cmx: [
-                0x85, 0xec, 0x16, 0xe8, 0x78, 0x77, 0x33, 0x37, 0x07, 0x9a, 0xec, 0xf3, 0x2c, 0x45,
-                0x5e, 0xbf, 0x16, 0x96, 0x8d, 0xa1, 0xd4, 0x34, 0x51, 0xb7, 0xa3, 0x06, 0x87, 0x6c,
-                0xa3, 0x08, 0xea, 0x3c,
-            ],
-            esk: [
-                0x05, 0x18, 0xdd, 0xc0, 0xc4, 0x7b, 0x7f, 0x77, 0xed, 0xcd, 0x39, 0x16, 0x0f, 0xe5,
-                0x67, 0x75, 0x1e, 0xb8, 0x4a, 0xa2, 0x1d, 0x33, 0xa6, 0x90, 0xe0, 0xd2, 0x9b, 0x35,
-                0x9a, 0xc4, 0xfa, 0x2c,
-            ],
-            ephemeral_key: [
-                0x10, 0x0d, 0xf0, 0x1d, 0x49, 0x86, 0x01, 0x21, 0x8a, 0x28, 0x6b, 0x8f, 0x4e, 0x54,
-                0xda, 0x9b, 0x3f, 0x14, 0x5c, 0x34, 0x70, 0xa9, 0xdb, 0xc4, 0x14, 0x48, 0x0a, 0xa8,
-                0xf2, 0xf4, 0x90, 0x9c,
-            ],
-            shared_secret: [
-                0x93, 0x68, 0xdd, 0x4f, 0x2a, 0xf6, 0x23, 0x34, 0xb8, 0x85, 0xb9, 0x6b, 0xc4, 0xc3,
-                0x8f, 0x10, 0x3a, 0xec, 0x25, 0x6b, 0xed, 0xc2, 0x8b, 0x5e, 0x2e, 0x10, 0x36, 0x4c,
-                0xdd, 0xf3, 0x84, 0xa4,
-            ],
-            k_enc: [
-                0x7a, 0xff, 0xfc, 0x6e, 0xae, 0x5d, 0x56, 0xb2, 0x7b, 0x86, 0xdb, 0x9e, 0xc8, 0xae,
-                0xc2, 0x70, 0xbb, 0x0a, 0xb7, 0x31, 0x23, 0xfd, 0x2a, 0x0b, 0x83, 0xf4, 0xef, 0x84,
-                0xc6, 0x98, 0xe1, 0x67,
-            ],
-            p_enc: [
-                0x03, 0xf6, 0xb0, 0x18, 0xdf, 0xa7, 0x26, 0x31, 0x5b, 0x44, 0xcf, 0x9e, 0x0d, 0x22,
-                0x4a, 0xb7, 0xa1, 0x02, 0x4e, 0x1d, 0xcc, 0x57, 0x9a, 0x7a, 0x8f, 0xff, 0x7c, 0xa7,
-                0xcf, 0x14, 0x5d, 0xfc, 0x13, 0xea, 0xfc, 0x34, 0x15, 0x3b, 0x2c, 0x3e, 0x8a, 0xfb,
-                0xe5, 0x34, 0x44, 0xd0, 0xc7, 0x3b, 0x3b, 0xd5, 0xbc, 0x87, 0xa9, 0x71, 0x5e, 0x65,
-                0xaf, 0x82, 0x67, 0x37, 0x3d, 0x34, 0x51, 0x67, 0x4f, 0xf0, 0x84, 0xef, 0xd9, 0x2c,
-                0xcf, 0x3b, 0xcc, 0x7a, 0xca, 0x14, 0x67, 0xb6, 0x32, 0x7e, 0x4f, 0x95, 0x22, 0xb2,
-                0xff, 0x0b, 0x01, 0xcd, 0x45, 0x79, 0x11, 0xe3, 0x56, 0x31, 0x3f, 0xd1, 0xda, 0xfb,
-                0x4c, 0x81, 0x51, 0x63, 0x4a, 0x01, 0xaf, 0xf7, 0xcf, 0x11, 0x6d, 0x43, 0x3c, 0x3d,
-                0x2b, 0x3a, 0xdd, 0xa9, 0xce, 0xbe, 0x18, 0xf7, 0xd1, 0x72, 0x44, 0x3e, 0x5e, 0x7b,
-                0x5a, 0xc9, 0xab, 0xe8, 0xdb, 0x22, 0x56, 0xd7, 0xeb, 0xe2, 0xff, 0x28, 0x02, 0x09,
-                0x39, 0x50, 0x38, 0x70, 0x59, 0x7b, 0x9a, 0x95, 0x58, 0x92, 0xc7, 0x38, 0x96, 0x50,
-                0xa2, 0xd4, 0x2e, 0xc9, 0x2b, 0xe7, 0x23, 0xfe, 0xdf, 0x2f, 0x2e, 0xde, 0x5a, 0x47,
-                0x2a, 0xa1, 0xe7, 0x4f, 0x33, 0xad, 0x41, 0x90, 0x15, 0x44, 0xed, 0xbb, 0xe3, 0xac,
-                0x46, 0x4c, 0xf4, 0x39, 0x19, 0x60, 0x15, 0xf4, 0xf2, 0x2a, 0xc2, 0xb8, 0xfc, 0x01,
-                0x49, 0x6b, 0xea, 0xb4, 0xd4, 0x59, 0x07, 0xf4, 0x79, 0x81, 0x2a, 0x25, 0x94, 0x31,
-                0xa2, 0xcb, 0xc9, 0x3d, 0x4f, 0x3b, 0x84, 0xe4, 0xdd, 0x36, 0x60, 0x20, 0x27, 0x3a,
-                0x67, 0x52, 0xe5, 0x01, 0xaf, 0x6f, 0xf1, 0xb7, 0x8d, 0xdc, 0x81, 0x7e, 0x6e, 0xa3,
-                0x51, 0xd6, 0x00, 0x6b, 0xec, 0xf8, 0xd2, 0xff, 0xb0, 0x39, 0x90, 0xf6, 0x77, 0x74,
-                0xa8, 0x1e, 0x05, 0xb7, 0xf4, 0xbb, 0xad, 0x85, 0x77, 0xfa, 0x27, 0xc9, 0xde, 0x64,
-                0xe1, 0xb1, 0x1d, 0xcf, 0x38, 0x4f, 0x59, 0x56, 0x44, 0x37, 0x48, 0x75, 0x5a, 0x9f,
-                0xc6, 0xf2, 0xa0, 0x0b, 0x10, 0xc3, 0x65, 0x7e, 0xba, 0xc0, 0x3b, 0xfc, 0x0b, 0x58,
-                0x7b, 0xef, 0x2f, 0x45, 0xec, 0x8a, 0xcd, 0xaa, 0x51, 0xc1, 0x43, 0xb0, 0xcb, 0x25,
-                0xb9, 0x14, 0x2c, 0x61, 0xbd, 0x79, 0x0a, 0x80, 0xd7, 0xc2, 0x3f, 0x90, 0xcc, 0x03,
-                0x49, 0x5b, 0x51, 0xe4, 0xd2, 0x84, 0x3e, 0x55, 0x7f, 0x9e, 0x25, 0x45, 0x10, 0x8c,
-                0x6c, 0x6f, 0xae, 0x35, 0x9f, 0x64, 0x5c, 0x27, 0x68, 0x91, 0xc0, 0xdc, 0xab, 0x3f,
-                0xaf, 0x18, 0x77, 0x00, 0xc0, 0x82, 0xdc, 0x47, 0x77, 0x40, 0xfb, 0x3f, 0x2c, 0xd7,
-                0xbb, 0x59, 0xfb, 0x35, 0x85, 0x54, 0xe9, 0x4c, 0x7e, 0x67, 0x8c, 0xe0, 0x1a, 0xeb,
-                0xf9, 0x4e, 0x51, 0x5e, 0x49, 0x72, 0x29, 0x67, 0x99, 0x5a, 0xea, 0x85, 0x8d, 0x64,
-                0xe7, 0x78, 0x9f, 0xf3, 0x06, 0x36, 0x95, 0x77, 0x22, 0x81, 0x80, 0x32, 0x6a, 0x5b,
-                0x0a, 0xf4, 0x75, 0xe2, 0x7a, 0x54, 0xb2, 0x07, 0xb4, 0x1f, 0x92, 0xe3, 0x76, 0x17,
-                0x0e, 0x3f, 0xb0, 0x05, 0x02, 0x82, 0x61, 0xc9, 0x9c, 0x2d, 0xbd, 0x0e, 0xed, 0xee,
-                0x87, 0x1c, 0x1c, 0x0f, 0x48, 0xb8, 0xe9, 0xb8, 0xe4, 0xbe, 0x77, 0xd1, 0xb7, 0x37,
-                0xfe, 0x21, 0xf0, 0xfa, 0x5a, 0x18, 0xeb, 0xb5, 0x27, 0x55, 0xb5, 0xa6, 0xcf, 0x61,
-                0x30, 0xfb, 0x56, 0x94, 0x4c, 0xfa, 0xb8, 0x75, 0x27, 0xc2, 0x50, 0xd1, 0x13, 0xb2,
-                0x9b, 0xca, 0xc9, 0xaa, 0xa1, 0x0c, 0x2e, 0x7d, 0xe4, 0x15, 0xed, 0xb0, 0x80, 0x6c,
-                0x6d, 0xa0, 0x30, 0x20, 0xa1, 0x34, 0xca, 0x7e, 0xcd, 0xc8, 0xda, 0x1b, 0xd5, 0x7a,
-                0x37, 0xf5, 0x5a, 0x46, 0x94, 0x0b, 0x45, 0xb2, 0x41, 0xb1, 0xc1, 0x6e, 0xe1, 0x00,
-                0x92, 0x7d, 0x1b, 0xd8, 0x60, 0xd4, 0x45, 0xa9, 0xde, 0x50, 0xd4, 0xc3, 0x84, 0xd6,
-                0xe1, 0xd0, 0x01, 0x08, 0x02, 0x6c, 0x0e, 0xa5, 0xeb, 0xbf, 0x0b, 0x72, 0xfb, 0xf5,
-                0xc3, 0x70, 0xbc, 0xe1, 0x8d, 0x3a, 0xcb, 0xc4, 0x65, 0x99, 0x09, 0x9b, 0xaa, 0xe1,
-                0xd8, 0x02, 0xf7, 0x73,
-            ],
-            c_enc: [
-                0x45, 0x6b, 0x2b, 0xb8, 0x03, 0xc7, 0xdf, 0xf7, 0xac, 0x82, 0xe6, 0x42, 0xf4, 0xd8,
-                0x46, 0x1e, 0x0b, 0x7a, 0x3b, 0x3c, 0x95, 0xa4, 0xcb, 0xf1, 0xc0, 0x6f, 0xeb, 0x93,
-                0xa1, 0x8b, 0xeb, 0xa2, 0x9f, 0x2b, 0x8f, 0x12, 0x1a, 0x61, 0x5c, 0xa5, 0x3f, 0xc2,
-                0xa7, 0x60, 0x63, 0xb8, 0x0d, 0xaa, 0x71, 0x01, 0x8b, 0x66, 0x3b, 0x7c, 0x46, 0x6d,
-                0xb2, 0x63, 0xf9, 0x04, 0x27, 0xd0, 0x11, 0x7f, 0x0b, 0x89, 0x90, 0x6e, 0x98, 0x41,
-                0x7f, 0x3e, 0xe8, 0x5a, 0xcc, 0xed, 0xb1, 0x41, 0xfb, 0x10, 0x26, 0xa3, 0xb3, 0xf7,
-                0xa4, 0xfd, 0x10, 0x24, 0xf9, 0xc8, 0x08, 0x9a, 0x2e, 0xbe, 0x1a, 0x27, 0x82, 0xf8,
-                0xb0, 0xbf, 0x5c, 0x40, 0xb6, 0xd5, 0x2f, 0xfe, 0x38, 0x37, 0xf4, 0xe4, 0x42, 0x52,
-                0x13, 0x41, 0xc2, 0x4d, 0x3e, 0x89, 0x55, 0x95, 0x08, 0x86, 0x27, 0x85, 0xea, 0x63,
-                0x56, 0xb4, 0xe4, 0x66, 0xc3, 0x25, 0x9c, 0xeb, 0x0d, 0x28, 0x2e, 0x07, 0xbb, 0x35,
-                0xdc, 0xf2, 0xd9, 0xa8, 0x62, 0xc7, 0x47, 0x58, 0xd3, 0x83, 0xaa, 0xa2, 0x82, 0xfa,
-                0xc4, 0xfa, 0xcf, 0xe5, 0x39, 0xe4, 0xe1, 0xbb, 0xd5, 0x46, 0x8a, 0xcf, 0x25, 0xec,
-                0x2b, 0x4b, 0xa5, 0x11, 0x9d, 0xea, 0xed, 0x01, 0x1d, 0x4f, 0x30, 0xb0, 0xc5, 0x82,
-                0x01, 0xfe, 0xe1, 0xc6, 0xe4, 0xf6, 0xb5, 0x2e, 0x41, 0xad, 0xfa, 0x5d, 0x6f, 0xda,
-                0x94, 0xa5, 0x23, 0x20, 0xe8, 0x3b, 0x80, 0xc6, 0xfc, 0xee, 0xb8, 0x97, 0x89, 0xd8,
-                0x79, 0x94, 0xb7, 0xa0, 0x16, 0xec, 0x64, 0xe4, 0x70, 0x78, 0x07, 0xf8, 0xf2, 0xd2,
-                0x30, 0x63, 0x10, 0x74, 0x10, 0x9f, 0xc5, 0x9d, 0xe3, 0xe4, 0x37, 0x10, 0xca, 0xe8,
-                0x9c, 0xb1, 0x89, 0xa0, 0xa4, 0x64, 0x8b, 0x37, 0x54, 0x5d, 0x25, 0x49, 0x47, 0x95,
-                0xa8, 0xdf, 0x3f, 0xfc, 0x7a, 0x3a, 0x21, 0xe3, 0xb9, 0x1c, 0x95, 0x96, 0xe0, 0xd5,
-                0x10, 0x5d, 0xf8, 0xad, 0xa9, 0xcf, 0xe9, 0x31, 0x10, 0xb1, 0x9f, 0xf2, 0xaf, 0x83,
-                0x03, 0xb5, 0xd2, 0x79, 0x3f, 0xff, 0xd0, 0x4d, 0x8e, 0x02, 0xf7, 0xb9, 0x30, 0x14,
-                0x80, 0xdf, 0xd9, 0x35, 0x50, 0x2d, 0x98, 0xe2, 0xf3, 0xc3, 0xe9, 0xe9, 0x5e, 0x64,
-                0xe4, 0x96, 0xeb, 0x7d, 0x15, 0xcf, 0x2c, 0x70, 0x11, 0x94, 0xe6, 0x25, 0xde, 0x52,
-                0x1a, 0x02, 0x55, 0x20, 0xdf, 0x67, 0xac, 0x2b, 0xa4, 0x3b, 0x9c, 0x4a, 0x6d, 0x77,
-                0xb8, 0x6a, 0x40, 0x18, 0x2d, 0x70, 0x31, 0x8b, 0x8f, 0xa3, 0x48, 0xb1, 0x86, 0x47,
-                0xd8, 0x4e, 0x0e, 0xe5, 0xf0, 0x56, 0x07, 0xa2, 0xb8, 0xf2, 0x69, 0xe1, 0x86, 0xc7,
-                0x94, 0x28, 0xbe, 0xa6, 0x7c, 0xbf, 0x71, 0xda, 0xcc, 0x98, 0xe9, 0xcc, 0x72, 0x5e,
-                0x50, 0x53, 0xa4, 0x40, 0xca, 0xa6, 0xca, 0xd2, 0x41, 0xa5, 0x06, 0x28, 0x18, 0x3a,
-                0xe9, 0xef, 0x9f, 0x0c, 0xbd, 0xfe, 0xf7, 0x0a, 0x42, 0xe5, 0xb7, 0x97, 0xbc, 0x99,
-                0xd9, 0x22, 0xfc, 0xc2, 0x81, 0x37, 0x84, 0xea, 0xe4, 0x48, 0x60, 0x18, 0x0e, 0xf8,
-                0xe8, 0x1f, 0x7b, 0x94, 0xf2, 0xad, 0x62, 0x12, 0x8b, 0xb6, 0x1f, 0x10, 0xd5, 0x0c,
-                0x9c, 0xad, 0x9d, 0x80, 0x48, 0xd9, 0x78, 0x01, 0x8a, 0x1f, 0x3b, 0xc9, 0x24, 0x28,
-                0xf8, 0x9d, 0x7d, 0xdc, 0xe5, 0x45, 0x4b, 0xc4, 0x49, 0x1f, 0xb4, 0xc2, 0xcb, 0x66,
-                0x88, 0x35, 0xb2, 0x2f, 0xcc, 0x4d, 0xf2, 0x08, 0xf2, 0x16, 0x64, 0xf7, 0x12, 0x94,
-                0xc5, 0xce, 0xd3, 0x3c, 0x8e, 0x11, 0xd4, 0x25, 0xd1, 0x39, 0x85, 0x23, 0xc2, 0x79,
-                0x88, 0x3a, 0x38, 0x2f, 0x70, 0xfe, 0xfe, 0xc8, 0x25, 0xc5, 0xe3, 0x50, 0x85, 0xaf,
-                0x82, 0xd0, 0xa0, 0xa9, 0xbf, 0x45, 0x11, 0x65, 0x0a, 0x2b, 0xfb, 0xf0, 0xb2, 0x18,
-                0x82, 0x10, 0x5e, 0xc6, 0xe5, 0x99, 0x74, 0xd8, 0xd6, 0xce, 0x73, 0x07, 0x8f, 0xb4,
-                0xb5, 0x63, 0x4e, 0x85, 0xd7, 0xe2, 0x0a, 0x97, 0xff, 0xb6, 0x5d, 0x4f, 0x5e, 0xaf,
-                0x42, 0x63, 0x9b, 0x09, 0xf5, 0xed, 0xa5, 0x9a, 0xb1, 0x04, 0x97, 0x69, 0x95, 0x41,
-                0xd1, 0xc8, 0x22, 0x8e, 0xb5, 0xdf, 0x47, 0xa6, 0x67, 0xc4, 0x6d, 0x4c, 0xff, 0xeb,
-                0xfe, 0x3f, 0xbb, 0x0a, 0x4e, 0x48,
-            ],
-            ock: [
-                0xc6, 0x7c, 0x23, 0x33, 0xc3, 0xcf, 0x4a, 0xc4, 0x6e, 0xde, 0x34, 0xe3, 0xe3, 0xe0,
-                0xdb, 0xff, 0x1e, 0x96, 0xb7, 0xa7, 0x8f, 0x16, 0xaa, 0xef, 0x1c, 0x74, 0xa3, 0xef,
-                0x07, 0xc5, 0x97, 0x16,
-            ],
-            op: [
-                0x05, 0x82, 0x53, 0xd4, 0x85, 0x76, 0x44, 0x88, 0x5e, 0x26, 0xa9, 0x09, 0xc8, 0x38,
-                0x59, 0x25, 0x23, 0x5a, 0x75, 0x29, 0x85, 0x44, 0x6e, 0x11, 0x69, 0x5f, 0x36, 0xc2,
-                0xe6, 0x84, 0x45, 0xbb, 0x05, 0x18, 0xdd, 0xc0, 0xc4, 0x7b, 0x7f, 0x77, 0xed, 0xcd,
-                0x39, 0x16, 0x0f, 0xe5, 0x67, 0x75, 0x1e, 0xb8, 0x4a, 0xa2, 0x1d, 0x33, 0xa6, 0x90,
-                0xe0, 0xd2, 0x9b, 0x35, 0x9a, 0xc4, 0xfa, 0x2c,
-            ],
-            c_out: [
-                0xe4, 0xba, 0x0e, 0xa2, 0x92, 0x3b, 0x40, 0x19, 0xac, 0x8a, 0xbc, 0xd1, 0x9b, 0xe6,
-                0x1c, 0x90, 0xf1, 0x8e, 0xef, 0xae, 0x87, 0xc4, 0xed, 0x8c, 0x76, 0x70, 0x85, 0xba,
-                0xa8, 0x3b, 0x4d, 0x61, 0x0c, 0xf3, 0x63, 0x70, 0xda, 0x07, 0x90, 0x1e, 0xad, 0x6d,
-                0x4f, 0x4b, 0x71, 0xdc, 0xae, 0x31, 0x1f, 0xa0, 0x36, 0x40, 0x6d, 0x64, 0x7b, 0x7e,
-                0xe1, 0x41, 0x1e, 0xf5, 0xae, 0xe0, 0x34, 0x68, 0xb1, 0x09, 0x13, 0xc9, 0x90, 0xcb,
-                0x61, 0x61, 0x22, 0xeb, 0xbe, 0x49, 0xda, 0x67, 0x81, 0xc2,
-            ],
-            asset: Some([
-                0xa9, 0x71, 0x5e, 0x65, 0xaf, 0x82, 0x67, 0x37, 0x3d, 0x34, 0x51, 0x67, 0x4f, 0xf0,
-                0x84, 0xef, 0xd9, 0x2c, 0xcf, 0x3b, 0xcc, 0x7a, 0xca, 0x14, 0x67, 0xb6, 0x32, 0x7e,
-                0x4f, 0x95, 0x22, 0xb2,
-            ]),
-        },
-        TestVector {
-            incoming_viewing_key: [
-                0xb6, 0x6c, 0x73, 0x33, 0x75, 0xda, 0xc6, 0xff, 0xcc, 0x98, 0xf5, 0x0f, 0x3a, 0xf0,
-                0xb0, 0x76, 0x05, 0x53, 0xfe, 0x98, 0xed, 0x61, 0xff, 0xa4, 0x93, 0xea, 0xe6, 0x8d,
-                0xf0, 0xb3, 0x33, 0x4e, 0xe8, 0xd4, 0x39, 0x37, 0xb7, 0xdb, 0x8e, 0xbb, 0xfe, 0xbd,
-                0x54, 0x8a, 0x28, 0x02, 0x51, 0xea, 0x87, 0xaa, 0x5d, 0x8c, 0xa5, 0x36, 0x86, 0x1b,
-                0x38, 0x4f, 0x20, 0x86, 0x9f, 0x8f, 0xe8, 0x01,
-            ],
-            ovk: [
-                0xe9, 0x4c, 0x15, 0x24, 0x5f, 0x1a, 0x95, 0x88, 0x40, 0xba, 0x3f, 0x38, 0x0a, 0x4d,
-                0x20, 0xf1, 0x18, 0x4e, 0x77, 0x82, 0x7d, 0xe3, 0xff, 0x8f, 0x3d, 0x73, 0x45, 0x9a,
-                0xfe, 0x24, 0x1f, 0x72,
-            ],
-            default_d: [
-                0x7c, 0x51, 0xbe, 0xc6, 0xee, 0x28, 0x46, 0xfd, 0x85, 0x12, 0x64,
-            ],
-            default_pk_d: [
-                0x7a, 0xfc, 0xa0, 0x5d, 0x04, 0x2c, 0x84, 0x3e, 0xec, 0xdc, 0x37, 0x24, 0x10, 0x52,
-                0xc4, 0x6f, 0x93, 0xd4, 0xaf, 0xd5, 0xc9, 0xb0, 0x4d, 0x2b, 0x26, 0x4e, 0x81, 0x0f,
-                0x25, 0xc8, 0xd6, 0xae,
-            ],
-            v: 16065731808124965111,
-            rseed: [
-                0x26, 0xf2, 0x84, 0x38, 0xe5, 0x78, 0x2f, 0x45, 0xac, 0x1d, 0x07, 0xf6, 0xf6, 0xf5,
-                0xed, 0x73, 0x74, 0x1d, 0x57, 0x85, 0x83, 0x7a, 0x6b, 0x84, 0x4b, 0x47, 0x47, 0x75,
-                0x71, 0x8c, 0x29, 0xdd,
-            ],
-            memo: [
-                0xff, 0x99, 0x08, 0x4e, 0x9f, 0x88, 0xef, 0x15, 0x3a, 0x83, 0x29, 0xf5, 0x32, 0xa6,
-                0x90, 0x17, 0xdc, 0x3a, 0x97, 0xed, 0x75, 0x43, 0x67, 0x72, 0x30, 0x98, 0xe5, 0x76,
-                0x58, 0x40, 0xb0, 0x22, 0x89, 0x72, 0x44, 0x74, 0x5f, 0xbb, 0xbb, 0x30, 0xa7, 0xcb,
-                0x54, 0xfa, 0x05, 0x11, 0x16, 0x6e, 0x95, 0x44, 0x12, 0x20, 0x00, 0x61, 0x0b, 0xd2,
-                0xaa, 0xcb, 0xd8, 0x23, 0x25, 0xa5, 0x9b, 0x95, 0x15, 0x4e, 0xcd, 0x82, 0xc8, 0x8d,
-                0x23, 0xab, 0xd1, 0xe2, 0x07, 0x70, 0xff, 0xb8, 0xaa, 0xbf, 0x83, 0xfc, 0x07, 0x34,
-                0x96, 0x4c, 0xcd, 0x41, 0x1d, 0x1c, 0x93, 0x57, 0x14, 0xe2, 0x4a, 0xab, 0x56, 0x6f,
-                0x4f, 0x08, 0x42, 0x40, 0x14, 0xc4, 0xec, 0xa9, 0x1b, 0x59, 0x0f, 0x08, 0x2b, 0x47,
-                0x3f, 0x36, 0x1c, 0x87, 0x41, 0x5d, 0x37, 0xbd, 0x20, 0xd7, 0x0f, 0xd0, 0xb5, 0x2b,
-                0x6d, 0xdf, 0x18, 0x65, 0xf7, 0x66, 0x70, 0x2e, 0x32, 0xb0, 0x5b, 0x3c, 0xf1, 0x63,
-                0x0e, 0xe8, 0x59, 0x7a, 0xae, 0x19, 0x63, 0x3f, 0x35, 0x16, 0xa8, 0x55, 0x5a, 0xc5,
-                0xbe, 0x32, 0xc6, 0x75, 0xbe, 0x18, 0x17, 0xef, 0xbf, 0xfd, 0x93, 0x69, 0x04, 0x1a,
-                0x08, 0x9c, 0x28, 0x3f, 0x19, 0x64, 0x99, 0x68, 0xc2, 0x49, 0x8c, 0xde, 0x56, 0xf5,
-                0x00, 0x43, 0x4f, 0x28, 0x0d, 0x77, 0xa9, 0xc6, 0x2e, 0x43, 0xcb, 0xd3, 0xf1, 0x36,
-                0xa4, 0xc6, 0xa0, 0x0a, 0x43, 0xe6, 0xed, 0x53, 0x0c, 0xb2, 0xe8, 0xae, 0x83, 0x88,
-                0x60, 0xad, 0xc8, 0x8a, 0xac, 0xc7, 0xbd, 0x6a, 0x00, 0xae, 0x0c, 0x19, 0xff, 0x45,
-                0x33, 0xa4, 0x85, 0xef, 0xde, 0x08, 0x2b, 0x5f, 0x4d, 0x1f, 0x7a, 0x8e, 0xbe, 0x7e,
-                0xd8, 0x2b, 0x7b, 0x05, 0xa8, 0xcf, 0xe1, 0xe3, 0x73, 0x45, 0x9f, 0x1b, 0xdc, 0xbf,
-                0x95, 0x25, 0x74, 0x7e, 0x8c, 0x95, 0x08, 0xa5, 0x55, 0xfa, 0xcb, 0x79, 0x87, 0x40,
-                0xe0, 0xbd, 0xf9, 0x94, 0xd9, 0x73, 0x9b, 0xbe, 0x55, 0x38, 0xa0, 0xae, 0x0f, 0x07,
-                0x6c, 0x58, 0x2c, 0x0f, 0x5b, 0xa8, 0x78, 0xb9, 0x9b, 0x82, 0x49, 0xdb, 0x1d, 0x7e,
-                0x95, 0x05, 0x6c, 0x98, 0xaf, 0x08, 0x3d, 0x98, 0xcb, 0x0e, 0xd9, 0xe3, 0xf7, 0x43,
-                0x6e, 0x1c, 0x76, 0x43, 0x76, 0x6f, 0x96, 0x6b, 0x83, 0xe9, 0x99, 0x20, 0x6e, 0xbd,
-                0x13, 0x93, 0xb9, 0xb2, 0xa7, 0xf4, 0x14, 0x48, 0x0f, 0xa0, 0x17, 0x48, 0x00, 0x69,
-                0xf8, 0x5c, 0x77, 0x49, 0xc4, 0x35, 0xae, 0x2f, 0xba, 0x2d, 0xdc, 0x10, 0x38, 0xd5,
-                0x47, 0xd8, 0x48, 0x54, 0x81, 0x7e, 0xf3, 0x96, 0x35, 0xc2, 0x98, 0x27, 0xaa, 0xd8,
-                0x67, 0x26, 0xc9, 0xad, 0xe3, 0xb2, 0x65, 0xb9, 0x08, 0x6c, 0x8b, 0x5b, 0x75, 0xef,
-                0x56, 0xfe, 0x4b, 0xd8, 0xb4, 0xd6, 0x28, 0x93, 0x89, 0x5b, 0x3f, 0xd2, 0x73, 0x4f,
-                0xda, 0xc4, 0x64, 0x15, 0x6d, 0x7e, 0x5e, 0xbc, 0x7e, 0xcf, 0x1d, 0x83, 0xb8, 0x6f,
-                0x65, 0x96, 0x37, 0xe3, 0xb1, 0x42, 0xc1, 0x64, 0x96, 0x3b, 0x8c, 0xdc, 0xf4, 0xba,
-                0x4f, 0x40, 0x35, 0xdf, 0xfc, 0x5a, 0x78, 0x94, 0x58, 0x84, 0x77, 0x81, 0x91, 0x8a,
-                0xc7, 0x2f, 0xc1, 0x8b, 0xbb, 0xf5, 0x11, 0x00, 0x32, 0xe6, 0x6d, 0x75, 0xb3, 0x17,
-                0x1e, 0xf4, 0xb5, 0x13, 0x29, 0x01, 0x64, 0xa7, 0x7b, 0x42, 0xb0, 0xa4, 0xcf, 0xb8,
-                0x96, 0x39, 0xab, 0x23, 0x84, 0x5e, 0x1a, 0xa2, 0xa4, 0x52, 0xf3, 0x73, 0x1c, 0x8c,
-                0xb6, 0x50, 0x82, 0xa6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ],
-            cv_net: [
-                0x0a, 0x1f, 0x28, 0x15, 0xb7, 0xaf, 0xe2, 0x19, 0x06, 0x87, 0x15, 0xfc, 0x76, 0x6b,
-                0x87, 0x2e, 0xf2, 0x17, 0x35, 0x43, 0xac, 0x81, 0x4c, 0x32, 0xb4, 0xb6, 0x9c, 0x9c,
-                0x34, 0x5e, 0x46, 0x98,
-            ],
-            rho: [
-                0x27, 0x3c, 0x68, 0xd1, 0x9c, 0xda, 0xa8, 0x62, 0x8b, 0xac, 0x37, 0xa2, 0xd4, 0x2c,
-                0x51, 0x1c, 0x9b, 0xab, 0x65, 0xb6, 0xd8, 0xd5, 0xc5, 0xbd, 0x1e, 0x32, 0x77, 0x1a,
-                0xb6, 0xf6, 0x4c, 0x26,
-            ],
-            cmx: [
-                0x40, 0x8f, 0x59, 0x4f, 0xdd, 0xc5, 0x0c, 0x67, 0xf5, 0x47, 0xe1, 0xeb, 0x3e, 0xa2,
-                0x99, 0xa3, 0x1f, 0x69, 0xf5, 0x7f, 0xc9, 0x92, 0x03, 0x01, 0x42, 0x90, 0x35, 0xa6,
-                0xc2, 0x49, 0x79, 0x1a,
-            ],
-            esk: [
-                0xcb, 0xfc, 0x51, 0x10, 0xff, 0x2f, 0xe9, 0xc5, 0xd5, 0x9e, 0xef, 0x08, 0xbd, 0xf6,
-                0xf8, 0x57, 0xe7, 0x1a, 0xab, 0x45, 0x0e, 0x6c, 0xd6, 0x13, 0xf5, 0x3b, 0x57, 0xc3,
-                0x45, 0xa9, 0x87, 0x2f,
-            ],
-            ephemeral_key: [
-                0xa5, 0xc8, 0x0a, 0x29, 0xf2, 0xec, 0xdd, 0xd7, 0x01, 0x96, 0xef, 0x45, 0x9e, 0xd5,
-                0x03, 0xc4, 0xb3, 0xc2, 0x22, 0x8d, 0x10, 0xcc, 0xbc, 0xad, 0x9a, 0x28, 0x23, 0x30,
-                0x07, 0x7b, 0xca, 0x0c,
-            ],
-            shared_secret: [
-                0x37, 0x14, 0x15, 0xfc, 0x1e, 0x98, 0x42, 0xa1, 0x26, 0xa3, 0x7a, 0xa7, 0x7b, 0x8f,
-                0x0f, 0x1a, 0xb6, 0x48, 0xa3, 0xf7, 0x43, 0x57, 0x34, 0x89, 0x6f, 0x07, 0x59, 0x52,
-                0xe7, 0xd1, 0x60, 0x17,
-            ],
-            k_enc: [
-                0xd7, 0x36, 0xf0, 0x3c, 0x81, 0x2d, 0x9b, 0xf9, 0x54, 0xff, 0xd2, 0x41, 0x84, 0x07,
-                0xf3, 0x36, 0xa5, 0xf9, 0x69, 0x8b, 0x62, 0x85, 0x23, 0x2f, 0x5c, 0x85, 0xf0, 0xd1,
-                0x1d, 0x5e, 0x9d, 0x0a,
-            ],
-            p_enc: [
-                0x03, 0x7c, 0x51, 0xbe, 0xc6, 0xee, 0x28, 0x46, 0xfd, 0x85, 0x12, 0x64, 0xf7, 0x90,
-                0xfb, 0xa7, 0xf5, 0xf1, 0xf4, 0xde, 0x26, 0xf2, 0x84, 0x38, 0xe5, 0x78, 0x2f, 0x45,
-                0xac, 0x1d, 0x07, 0xf6, 0xf6, 0xf5, 0xed, 0x73, 0x74, 0x1d, 0x57, 0x85, 0x83, 0x7a,
-                0x6b, 0x84, 0x4b, 0x47, 0x47, 0x75, 0x71, 0x8c, 0x29, 0xdd, 0xdf, 0xfd, 0x79, 0xa9,
-                0xde, 0xd0, 0x5e, 0x88, 0x89, 0x58, 0x19, 0x9e, 0xea, 0x45, 0x01, 0xe2, 0x99, 0x0a,
-                0x53, 0xa5, 0xcd, 0x2a, 0x46, 0xa4, 0x01, 0x57, 0x65, 0x88, 0xfd, 0x7d, 0x05, 0x8a,
-                0xff, 0x99, 0x08, 0x4e, 0x9f, 0x88, 0xef, 0x15, 0x3a, 0x83, 0x29, 0xf5, 0x32, 0xa6,
-                0x90, 0x17, 0xdc, 0x3a, 0x97, 0xed, 0x75, 0x43, 0x67, 0x72, 0x30, 0x98, 0xe5, 0x76,
-                0x58, 0x40, 0xb0, 0x22, 0x89, 0x72, 0x44, 0x74, 0x5f, 0xbb, 0xbb, 0x30, 0xa7, 0xcb,
-                0x54, 0xfa, 0x05, 0x11, 0x16, 0x6e, 0x95, 0x44, 0x12, 0x20, 0x00, 0x61, 0x0b, 0xd2,
-                0xaa, 0xcb, 0xd8, 0x23, 0x25, 0xa5, 0x9b, 0x95, 0x15, 0x4e, 0xcd, 0x82, 0xc8, 0x8d,
-                0x23, 0xab, 0xd1, 0xe2, 0x07, 0x70, 0xff, 0xb8, 0xaa, 0xbf, 0x83, 0xfc, 0x07, 0x34,
-                0x96, 0x4c, 0xcd, 0x41, 0x1d, 0x1c, 0x93, 0x57, 0x14, 0xe2, 0x4a, 0xab, 0x56, 0x6f,
-                0x4f, 0x08, 0x42, 0x40, 0x14, 0xc4, 0xec, 0xa9, 0x1b, 0x59, 0x0f, 0x08, 0x2b, 0x47,
-                0x3f, 0x36, 0x1c, 0x87, 0x41, 0x5d, 0x37, 0xbd, 0x20, 0xd7, 0x0f, 0xd0, 0xb5, 0x2b,
-                0x6d, 0xdf, 0x18, 0x65, 0xf7, 0x66, 0x70, 0x2e, 0x32, 0xb0, 0x5b, 0x3c, 0xf1, 0x63,
-                0x0e, 0xe8, 0x59, 0x7a, 0xae, 0x19, 0x63, 0x3f, 0x35, 0x16, 0xa8, 0x55, 0x5a, 0xc5,
-                0xbe, 0x32, 0xc6, 0x75, 0xbe, 0x18, 0x17, 0xef, 0xbf, 0xfd, 0x93, 0x69, 0x04, 0x1a,
-                0x08, 0x9c, 0x28, 0x3f, 0x19, 0x64, 0x99, 0x68, 0xc2, 0x49, 0x8c, 0xde, 0x56, 0xf5,
-                0x00, 0x43, 0x4f, 0x28, 0x0d, 0x77, 0xa9, 0xc6, 0x2e, 0x43, 0xcb, 0xd3, 0xf1, 0x36,
-                0xa4, 0xc6, 0xa0, 0x0a, 0x43, 0xe6, 0xed, 0x53, 0x0c, 0xb2, 0xe8, 0xae, 0x83, 0x88,
-                0x60, 0xad, 0xc8, 0x8a, 0xac, 0xc7, 0xbd, 0x6a, 0x00, 0xae, 0x0c, 0x19, 0xff, 0x45,
-                0x33, 0xa4, 0x85, 0xef, 0xde, 0x08, 0x2b, 0x5f, 0x4d, 0x1f, 0x7a, 0x8e, 0xbe, 0x7e,
-                0xd8, 0x2b, 0x7b, 0x05, 0xa8, 0xcf, 0xe1, 0xe3, 0x73, 0x45, 0x9f, 0x1b, 0xdc, 0xbf,
-                0x95, 0x25, 0x74, 0x7e, 0x8c, 0x95, 0x08, 0xa5, 0x55, 0xfa, 0xcb, 0x79, 0x87, 0x40,
-                0xe0, 0xbd, 0xf9, 0x94, 0xd9, 0x73, 0x9b, 0xbe, 0x55, 0x38, 0xa0, 0xae, 0x0f, 0x07,
-                0x6c, 0x58, 0x2c, 0x0f, 0x5b, 0xa8, 0x78, 0xb9, 0x9b, 0x82, 0x49, 0xdb, 0x1d, 0x7e,
-                0x95, 0x05, 0x6c, 0x98, 0xaf, 0x08, 0x3d, 0x98, 0xcb, 0x0e, 0xd9, 0xe3, 0xf7, 0x43,
-                0x6e, 0x1c, 0x76, 0x43, 0x76, 0x6f, 0x96, 0x6b, 0x83, 0xe9, 0x99, 0x20, 0x6e, 0xbd,
-                0x13, 0x93, 0xb9, 0xb2, 0xa7, 0xf4, 0x14, 0x48, 0x0f, 0xa0, 0x17, 0x48, 0x00, 0x69,
-                0xf8, 0x5c, 0x77, 0x49, 0xc4, 0x35, 0xae, 0x2f, 0xba, 0x2d, 0xdc, 0x10, 0x38, 0xd5,
-                0x47, 0xd8, 0x48, 0x54, 0x81, 0x7e, 0xf3, 0x96, 0x35, 0xc2, 0x98, 0x27, 0xaa, 0xd8,
-                0x67, 0x26, 0xc9, 0xad, 0xe3, 0xb2, 0x65, 0xb9, 0x08, 0x6c, 0x8b, 0x5b, 0x75, 0xef,
-                0x56, 0xfe, 0x4b, 0xd8, 0xb4, 0xd6, 0x28, 0x93, 0x89, 0x5b, 0x3f, 0xd2, 0x73, 0x4f,
-                0xda, 0xc4, 0x64, 0x15, 0x6d, 0x7e, 0x5e, 0xbc, 0x7e, 0xcf, 0x1d, 0x83, 0xb8, 0x6f,
-                0x65, 0x96, 0x37, 0xe3, 0xb1, 0x42, 0xc1, 0x64, 0x96, 0x3b, 0x8c, 0xdc, 0xf4, 0xba,
-                0x4f, 0x40, 0x35, 0xdf, 0xfc, 0x5a, 0x78, 0x94, 0x58, 0x84, 0x77, 0x81, 0x91, 0x8a,
-                0xc7, 0x2f, 0xc1, 0x8b, 0xbb, 0xf5, 0x11, 0x00, 0x32, 0xe6, 0x6d, 0x75, 0xb3, 0x17,
-                0x1e, 0xf4, 0xb5, 0x13, 0x29, 0x01, 0x64, 0xa7, 0x7b, 0x42, 0xb0, 0xa4, 0xcf, 0xb8,
-                0x96, 0x39, 0xab, 0x23, 0x84, 0x5e, 0x1a, 0xa2, 0xa4, 0x52, 0xf3, 0x73, 0x1c, 0x8c,
-                0xb6, 0x50, 0x82, 0xa6,
-            ],
-            c_enc: [
-                0xfc, 0x90, 0xcb, 0xe1, 0xcd, 0x9f, 0x59, 0x9a, 0x1a, 0x24, 0xc7, 0xa3, 0xea, 0xf6,
-                0x07, 0xd9, 0x13, 0xbf, 0x48, 0xbd, 0xc1, 0xa4, 0x6d, 0xf7, 0xb1, 0x74, 0x7f, 0x12,
-                0x60, 0x64, 0x49, 0x4b, 0xf5, 0x39, 0x61, 0xe9, 0xa5, 0xa2, 0xb9, 0x69, 0x80, 0x57,
-                0x63, 0x44, 0x2e, 0x2c, 0x38, 0x8d, 0x21, 0x2d, 0x74, 0x84, 0x6e, 0x57, 0x27, 0x87,
-                0x2d, 0x06, 0x3f, 0xc9, 0x94, 0xa4, 0x4f, 0x9e, 0xb6, 0x55, 0x25, 0xd6, 0x8f, 0x98,
-                0x24, 0xa6, 0x03, 0x75, 0xfe, 0x43, 0xc0, 0x5f, 0x08, 0xfe, 0x45, 0x42, 0xa7, 0xe4,
-                0x0c, 0x03, 0x8d, 0xe7, 0x10, 0x85, 0x01, 0x17, 0x95, 0x1b, 0x9a, 0x32, 0x1e, 0xea,
-                0x4f, 0x8c, 0x91, 0xc0, 0x1d, 0x39, 0xdb, 0xb5, 0xd4, 0x12, 0x40, 0xf8, 0xb1, 0xb1,
-                0xdb, 0xb3, 0x3f, 0x45, 0x87, 0x87, 0xdb, 0x8c, 0xda, 0x06, 0x9b, 0x64, 0x5a, 0x76,
-                0x38, 0xc2, 0xec, 0xca, 0xd3, 0xd9, 0xa7, 0x39, 0xd6, 0x4c, 0x9a, 0xd5, 0xd5, 0xb3,
-                0xa0, 0x24, 0x55, 0xa4, 0xec, 0xd6, 0x96, 0x7c, 0xf3, 0xb3, 0x3b, 0xf0, 0x4e, 0xf6,
-                0xdd, 0x88, 0x10, 0xe1, 0x0c, 0x25, 0x86, 0xf7, 0x89, 0x32, 0x44, 0xea, 0x72, 0x80,
-                0xd1, 0x34, 0xcf, 0x37, 0xb3, 0xdc, 0x0c, 0x32, 0x82, 0x3b, 0x1a, 0x29, 0xc5, 0x0c,
-                0xa6, 0x48, 0x31, 0xd8, 0x4e, 0xbd, 0xf5, 0xe0, 0x1c, 0x14, 0xca, 0x36, 0x05, 0xbe,
-                0x02, 0xf1, 0x5f, 0x31, 0x57, 0x90, 0xf7, 0x4e, 0x20, 0x57, 0x7f, 0x92, 0x39, 0x51,
-                0x2f, 0xbd, 0xdd, 0x67, 0x63, 0x77, 0xae, 0x50, 0xc3, 0xfe, 0x71, 0xc9, 0x30, 0xa8,
-                0x29, 0x57, 0xd1, 0x54, 0x70, 0xeb, 0x1b, 0x55, 0xb2, 0x0c, 0xe5, 0x02, 0x35, 0x64,
-                0xfe, 0xa7, 0xe1, 0x81, 0xbe, 0x04, 0xa9, 0x33, 0xa7, 0xa3, 0xa1, 0x11, 0x89, 0x4d,
-                0xec, 0xf7, 0x2a, 0x56, 0x54, 0xcb, 0x4e, 0xac, 0x32, 0xe1, 0xd5, 0x96, 0xad, 0x99,
-                0x1a, 0x2f, 0x4c, 0x62, 0xe8, 0xe2, 0x82, 0x57, 0x13, 0x7b, 0xcb, 0xa5, 0x03, 0xdc,
-                0x91, 0xed, 0x9e, 0x90, 0xb3, 0x08, 0xcd, 0xa5, 0xcc, 0xcc, 0xc9, 0xd1, 0x4e, 0xa6,
-                0xd0, 0x3b, 0x3d, 0xec, 0xa1, 0x57, 0xd5, 0x30, 0xde, 0x63, 0x1e, 0x1e, 0x45, 0x8f,
-                0x6a, 0x60, 0x8e, 0x1f, 0x9d, 0x57, 0x9b, 0x6e, 0xe6, 0x00, 0x5c, 0xd0, 0xa8, 0xc3,
-                0xe2, 0xdf, 0x89, 0x46, 0x8a, 0xcf, 0xb4, 0x36, 0xcb, 0x59, 0x84, 0x56, 0xf0, 0x38,
-                0x95, 0x5d, 0xc6, 0xb4, 0x07, 0xec, 0x33, 0x00, 0xa5, 0xcf, 0xcd, 0xc8, 0x45, 0x47,
-                0xe3, 0xef, 0xe9, 0xfc, 0xa1, 0x7e, 0xd2, 0xc2, 0x74, 0xf0, 0x03, 0x0b, 0x63, 0xcc,
-                0x42, 0xe2, 0x38, 0x94, 0xa5, 0xf2, 0x53, 0x66, 0xcb, 0xc3, 0xbf, 0xcb, 0x77, 0x2d,
-                0x04, 0x17, 0xf6, 0x24, 0x4b, 0x2f, 0xd8, 0x17, 0xc4, 0xc6, 0x79, 0x06, 0xc3, 0x38,
-                0x4d, 0x69, 0xd7, 0x93, 0xef, 0xca, 0x6e, 0x5d, 0x6a, 0xf2, 0x5e, 0x4e, 0xbc, 0x0f,
-                0x53, 0x56, 0xeb, 0x74, 0x28, 0x85, 0x19, 0xe8, 0xf4, 0x49, 0x38, 0xeb, 0xf9, 0xb2,
-                0x5b, 0xe5, 0x85, 0xe1, 0x35, 0x1f, 0x62, 0x59, 0x6c, 0x31, 0x79, 0xca, 0xe4, 0x5e,
-                0x75, 0x49, 0xd7, 0xfb, 0xb5, 0x91, 0x3b, 0xe9, 0xc3, 0xba, 0xa5, 0x7c, 0xab, 0x7c,
-                0xd4, 0xb5, 0x67, 0x12, 0x8d, 0x1b, 0xa5, 0x20, 0x31, 0xd7, 0xd5, 0xa5, 0xbd, 0x69,
-                0xde, 0x61, 0x4a, 0xbb, 0x8c, 0xa3, 0x8a, 0x94, 0x51, 0xcd, 0x1b, 0xad, 0xd9, 0x71,
-                0xb3, 0xf1, 0xb0, 0xb5, 0x0c, 0x7f, 0x21, 0xbf, 0xc4, 0x23, 0x04, 0xa4, 0xa5, 0x3e,
-                0x0d, 0x55, 0x92, 0x0d, 0xa0, 0x53, 0x27, 0x14, 0x79, 0x13, 0x45, 0xfb, 0x07, 0x4c,
-                0x66, 0xc4, 0xb7, 0xc9, 0x89, 0x28, 0x30, 0xf9, 0x62, 0x09, 0xb8, 0x1c, 0x26, 0xd1,
-                0x74, 0xf8, 0xa9, 0x33, 0xc3, 0x77, 0x9d, 0x97, 0x88, 0x55, 0x3f, 0x6e, 0xeb, 0x21,
-                0xf7, 0xdb, 0x57, 0x78, 0xf4, 0xf8, 0x17, 0x4c, 0xb4, 0x6f, 0x71, 0xfd, 0xdc, 0x4b,
-                0xe4, 0xd8, 0x70, 0x3e, 0xbf, 0xbc, 0xd2, 0xa7, 0x72, 0x89, 0xee, 0xfa, 0x72, 0x76,
-                0x56, 0x74, 0xdb, 0xf0, 0xe0, 0x65, 0xff, 0xcb, 0xf6, 0xbb, 0xa0, 0x18, 0x09, 0x1e,
-                0x49, 0xaa, 0x90, 0xe6, 0x02, 0xc8,
-            ],
-            ock: [
-                0x2f, 0x88, 0x37, 0x27, 0xb5, 0x4d, 0x06, 0x25, 0xcf, 0xdc, 0x19, 0x5a, 0xce, 0x10,
-                0xca, 0xc0, 0x26, 0x8a, 0xba, 0x3d, 0xe2, 0x8a, 0xd6, 0x08, 0x88, 0x06, 0x50, 0x6d,
-                0x69, 0xc4, 0xdd, 0x8e,
-            ],
-            op: [
-                0x7a, 0xfc, 0xa0, 0x5d, 0x04, 0x2c, 0x84, 0x3e, 0xec, 0xdc, 0x37, 0x24, 0x10, 0x52,
-                0xc4, 0x6f, 0x93, 0xd4, 0xaf, 0xd5, 0xc9, 0xb0, 0x4d, 0x2b, 0x26, 0x4e, 0x81, 0x0f,
-                0x25, 0xc8, 0xd6, 0xae, 0xcb, 0xfc, 0x51, 0x10, 0xff, 0x2f, 0xe9, 0xc5, 0xd5, 0x9e,
-                0xef, 0x08, 0xbd, 0xf6, 0xf8, 0x57, 0xe7, 0x1a, 0xab, 0x45, 0x0e, 0x6c, 0xd6, 0x13,
-                0xf5, 0x3b, 0x57, 0xc3, 0x45, 0xa9, 0x87, 0x2f,
-            ],
-            c_out: [
-                0x99, 0x96, 0x90, 0xd4, 0xcd, 0xd9, 0xe7, 0x6b, 0x07, 0x2c, 0x3c, 0x4c, 0x41, 0xbf,
-                0xc7, 0x9a, 0xaa, 0xc6, 0x7f, 0xdc, 0x0f, 0x41, 0xe8, 0x0e, 0x95, 0x48, 0x80, 0x0e,
-                0xef, 0xbc, 0x95, 0x74, 0xf1, 0x5d, 0x64, 0xa6, 0x9e, 0x44, 0x47, 0xc4, 0x5b, 0x07,
-                0x0c, 0x6c, 0x9f, 0x50, 0x0a, 0xdd, 0xef, 0x6f, 0x57, 0x14, 0xa5, 0x76, 0x22, 0x1f,
-                0x3f, 0xbc, 0x61, 0x22, 0x8d, 0x95, 0xc3, 0xac, 0xe4, 0x21, 0x4b, 0xb6, 0xcf, 0x5b,
-                0xd9, 0x69, 0x84, 0xd7, 0x78, 0x96, 0x0d, 0xe9, 0x0c, 0x02,
-            ],
-            asset: Some([
-                0xdf, 0xfd, 0x79, 0xa9, 0xde, 0xd0, 0x5e, 0x88, 0x89, 0x58, 0x19, 0x9e, 0xea, 0x45,
-                0x01, 0xe2, 0x99, 0x0a, 0x53, 0xa5, 0xcd, 0x2a, 0x46, 0xa4, 0x01, 0x57, 0x65, 0x88,
-                0xfd, 0x7d, 0x05, 0x8a,
-            ]),
-        },
-        TestVector {
-            incoming_viewing_key: [
-                0x8c, 0x45, 0x43, 0xe1, 0x1f, 0x9f, 0x30, 0x7e, 0xc9, 0x04, 0x31, 0x61, 0x29, 0x46,
-                0xfb, 0x01, 0x81, 0xb3, 0x6e, 0x1b, 0x52, 0xdb, 0x43, 0x1e, 0x6d, 0xf9, 0x38, 0x8c,
-                0xac, 0xd3, 0x08, 0xe8, 0x99, 0xd9, 0x3f, 0x70, 0xad, 0x2a, 0xea, 0xec, 0x99, 0x5e,
-                0xcc, 0xe1, 0x80, 0x1c, 0x61, 0x56, 0xe2, 0x3e, 0xc4, 0x1b, 0x1a, 0xe1, 0xcd, 0x2f,
-                0xd6, 0xe3, 0x9b, 0x69, 0x98, 0x2f, 0x46, 0x33,
-            ],
-            ovk: [
-                0x01, 0x76, 0xae, 0x33, 0x93, 0x25, 0xd5, 0xa5, 0x88, 0xda, 0x57, 0x96, 0xfa, 0xae,
-                0x5b, 0xab, 0x7c, 0x82, 0x97, 0x7c, 0x0f, 0xf7, 0x97, 0x09, 0x3e, 0x2c, 0x1f, 0x3a,
-                0xe8, 0x55, 0xf6, 0x5a,
-            ],
-            default_d: [
-                0x4e, 0x42, 0x6d, 0xf1, 0xad, 0x32, 0x48, 0x94, 0xbc, 0xa2, 0xc1,
-            ],
-            default_pk_d: [
-                0x84, 0xda, 0x49, 0x6b, 0x16, 0x0a, 0x81, 0x72, 0xc4, 0x8d, 0x76, 0xb4, 0xfb, 0x08,
-                0xbc, 0xab, 0xf4, 0x0f, 0xf1, 0xe4, 0x2c, 0x48, 0x66, 0x77, 0x57, 0x4f, 0x9e, 0xf8,
-                0x36, 0x34, 0xb0, 0x23,
-            ],
-            v: 3775288302605163507,
-            rseed: [
-                0x49, 0x56, 0xbb, 0xb1, 0x95, 0xa4, 0xfa, 0x66, 0xdc, 0x9c, 0xd5, 0x42, 0xc7, 0x6b,
-                0x91, 0x50, 0xc8, 0x4b, 0xf8, 0x90, 0x78, 0x99, 0x42, 0xf5, 0x5c, 0x20, 0x0b, 0x77,
-                0x3e, 0xcd, 0xd7, 0x99,
-            ],
-            memo: [
-                0xff, 0x2c, 0xff, 0x3e, 0xca, 0x24, 0xde, 0x3e, 0x09, 0x84, 0xe1, 0x0e, 0x68, 0xae,
-                0x38, 0x75, 0x34, 0xb9, 0x6c, 0xde, 0x37, 0x92, 0xf1, 0x35, 0xbf, 0x5f, 0x68, 0x78,
-                0x7d, 0x37, 0x0c, 0xa8, 0xc4, 0xc4, 0x07, 0x4d, 0xc5, 0xd6, 0x01, 0xae, 0x90, 0x49,
-                0x54, 0x37, 0xc3, 0xc2, 0xd4, 0x8a, 0x3d, 0x96, 0x66, 0x83, 0xac, 0x05, 0x16, 0x0b,
-                0x7a, 0x84, 0xea, 0xa7, 0xaa, 0xb7, 0x40, 0x09, 0xe5, 0x7a, 0x85, 0xf7, 0xbf, 0x68,
-                0xa2, 0xe4, 0x82, 0x00, 0x0f, 0x82, 0x9c, 0x54, 0x50, 0x73, 0xa1, 0x5d, 0x5c, 0xd0,
-                0xfc, 0xc5, 0x74, 0x39, 0xa4, 0x35, 0x0e, 0xaf, 0x09, 0x8d, 0xfb, 0x82, 0xa0, 0x85,
-                0xea, 0x8a, 0x4a, 0xf6, 0xfa, 0x83, 0x81, 0xf0, 0x65, 0x88, 0x19, 0xea, 0xb4, 0x83,
-                0xf6, 0x5b, 0x32, 0x5d, 0x5a, 0xed, 0xa1, 0x52, 0x32, 0xcf, 0xad, 0xec, 0x75, 0xab,
-                0x18, 0x66, 0xe4, 0xc0, 0x15, 0x5a, 0x9c, 0x74, 0xa7, 0xa5, 0x7c, 0xcf, 0x34, 0xc4,
-                0x83, 0xac, 0x7d, 0xa1, 0x58, 0x8a, 0x1b, 0x6b, 0x99, 0x41, 0xf1, 0x10, 0x40, 0xf9,
-                0x4c, 0xf7, 0x8f, 0xad, 0x89, 0xbf, 0x11, 0xfe, 0xd6, 0x9a, 0xa0, 0xd8, 0x31, 0x05,
-                0xad, 0xac, 0xdd, 0x4e, 0x5f, 0x04, 0xa6, 0x24, 0x24, 0x02, 0x3c, 0x9b, 0x9e, 0x33,
-                0xc4, 0xfb, 0x7f, 0x12, 0xbd, 0xf2, 0x1f, 0x07, 0xf2, 0x65, 0xc5, 0x37, 0xd5, 0x1c,
-                0x65, 0x51, 0xf4, 0x61, 0x7b, 0x91, 0x5d, 0x21, 0x99, 0x18, 0x39, 0xc3, 0xd0, 0xd3,
-                0x63, 0x93, 0xd6, 0x46, 0xe0, 0xa8, 0xa4, 0x15, 0x09, 0x21, 0x7d, 0x0e, 0x7d, 0x2c,
-                0xa1, 0xa0, 0xa0, 0xd6, 0x77, 0xa3, 0xea, 0xca, 0x23, 0xed, 0xeb, 0x07, 0xb7, 0x4e,
-                0x65, 0x2a, 0x0b, 0xc5, 0x0c, 0x6c, 0x08, 0x3a, 0x55, 0xd6, 0xc7, 0x30, 0x6e, 0x74,
-                0x08, 0x6f, 0x47, 0x68, 0x93, 0x3a, 0xa2, 0x48, 0x73, 0x68, 0x18, 0x67, 0xa7, 0x89,
-                0x3d, 0x77, 0xcb, 0x7f, 0x29, 0xb8, 0xc8, 0x47, 0xc5, 0x83, 0xf2, 0xd0, 0x71, 0xa6,
-                0x86, 0x61, 0x6e, 0x20, 0x67, 0x19, 0xf7, 0x61, 0xae, 0x39, 0xc1, 0x10, 0x44, 0x2e,
-                0x06, 0x16, 0x3d, 0x2b, 0x84, 0x59, 0x03, 0x60, 0x69, 0x5d, 0x4e, 0x19, 0x84, 0x9e,
-                0x63, 0x4f, 0x24, 0xd9, 0xad, 0x39, 0x6c, 0x19, 0xff, 0x83, 0xce, 0x74, 0xf4, 0x6e,
-                0x64, 0x5f, 0x93, 0x2e, 0x14, 0x1a, 0x41, 0x19, 0x59, 0x36, 0xc8, 0x5d, 0x51, 0x44,
-                0x14, 0xf1, 0x12, 0xe6, 0x0b, 0x1a, 0x25, 0x37, 0xc3, 0x8d, 0x6d, 0xc6, 0xc4, 0x63,
-                0x83, 0x05, 0xc9, 0xbd, 0x6c, 0x62, 0xe3, 0x66, 0xbc, 0x63, 0x12, 0x3e, 0x3e, 0x6d,
-                0xd3, 0x6e, 0xed, 0xd3, 0x13, 0x6f, 0xce, 0x8d, 0xee, 0xca, 0x2a, 0xa0, 0x9a, 0x32,
-                0x98, 0xa3, 0x9d, 0x83, 0x85, 0x9e, 0xfc, 0x9b, 0x2b, 0x69, 0xcf, 0x9a, 0x7d, 0xee,
-                0x08, 0xa9, 0x8e, 0x4b, 0xe5, 0x58, 0xac, 0x79, 0x12, 0xfd, 0xcb, 0x42, 0x20, 0x90,
-                0x75, 0x42, 0x02, 0x60, 0xf7, 0xca, 0xd0, 0xf2, 0xc0, 0x1f, 0x2a, 0xfe, 0x33, 0x07,
-                0x3f, 0x26, 0x24, 0x9d, 0x94, 0x4f, 0x7a, 0x50, 0xdd, 0x84, 0x83, 0x9b, 0xc3, 0xea,
-                0x7f, 0xde, 0xe4, 0xed, 0x71, 0x44, 0x9c, 0xf0, 0x75, 0x33, 0xd2, 0x6e, 0x1e, 0x27,
-                0xa3, 0xef, 0xb0, 0x32, 0xc3, 0xa3, 0xb3, 0x4b, 0xd3, 0x09, 0x26, 0x22, 0xd2, 0x06,
-                0x2a, 0xe5, 0x36, 0xef, 0x51, 0x49, 0xc4, 0x9b, 0x5b, 0xc9, 0x47, 0x5e, 0xaf, 0xab,
-                0x6e, 0x67, 0x57, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ],
-            cv_net: [
-                0xde, 0x2b, 0xfc, 0x89, 0x5b, 0xa8, 0xb5, 0x43, 0x03, 0x93, 0x43, 0x4e, 0x20, 0x92,
-                0xce, 0xe7, 0x81, 0xe4, 0x00, 0x28, 0x5c, 0xc6, 0x66, 0xbc, 0x6c, 0x41, 0x89, 0xdb,
-                0x2d, 0xda, 0x71, 0x92,
-            ],
-            rho: [
-                0xea, 0x1d, 0x9d, 0x26, 0x5e, 0xf4, 0x8a, 0x18, 0x97, 0x89, 0x70, 0xb1, 0x76, 0x7b,
-                0xe0, 0xe8, 0x14, 0x11, 0x94, 0x7e, 0x9e, 0x69, 0xb7, 0x19, 0xfa, 0xb7, 0x41, 0x72,
-                0x1d, 0x40, 0x9b, 0x33,
-            ],
-            cmx: [
-                0x9e, 0x3d, 0x61, 0x35, 0x6b, 0x0d, 0x88, 0x95, 0x9e, 0x3f, 0x0f, 0xcc, 0x4a, 0x93,
-                0x2e, 0x93, 0x2e, 0xac, 0xbc, 0x80, 0x1d, 0x48, 0xc0, 0x19, 0x5b, 0x9c, 0x8b, 0xd1,
-                0x05, 0x5a, 0x8e, 0x2e,
-            ],
-            esk: [
-                0x1b, 0x52, 0x63, 0x2d, 0x2a, 0x8d, 0x58, 0xd1, 0x63, 0x57, 0xa9, 0x19, 0xa2, 0x06,
-                0x31, 0xe2, 0x91, 0x14, 0xc8, 0x60, 0x07, 0xa2, 0xb1, 0x8b, 0x25, 0xec, 0xff, 0x47,
-                0x72, 0x16, 0x8c, 0x05,
-            ],
-            ephemeral_key: [
-                0xc1, 0xce, 0x25, 0xfb, 0x89, 0xe5, 0xca, 0x89, 0x97, 0xf9, 0xb4, 0xbb, 0x0e, 0x1e,
-                0xfb, 0xcc, 0x1a, 0x8c, 0xbf, 0x44, 0xec, 0xfd, 0x33, 0x2c, 0x6c, 0x5c, 0x17, 0x3b,
-                0xb1, 0x1f, 0xb5, 0x87,
-            ],
-            shared_secret: [
-                0x2e, 0xe5, 0x69, 0xce, 0xb3, 0xfd, 0xb8, 0x67, 0xa5, 0xd8, 0x4c, 0x92, 0x68, 0x24,
-                0xef, 0x54, 0x9f, 0x2d, 0xd2, 0x8f, 0x8b, 0x04, 0x8d, 0x67, 0xd0, 0x28, 0x81, 0x7d,
-                0xbf, 0xf5, 0xd2, 0xb1,
-            ],
-            k_enc: [
-                0x41, 0x4d, 0x80, 0x67, 0xc9, 0xfe, 0xbd, 0x5e, 0xbc, 0xd9, 0xae, 0x8c, 0x05, 0x99,
-                0x4e, 0x3b, 0x06, 0x85, 0xc8, 0x86, 0x6f, 0x88, 0x95, 0x94, 0xc3, 0x74, 0xb3, 0x75,
-                0xac, 0x2c, 0x6d, 0x24,
-            ],
-            p_enc: [
-                0x03, 0x4e, 0x42, 0x6d, 0xf1, 0xad, 0x32, 0x48, 0x94, 0xbc, 0xa2, 0xc1, 0xf3, 0xdb,
-                0x77, 0x79, 0xb5, 0x84, 0x64, 0x34, 0x49, 0x56, 0xbb, 0xb1, 0x95, 0xa4, 0xfa, 0x66,
-                0xdc, 0x9c, 0xd5, 0x42, 0xc7, 0x6b, 0x91, 0x50, 0xc8, 0x4b, 0xf8, 0x90, 0x78, 0x99,
-                0x42, 0xf5, 0x5c, 0x20, 0x0b, 0x77, 0x3e, 0xcd, 0xd7, 0x99, 0xa6, 0x33, 0x05, 0x44,
-                0xe5, 0x46, 0x39, 0xb5, 0x41, 0x87, 0x01, 0xff, 0x4c, 0xc4, 0x5a, 0x31, 0xf6, 0x2e,
-                0xdd, 0x84, 0x3d, 0xbb, 0xdc, 0x5a, 0xa7, 0x27, 0xab, 0x79, 0xb4, 0x42, 0x68, 0x3c,
-                0xff, 0x2c, 0xff, 0x3e, 0xca, 0x24, 0xde, 0x3e, 0x09, 0x84, 0xe1, 0x0e, 0x68, 0xae,
-                0x38, 0x75, 0x34, 0xb9, 0x6c, 0xde, 0x37, 0x92, 0xf1, 0x35, 0xbf, 0x5f, 0x68, 0x78,
-                0x7d, 0x37, 0x0c, 0xa8, 0xc4, 0xc4, 0x07, 0x4d, 0xc5, 0xd6, 0x01, 0xae, 0x90, 0x49,
-                0x54, 0x37, 0xc3, 0xc2, 0xd4, 0x8a, 0x3d, 0x96, 0x66, 0x83, 0xac, 0x05, 0x16, 0x0b,
-                0x7a, 0x84, 0xea, 0xa7, 0xaa, 0xb7, 0x40, 0x09, 0xe5, 0x7a, 0x85, 0xf7, 0xbf, 0x68,
-                0xa2, 0xe4, 0x82, 0x00, 0x0f, 0x82, 0x9c, 0x54, 0x50, 0x73, 0xa1, 0x5d, 0x5c, 0xd0,
-                0xfc, 0xc5, 0x74, 0x39, 0xa4, 0x35, 0x0e, 0xaf, 0x09, 0x8d, 0xfb, 0x82, 0xa0, 0x85,
-                0xea, 0x8a, 0x4a, 0xf6, 0xfa, 0x83, 0x81, 0xf0, 0x65, 0x88, 0x19, 0xea, 0xb4, 0x83,
-                0xf6, 0x5b, 0x32, 0x5d, 0x5a, 0xed, 0xa1, 0x52, 0x32, 0xcf, 0xad, 0xec, 0x75, 0xab,
-                0x18, 0x66, 0xe4, 0xc0, 0x15, 0x5a, 0x9c, 0x74, 0xa7, 0xa5, 0x7c, 0xcf, 0x34, 0xc4,
-                0x83, 0xac, 0x7d, 0xa1, 0x58, 0x8a, 0x1b, 0x6b, 0x99, 0x41, 0xf1, 0x10, 0x40, 0xf9,
-                0x4c, 0xf7, 0x8f, 0xad, 0x89, 0xbf, 0x11, 0xfe, 0xd6, 0x9a, 0xa0, 0xd8, 0x31, 0x05,
-                0xad, 0xac, 0xdd, 0x4e, 0x5f, 0x04, 0xa6, 0x24, 0x24, 0x02, 0x3c, 0x9b, 0x9e, 0x33,
-                0xc4, 0xfb, 0x7f, 0x12, 0xbd, 0xf2, 0x1f, 0x07, 0xf2, 0x65, 0xc5, 0x37, 0xd5, 0x1c,
-                0x65, 0x51, 0xf4, 0x61, 0x7b, 0x91, 0x5d, 0x21, 0x99, 0x18, 0x39, 0xc3, 0xd0, 0xd3,
-                0x63, 0x93, 0xd6, 0x46, 0xe0, 0xa8, 0xa4, 0x15, 0x09, 0x21, 0x7d, 0x0e, 0x7d, 0x2c,
-                0xa1, 0xa0, 0xa0, 0xd6, 0x77, 0xa3, 0xea, 0xca, 0x23, 0xed, 0xeb, 0x07, 0xb7, 0x4e,
-                0x65, 0x2a, 0x0b, 0xc5, 0x0c, 0x6c, 0x08, 0x3a, 0x55, 0xd6, 0xc7, 0x30, 0x6e, 0x74,
-                0x08, 0x6f, 0x47, 0x68, 0x93, 0x3a, 0xa2, 0x48, 0x73, 0x68, 0x18, 0x67, 0xa7, 0x89,
-                0x3d, 0x77, 0xcb, 0x7f, 0x29, 0xb8, 0xc8, 0x47, 0xc5, 0x83, 0xf2, 0xd0, 0x71, 0xa6,
-                0x86, 0x61, 0x6e, 0x20, 0x67, 0x19, 0xf7, 0x61, 0xae, 0x39, 0xc1, 0x10, 0x44, 0x2e,
-                0x06, 0x16, 0x3d, 0x2b, 0x84, 0x59, 0x03, 0x60, 0x69, 0x5d, 0x4e, 0x19, 0x84, 0x9e,
-                0x63, 0x4f, 0x24, 0xd9, 0xad, 0x39, 0x6c, 0x19, 0xff, 0x83, 0xce, 0x74, 0xf4, 0x6e,
-                0x64, 0x5f, 0x93, 0x2e, 0x14, 0x1a, 0x41, 0x19, 0x59, 0x36, 0xc8, 0x5d, 0x51, 0x44,
-                0x14, 0xf1, 0x12, 0xe6, 0x0b, 0x1a, 0x25, 0x37, 0xc3, 0x8d, 0x6d, 0xc6, 0xc4, 0x63,
-                0x83, 0x05, 0xc9, 0xbd, 0x6c, 0x62, 0xe3, 0x66, 0xbc, 0x63, 0x12, 0x3e, 0x3e, 0x6d,
-                0xd3, 0x6e, 0xed, 0xd3, 0x13, 0x6f, 0xce, 0x8d, 0xee, 0xca, 0x2a, 0xa0, 0x9a, 0x32,
-                0x98, 0xa3, 0x9d, 0x83, 0x85, 0x9e, 0xfc, 0x9b, 0x2b, 0x69, 0xcf, 0x9a, 0x7d, 0xee,
-                0x08, 0xa9, 0x8e, 0x4b, 0xe5, 0x58, 0xac, 0x79, 0x12, 0xfd, 0xcb, 0x42, 0x20, 0x90,
-                0x75, 0x42, 0x02, 0x60, 0xf7, 0xca, 0xd0, 0xf2, 0xc0, 0x1f, 0x2a, 0xfe, 0x33, 0x07,
-                0x3f, 0x26, 0x24, 0x9d, 0x94, 0x4f, 0x7a, 0x50, 0xdd, 0x84, 0x83, 0x9b, 0xc3, 0xea,
-                0x7f, 0xde, 0xe4, 0xed, 0x71, 0x44, 0x9c, 0xf0, 0x75, 0x33, 0xd2, 0x6e, 0x1e, 0x27,
-                0xa3, 0xef, 0xb0, 0x32, 0xc3, 0xa3, 0xb3, 0x4b, 0xd3, 0x09, 0x26, 0x22, 0xd2, 0x06,
-                0x2a, 0xe5, 0x36, 0xef, 0x51, 0x49, 0xc4, 0x9b, 0x5b, 0xc9, 0x47, 0x5e, 0xaf, 0xab,
-                0x6e, 0x67, 0x57, 0x61,
-            ],
-            c_enc: [
-                0xbc, 0x8a, 0x16, 0xfd, 0x57, 0xbc, 0x03, 0x60, 0x59, 0xe5, 0x4d, 0xc2, 0xbc, 0xfa,
-                0xad, 0x9c, 0xc1, 0xfa, 0xe8, 0xcb, 0x2b, 0xe2, 0xa0, 0xc8, 0x5e, 0x81, 0x6c, 0x67,
-                0xfd, 0xcd, 0x0b, 0x93, 0xe6, 0xa1, 0xed, 0xc8, 0x3b, 0xfa, 0xc4, 0x1e, 0xb4, 0x19,
-                0x1c, 0x56, 0x4b, 0xac, 0x58, 0x01, 0x62, 0x92, 0x2d, 0x88, 0x25, 0x30, 0x28, 0xeb,
-                0x88, 0xed, 0x46, 0xbf, 0x24, 0x2d, 0x82, 0x28, 0x6c, 0xb0, 0xa5, 0x66, 0xce, 0x01,
-                0x18, 0x09, 0x4c, 0x90, 0x8f, 0xc2, 0x68, 0xb3, 0x2b, 0xcb, 0xdc, 0x4c, 0x22, 0x82,
-                0xc5, 0x24, 0x2a, 0x65, 0x15, 0x48, 0x8b, 0x83, 0x3d, 0x29, 0x8e, 0x49, 0xda, 0x33,
-                0x3a, 0xdd, 0x96, 0xc9, 0x9b, 0x98, 0xac, 0x06, 0x7f, 0x21, 0x41, 0x28, 0x9a, 0xcd,
-                0x89, 0x49, 0x64, 0xfc, 0xf8, 0x94, 0xc9, 0x26, 0xf1, 0x81, 0xb1, 0x19, 0x85, 0x68,
-                0xb1, 0xdd, 0x6f, 0x5e, 0xd1, 0x22, 0xdc, 0x70, 0x44, 0xad, 0x96, 0x76, 0xa7, 0xc5,
-                0xae, 0x8e, 0xa9, 0x0f, 0x64, 0xbc, 0x59, 0x09, 0x36, 0xe0, 0xdf, 0x53, 0x1c, 0x1b,
-                0x94, 0xb7, 0x35, 0xcd, 0x7b, 0x18, 0x73, 0xc8, 0x51, 0x6f, 0xea, 0x83, 0x64, 0x91,
-                0x40, 0xbc, 0xbb, 0x9b, 0x42, 0xea, 0x6c, 0xb7, 0xaf, 0x67, 0xdc, 0x2d, 0xdb, 0xb4,
-                0x7a, 0xb2, 0x25, 0xe7, 0x98, 0x29, 0xcd, 0xaf, 0x77, 0x04, 0xfb, 0x56, 0x5b, 0x43,
-                0x91, 0x76, 0xf3, 0x35, 0xe4, 0x2b, 0x64, 0xc1, 0x6d, 0xdf, 0xe0, 0x88, 0x45, 0x38,
-                0xbf, 0x43, 0x33, 0xe3, 0x2c, 0xa1, 0xe6, 0x27, 0x41, 0xc3, 0xe7, 0x4c, 0x8f, 0xaa,
-                0xde, 0x0d, 0x89, 0xfa, 0x10, 0x30, 0xcd, 0x8e, 0xfd, 0x20, 0x22, 0x3e, 0x41, 0xc3,
-                0xfc, 0xca, 0xaa, 0xe7, 0x76, 0xe6, 0x8e, 0xe8, 0x40, 0x56, 0x6f, 0x4d, 0x13, 0xc1,
-                0xc9, 0xd5, 0xcb, 0xbe, 0xcf, 0xa7, 0x49, 0x9d, 0x43, 0x12, 0x7c, 0xe8, 0xfd, 0x83,
-                0xdb, 0x6e, 0x89, 0x67, 0x90, 0x32, 0x25, 0x24, 0x87, 0x21, 0x40, 0x0d, 0x5e, 0x3e,
-                0xc0, 0xc1, 0x8e, 0x10, 0xf5, 0xe6, 0x6e, 0x10, 0x17, 0x0c, 0xb3, 0x74, 0x48, 0x22,
-                0x4a, 0xde, 0x39, 0x9f, 0x1d, 0x74, 0xa2, 0x16, 0x7d, 0x9f, 0xdb, 0xfe, 0x36, 0xe1,
-                0x28, 0xe4, 0x8c, 0x01, 0x62, 0x61, 0x16, 0xc1, 0xa2, 0xdf, 0x3c, 0xb0, 0x23, 0xd8,
-                0x0a, 0xed, 0x9b, 0xfc, 0x02, 0x71, 0xb8, 0x1f, 0xf9, 0x79, 0x81, 0x01, 0x6f, 0xff,
-                0x19, 0x61, 0x08, 0x88, 0x8b, 0xcb, 0xca, 0x84, 0x5b, 0x5d, 0x97, 0x1b, 0xd5, 0x4f,
-                0x49, 0x7d, 0x3f, 0x3a, 0x09, 0x29, 0x9e, 0x56, 0x50, 0xd3, 0x26, 0xd8, 0x9b, 0x9a,
-                0x5e, 0xff, 0x3e, 0xbd, 0x27, 0x39, 0x34, 0xc4, 0x9f, 0x81, 0x46, 0x7e, 0xb8, 0x4f,
-                0x56, 0x98, 0x90, 0xcf, 0x89, 0x05, 0xb7, 0x4c, 0xd3, 0xed, 0xa6, 0x3c, 0x53, 0x88,
-                0xd5, 0x51, 0x5e, 0x3f, 0xd8, 0x1c, 0x70, 0xc1, 0x5e, 0x2a, 0x98, 0x2d, 0x59, 0x0e,
-                0x87, 0xb8, 0x64, 0x45, 0x4b, 0xcd, 0xf5, 0xf8, 0x4d, 0x9f, 0x11, 0xcb, 0x9c, 0xf2,
-                0xb5, 0xde, 0x3c, 0x5e, 0x0e, 0x2a, 0x6c, 0x48, 0x16, 0x61, 0x64, 0x96, 0x6f, 0xb9,
-                0x0d, 0xac, 0xf8, 0x67, 0x4f, 0x9f, 0x1a, 0x34, 0xd2, 0xcd, 0xc7, 0xc9, 0x48, 0xab,
-                0x99, 0xc3, 0x58, 0xa1, 0x95, 0x47, 0x0a, 0xdd, 0x06, 0x5e, 0xaf, 0x79, 0x24, 0xfa,
-                0xed, 0x63, 0x27, 0xa6, 0x10, 0xf5, 0x2e, 0xd5, 0xd3, 0xa8, 0x7e, 0x11, 0xb5, 0x97,
-                0x4f, 0xa0, 0x60, 0x45, 0xa4, 0x08, 0x95, 0xcd, 0xad, 0x60, 0x1c, 0xae, 0x01, 0xed,
-                0xda, 0x17, 0x52, 0x81, 0x62, 0xd7, 0x21, 0x24, 0xf2, 0x05, 0x6b, 0x9a, 0xb8, 0xc0,
-                0xc0, 0xf5, 0xc6, 0xdd, 0xaa, 0x0f, 0x5e, 0x33, 0xfb, 0x04, 0x23, 0x0b, 0x61, 0x1b,
-                0xff, 0xd8, 0xbd, 0xdc, 0x63, 0x4c, 0x79, 0x60, 0xa3, 0xd4, 0xe6, 0x8f, 0x21, 0xe7,
-                0x83, 0x04, 0xe4, 0xc4, 0xd2, 0xdc, 0xd6, 0xa1, 0x9c, 0xfc, 0x04, 0x57, 0x97, 0x09,
-                0xf0, 0x33, 0xf1, 0x95, 0x78, 0xae, 0x7f, 0x0b, 0xc6, 0x46, 0x32, 0xa6, 0xd7, 0xda,
-                0x40, 0xdc, 0x0c, 0x38, 0x3b, 0xca, 0xa8, 0x68, 0x6a, 0xc8, 0x49, 0x3b, 0x2c, 0xb8,
-                0xf1, 0xd7, 0xd3, 0x95, 0x8a, 0x54,
-            ],
-            ock: [
-                0x9c, 0xba, 0xd2, 0xf3, 0x8b, 0xf8, 0x8f, 0x39, 0x47, 0xce, 0xf6, 0x4d, 0xe7, 0xa6,
-                0xf4, 0x3e, 0x4c, 0xbb, 0x41, 0xe6, 0xe0, 0x37, 0xf1, 0x42, 0x01, 0xae, 0xe8, 0xab,
-                0xfd, 0xf8, 0xa2, 0x35,
-            ],
-            op: [
-                0x84, 0xda, 0x49, 0x6b, 0x16, 0x0a, 0x81, 0x72, 0xc4, 0x8d, 0x76, 0xb4, 0xfb, 0x08,
-                0xbc, 0xab, 0xf4, 0x0f, 0xf1, 0xe4, 0x2c, 0x48, 0x66, 0x77, 0x57, 0x4f, 0x9e, 0xf8,
-                0x36, 0x34, 0xb0, 0x23, 0x1b, 0x52, 0x63, 0x2d, 0x2a, 0x8d, 0x58, 0xd1, 0x63, 0x57,
-                0xa9, 0x19, 0xa2, 0x06, 0x31, 0xe2, 0x91, 0x14, 0xc8, 0x60, 0x07, 0xa2, 0xb1, 0x8b,
-                0x25, 0xec, 0xff, 0x47, 0x72, 0x16, 0x8c, 0x05,
-            ],
-            c_out: [
-                0xf6, 0x25, 0xcd, 0x3d, 0x19, 0x97, 0xb0, 0xd3, 0xf2, 0x29, 0x5a, 0xac, 0xc0, 0x3a,
-                0xe0, 0xc9, 0x47, 0x28, 0xb3, 0x3c, 0xc4, 0xf1, 0x6f, 0xd4, 0x28, 0xd6, 0x5f, 0x3c,
-                0x78, 0x5e, 0x8c, 0x0b, 0xb4, 0x66, 0xc1, 0x33, 0xd4, 0x83, 0xdf, 0xc5, 0xb1, 0xb3,
-                0x15, 0x1d, 0xa2, 0xd5, 0xf2, 0x4a, 0x2b, 0x32, 0x0d, 0x8e, 0x9c, 0xd3, 0x41, 0x5c,
-                0x25, 0xb6, 0xf9, 0x76, 0x1f, 0x42, 0x70, 0x04, 0xce, 0xe5, 0x4f, 0x75, 0xf1, 0x25,
-                0xbc, 0x50, 0x5e, 0xf6, 0x26, 0xef, 0xc9, 0xdd, 0x63, 0x66,
-            ],
-            asset: Some([
-                0xa6, 0x33, 0x05, 0x44, 0xe5, 0x46, 0x39, 0xb5, 0x41, 0x87, 0x01, 0xff, 0x4c, 0xc4,
-                0x5a, 0x31, 0xf6, 0x2e, 0xdd, 0x84, 0x3d, 0xbb, 0xdc, 0x5a, 0xa7, 0x27, 0xab, 0x79,
-                0xb4, 0x42, 0x68, 0x3c,
-            ]),
-        },
-        TestVector {
-            incoming_viewing_key: [
-                0x47, 0x30, 0x68, 0xbf, 0x68, 0xe5, 0x0b, 0xe3, 0x85, 0x7d, 0xec, 0xb2, 0xef, 0xd5,
-                0xde, 0x20, 0xea, 0xc8, 0x1b, 0x37, 0x5b, 0xd0, 0xbb, 0xe8, 0x36, 0x86, 0x6e, 0x99,
-                0x36, 0x3b, 0x37, 0x50, 0x9d, 0x53, 0x8f, 0xcc, 0xa9, 0x33, 0x37, 0xad, 0xbc, 0x24,
-                0x81, 0xe2, 0x70, 0x26, 0x18, 0x4c, 0x3f, 0x4f, 0x48, 0xcc, 0x5d, 0x5a, 0x0e, 0x4a,
-                0x4c, 0xfa, 0x4d, 0x6a, 0x24, 0x7f, 0x2e, 0x39,
-            ],
-            ovk: [
-                0x25, 0xb4, 0xc2, 0x6e, 0xb0, 0x3f, 0x71, 0x66, 0x46, 0x61, 0x9a, 0xf0, 0x24, 0x56,
-                0xae, 0x69, 0x59, 0x62, 0xfe, 0x5e, 0x93, 0x1a, 0x63, 0xb5, 0xc7, 0x90, 0x52, 0xec,
-                0xd3, 0x33, 0xe1, 0x84,
-            ],
-            default_d: [
-                0x61, 0x5f, 0x53, 0x89, 0x1a, 0x18, 0xe0, 0x52, 0x17, 0x2d, 0x81,
-            ],
-            default_pk_d: [
-                0x04, 0x47, 0x12, 0x42, 0xe1, 0xf4, 0x2b, 0xf0, 0x81, 0xf0, 0x8e, 0x9d, 0x71, 0xfe,
-                0x4f, 0x3a, 0x65, 0x91, 0xa7, 0xc0, 0x1e, 0xe2, 0xcf, 0x35, 0x30, 0x2f, 0x38, 0xd3,
-                0x34, 0xeb, 0x90, 0x2c,
-            ],
-            v: 15119422206032203650,
-            rseed: [
-                0x45, 0x60, 0x3a, 0x53, 0x46, 0x2c, 0x60, 0xe1, 0xf6, 0xcb, 0x0c, 0x9c, 0xa0, 0x39,
-                0x0c, 0x48, 0x82, 0x24, 0xc3, 0x13, 0x26, 0x9f, 0xcd, 0x59, 0xfc, 0xb6, 0x11, 0xfb,
-                0x2d, 0x9b, 0x4c, 0x8f,
-            ],
-            memo: [
-                0xff, 0xa6, 0x01, 0xbb, 0x1c, 0xb8, 0xd0, 0x7d, 0x79, 0x7b, 0xf5, 0xde, 0x52, 0xbc,
-                0xee, 0xb0, 0x23, 0x01, 0xc8, 0x96, 0x2a, 0xc1, 0xfc, 0x04, 0x91, 0xdc, 0x81, 0xaf,
-                0xfd, 0x6c, 0x1e, 0xbf, 0x89, 0xa1, 0x3d, 0x6f, 0x29, 0x0e, 0xda, 0x5d, 0x5c, 0xef,
-                0x38, 0x22, 0x15, 0xc5, 0xe9, 0x51, 0xd7, 0x13, 0x05, 0xef, 0x33, 0xd9, 0x73, 0x71,
-                0x26, 0xd0, 0xe6, 0x62, 0x90, 0x5f, 0x12, 0x50, 0x92, 0x6f, 0x6a, 0x22, 0x99, 0x90,
-                0xe3, 0x8f, 0x69, 0xad, 0x9a, 0x91, 0x92, 0xb3, 0x02, 0xf2, 0x6b, 0xdd, 0xa4, 0x65,
-                0xd9, 0x0b, 0x94, 0xb1, 0x2c, 0x57, 0xfa, 0x3f, 0xd6, 0x93, 0x00, 0x83, 0xf1, 0x84,
-                0x43, 0x8d, 0x8a, 0x88, 0x9d, 0x3f, 0x5e, 0xce, 0xa2, 0xc6, 0xd2, 0x3d, 0x67, 0x36,
-                0xf2, 0xa0, 0xf1, 0x8e, 0x26, 0xf4, 0xfa, 0x45, 0xd1, 0xbe, 0x8f, 0x3d, 0xc4, 0xa7,
-                0x07, 0x13, 0x7e, 0x95, 0xd2, 0xad, 0x59, 0x4f, 0x6c, 0x03, 0xd2, 0x49, 0x23, 0x06,
-                0x7a, 0xe4, 0x7f, 0xd6, 0x42, 0x5e, 0xfb, 0x9c, 0x1d, 0x50, 0x4e, 0x6f, 0xd5, 0x57,
-                0x53, 0x40, 0x94, 0x56, 0x01, 0xfe, 0x80, 0x6f, 0x57, 0x56, 0xac, 0xb5, 0x62, 0xf1,
-                0x3c, 0x0c, 0xa1, 0xd8, 0x03, 0xa1, 0x95, 0xc2, 0xeb, 0xb2, 0xef, 0x02, 0xac, 0x33,
-                0xe6, 0xa8, 0x8d, 0xea, 0x07, 0x5b, 0xa9, 0x96, 0xd3, 0xc3, 0x36, 0x64, 0x8e, 0x86,
-                0x94, 0xd3, 0xa1, 0x9d, 0x3d, 0xca, 0x53, 0x1b, 0xeb, 0x50, 0xd4, 0x32, 0x7c, 0x5c,
-                0x0c, 0x23, 0xcb, 0x7c, 0xfd, 0xb0, 0x8c, 0xa7, 0xcf, 0x2c, 0xac, 0x6b, 0xc1, 0x39,
-                0xd0, 0x74, 0x14, 0x73, 0xd3, 0x76, 0x02, 0x9c, 0xb4, 0xab, 0x6b, 0xf0, 0x54, 0x55,
-                0x7c, 0xe2, 0x94, 0xc7, 0x28, 0xa4, 0x68, 0x7d, 0x57, 0xec, 0x89, 0x09, 0xff, 0x51,
-                0xa4, 0xd0, 0x2f, 0x9d, 0xcd, 0x11, 0x19, 0x3d, 0x7d, 0x1c, 0x9f, 0xda, 0xe6, 0xa1,
-                0x73, 0x96, 0xa1, 0xbf, 0x57, 0xa9, 0x94, 0x93, 0x4f, 0x5e, 0x7a, 0x59, 0xf0, 0x45,
-                0xde, 0xbe, 0xaf, 0xf6, 0x2e, 0xf3, 0x26, 0xb9, 0x47, 0xf2, 0xa8, 0xb4, 0x95, 0x55,
-                0xe4, 0xd9, 0x9b, 0x3b, 0xf5, 0xc8, 0x1f, 0xf9, 0xfe, 0x31, 0x4e, 0x04, 0x7a, 0xf1,
-                0x52, 0x50, 0x8f, 0x57, 0x01, 0x5c, 0xa4, 0x02, 0xc6, 0x7d, 0x92, 0x5c, 0x99, 0xac,
-                0xea, 0x3e, 0xe8, 0xcc, 0x4b, 0x00, 0x8c, 0x5c, 0xb4, 0x39, 0x66, 0xe7, 0x14, 0xef,
-                0x48, 0x0f, 0xd0, 0x5e, 0x07, 0xc7, 0xb2, 0xdd, 0xa9, 0xaa, 0x39, 0x66, 0x11, 0x3e,
-                0xaa, 0x29, 0x3d, 0x3f, 0x62, 0x2b, 0x30, 0x9d, 0x64, 0x80, 0x3c, 0xe1, 0xe6, 0x37,
-                0x8b, 0x6a, 0xac, 0x4f, 0xab, 0x52, 0x7c, 0x43, 0xcd, 0x45, 0xed, 0x0a, 0x3c, 0x1a,
-                0x4b, 0x9f, 0xb1, 0x8d, 0xcc, 0xcf, 0xcd, 0xb6, 0xac, 0x0c, 0x24, 0x21, 0x63, 0x9c,
-                0xda, 0x00, 0x75, 0xa2, 0x0d, 0xc5, 0x11, 0x1b, 0x8d, 0x3d, 0x31, 0x99, 0x49, 0x5b,
-                0xd9, 0x13, 0x3d, 0xba, 0xb9, 0x45, 0x41, 0x41, 0x0e, 0x4f, 0xba, 0x92, 0xc7, 0xb6,
-                0x06, 0xa5, 0xcb, 0x12, 0x2f, 0x14, 0x0c, 0xf1, 0xa3, 0x59, 0x6f, 0x27, 0x88, 0xf3,
-                0xc8, 0xb9, 0x26, 0x60, 0xf1, 0x4c, 0xb6, 0x5a, 0xf5, 0xdd, 0x23, 0xdf, 0xdb, 0xac,
-                0x13, 0x71, 0xec, 0xf4, 0xb3, 0x37, 0x12, 0xfe, 0xd2, 0x29, 0x2c, 0x44, 0xf7, 0x08,
-                0x34, 0xcf, 0x96, 0xc0, 0x5d, 0x58, 0x82, 0x7e, 0x69, 0xbf, 0xc2, 0xe6, 0x96, 0xfa,
-                0x08, 0x74, 0x86, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ],
-            cv_net: [
-                0x45, 0x37, 0x85, 0x3e, 0x18, 0xac, 0x2c, 0xe9, 0x37, 0x79, 0x8c, 0x9b, 0xce, 0xa9,
-                0x80, 0x2d, 0x65, 0x00, 0x74, 0xdb, 0xd7, 0xe0, 0x6a, 0x48, 0x98, 0x03, 0x15, 0x30,
-                0x78, 0xe9, 0x97, 0x0b,
-            ],
-            rho: [
-                0x9a, 0xd0, 0x7f, 0x1c, 0x28, 0x7b, 0xdd, 0x53, 0x4f, 0x6f, 0x7e, 0xae, 0x08, 0xf7,
-                0x85, 0x72, 0xa3, 0x05, 0xfa, 0x3b, 0x70, 0x68, 0xa3, 0x78, 0x38, 0x27, 0xaf, 0xe2,
-                0x14, 0x7a, 0x27, 0x10,
-            ],
-            cmx: [
-                0xf2, 0x04, 0x22, 0x51, 0xa0, 0x59, 0xa2, 0xf5, 0x8a, 0xb8, 0xe9, 0x0b, 0x52, 0x64,
-                0xd0, 0xa4, 0x3f, 0x96, 0xd7, 0x7e, 0xdd, 0x54, 0xf8, 0x0f, 0xf4, 0x9d, 0x43, 0x86,
-                0x81, 0x4d, 0x73, 0x2e,
-            ],
-            esk: [
-                0xb5, 0x9a, 0x18, 0x4d, 0x24, 0xe6, 0x1b, 0x9f, 0x9d, 0x37, 0x1d, 0xa4, 0xb1, 0x44,
-                0x01, 0x72, 0x02, 0x9a, 0x2e, 0xbc, 0x0a, 0x2a, 0xbe, 0xb8, 0xaf, 0x2b, 0xd1, 0xa0,
-                0x8c, 0x67, 0xd9, 0x3f,
-            ],
-            ephemeral_key: [
-                0x46, 0x73, 0x1f, 0xff, 0xc5, 0x9a, 0xf4, 0xc1, 0x28, 0x82, 0xbc, 0xca, 0xea, 0xa7,
-                0xb8, 0xed, 0x39, 0x0b, 0x14, 0x66, 0x72, 0xe1, 0x36, 0x51, 0xc3, 0x2e, 0x57, 0x80,
-                0x62, 0x68, 0x65, 0xa7,
-            ],
-            shared_secret: [
-                0x9d, 0x56, 0xbd, 0x96, 0x00, 0x39, 0x62, 0x5e, 0x11, 0x7d, 0x7b, 0xfe, 0xd4, 0x3a,
-                0x57, 0x3b, 0x11, 0x51, 0x7f, 0xfa, 0x76, 0x14, 0xea, 0x2d, 0xa7, 0x7e, 0xdf, 0x62,
-                0x7f, 0x6f, 0x13, 0xaa,
-            ],
-            k_enc: [
-                0x04, 0x2f, 0x92, 0x82, 0x13, 0x44, 0xde, 0x97, 0x7c, 0xee, 0x89, 0x9e, 0xd2, 0x1b,
-                0xc8, 0x48, 0xf5, 0xc4, 0xfe, 0xdc, 0x39, 0xf2, 0xdf, 0xed, 0xad, 0x62, 0xcc, 0x7a,
-                0x92, 0x7f, 0x74, 0xfd,
-            ],
-            p_enc: [
-                0x03, 0x61, 0x5f, 0x53, 0x89, 0x1a, 0x18, 0xe0, 0x52, 0x17, 0x2d, 0x81, 0x82, 0xcf,
-                0xb3, 0xe7, 0x63, 0xfa, 0xd2, 0xd1, 0x45, 0x60, 0x3a, 0x53, 0x46, 0x2c, 0x60, 0xe1,
-                0xf6, 0xcb, 0x0c, 0x9c, 0xa0, 0x39, 0x0c, 0x48, 0x82, 0x24, 0xc3, 0x13, 0x26, 0x9f,
-                0xcd, 0x59, 0xfc, 0xb6, 0x11, 0xfb, 0x2d, 0x9b, 0x4c, 0x8f, 0x61, 0x16, 0xcf, 0xec,
-                0x26, 0x47, 0xcc, 0xaa, 0xe1, 0xc7, 0x4b, 0x41, 0x6f, 0x3e, 0x6a, 0xe8, 0xf7, 0xcc,
-                0x60, 0xea, 0xaf, 0x7b, 0x6a, 0x59, 0x0d, 0x51, 0x54, 0x41, 0x38, 0xe1, 0x73, 0x29,
-                0xff, 0xa6, 0x01, 0xbb, 0x1c, 0xb8, 0xd0, 0x7d, 0x79, 0x7b, 0xf5, 0xde, 0x52, 0xbc,
-                0xee, 0xb0, 0x23, 0x01, 0xc8, 0x96, 0x2a, 0xc1, 0xfc, 0x04, 0x91, 0xdc, 0x81, 0xaf,
-                0xfd, 0x6c, 0x1e, 0xbf, 0x89, 0xa1, 0x3d, 0x6f, 0x29, 0x0e, 0xda, 0x5d, 0x5c, 0xef,
-                0x38, 0x22, 0x15, 0xc5, 0xe9, 0x51, 0xd7, 0x13, 0x05, 0xef, 0x33, 0xd9, 0x73, 0x71,
-                0x26, 0xd0, 0xe6, 0x62, 0x90, 0x5f, 0x12, 0x50, 0x92, 0x6f, 0x6a, 0x22, 0x99, 0x90,
-                0xe3, 0x8f, 0x69, 0xad, 0x9a, 0x91, 0x92, 0xb3, 0x02, 0xf2, 0x6b, 0xdd, 0xa4, 0x65,
-                0xd9, 0x0b, 0x94, 0xb1, 0x2c, 0x57, 0xfa, 0x3f, 0xd6, 0x93, 0x00, 0x83, 0xf1, 0x84,
-                0x43, 0x8d, 0x8a, 0x88, 0x9d, 0x3f, 0x5e, 0xce, 0xa2, 0xc6, 0xd2, 0x3d, 0x67, 0x36,
-                0xf2, 0xa0, 0xf1, 0x8e, 0x26, 0xf4, 0xfa, 0x45, 0xd1, 0xbe, 0x8f, 0x3d, 0xc4, 0xa7,
-                0x07, 0x13, 0x7e, 0x95, 0xd2, 0xad, 0x59, 0x4f, 0x6c, 0x03, 0xd2, 0x49, 0x23, 0x06,
-                0x7a, 0xe4, 0x7f, 0xd6, 0x42, 0x5e, 0xfb, 0x9c, 0x1d, 0x50, 0x4e, 0x6f, 0xd5, 0x57,
-                0x53, 0x40, 0x94, 0x56, 0x01, 0xfe, 0x80, 0x6f, 0x57, 0x56, 0xac, 0xb5, 0x62, 0xf1,
-                0x3c, 0x0c, 0xa1, 0xd8, 0x03, 0xa1, 0x95, 0xc2, 0xeb, 0xb2, 0xef, 0x02, 0xac, 0x33,
-                0xe6, 0xa8, 0x8d, 0xea, 0x07, 0x5b, 0xa9, 0x96, 0xd3, 0xc3, 0x36, 0x64, 0x8e, 0x86,
-                0x94, 0xd3, 0xa1, 0x9d, 0x3d, 0xca, 0x53, 0x1b, 0xeb, 0x50, 0xd4, 0x32, 0x7c, 0x5c,
-                0x0c, 0x23, 0xcb, 0x7c, 0xfd, 0xb0, 0x8c, 0xa7, 0xcf, 0x2c, 0xac, 0x6b, 0xc1, 0x39,
-                0xd0, 0x74, 0x14, 0x73, 0xd3, 0x76, 0x02, 0x9c, 0xb4, 0xab, 0x6b, 0xf0, 0x54, 0x55,
-                0x7c, 0xe2, 0x94, 0xc7, 0x28, 0xa4, 0x68, 0x7d, 0x57, 0xec, 0x89, 0x09, 0xff, 0x51,
-                0xa4, 0xd0, 0x2f, 0x9d, 0xcd, 0x11, 0x19, 0x3d, 0x7d, 0x1c, 0x9f, 0xda, 0xe6, 0xa1,
-                0x73, 0x96, 0xa1, 0xbf, 0x57, 0xa9, 0x94, 0x93, 0x4f, 0x5e, 0x7a, 0x59, 0xf0, 0x45,
-                0xde, 0xbe, 0xaf, 0xf6, 0x2e, 0xf3, 0x26, 0xb9, 0x47, 0xf2, 0xa8, 0xb4, 0x95, 0x55,
-                0xe4, 0xd9, 0x9b, 0x3b, 0xf5, 0xc8, 0x1f, 0xf9, 0xfe, 0x31, 0x4e, 0x04, 0x7a, 0xf1,
-                0x52, 0x50, 0x8f, 0x57, 0x01, 0x5c, 0xa4, 0x02, 0xc6, 0x7d, 0x92, 0x5c, 0x99, 0xac,
-                0xea, 0x3e, 0xe8, 0xcc, 0x4b, 0x00, 0x8c, 0x5c, 0xb4, 0x39, 0x66, 0xe7, 0x14, 0xef,
-                0x48, 0x0f, 0xd0, 0x5e, 0x07, 0xc7, 0xb2, 0xdd, 0xa9, 0xaa, 0x39, 0x66, 0x11, 0x3e,
-                0xaa, 0x29, 0x3d, 0x3f, 0x62, 0x2b, 0x30, 0x9d, 0x64, 0x80, 0x3c, 0xe1, 0xe6, 0x37,
-                0x8b, 0x6a, 0xac, 0x4f, 0xab, 0x52, 0x7c, 0x43, 0xcd, 0x45, 0xed, 0x0a, 0x3c, 0x1a,
-                0x4b, 0x9f, 0xb1, 0x8d, 0xcc, 0xcf, 0xcd, 0xb6, 0xac, 0x0c, 0x24, 0x21, 0x63, 0x9c,
-                0xda, 0x00, 0x75, 0xa2, 0x0d, 0xc5, 0x11, 0x1b, 0x8d, 0x3d, 0x31, 0x99, 0x49, 0x5b,
-                0xd9, 0x13, 0x3d, 0xba, 0xb9, 0x45, 0x41, 0x41, 0x0e, 0x4f, 0xba, 0x92, 0xc7, 0xb6,
-                0x06, 0xa5, 0xcb, 0x12, 0x2f, 0x14, 0x0c, 0xf1, 0xa3, 0x59, 0x6f, 0x27, 0x88, 0xf3,
-                0xc8, 0xb9, 0x26, 0x60, 0xf1, 0x4c, 0xb6, 0x5a, 0xf5, 0xdd, 0x23, 0xdf, 0xdb, 0xac,
-                0x13, 0x71, 0xec, 0xf4, 0xb3, 0x37, 0x12, 0xfe, 0xd2, 0x29, 0x2c, 0x44, 0xf7, 0x08,
-                0x34, 0xcf, 0x96, 0xc0, 0x5d, 0x58, 0x82, 0x7e, 0x69, 0xbf, 0xc2, 0xe6, 0x96, 0xfa,
-                0x08, 0x74, 0x86, 0x9c,
-            ],
-            c_enc: [
-                0x16, 0x76, 0x72, 0x3a, 0x18, 0xff, 0x58, 0x77, 0x70, 0x15, 0x8d, 0x6b, 0x85, 0x09,
-                0x3c, 0x49, 0x20, 0x16, 0xf8, 0x7e, 0xc3, 0xfa, 0xe8, 0xb0, 0xb4, 0x7c, 0xd9, 0x29,
-                0x8f, 0xa2, 0x07, 0xc4, 0xb6, 0x09, 0xc6, 0x92, 0xdd, 0xb9, 0x10, 0x19, 0x72, 0xc9,
-                0x4c, 0x71, 0x87, 0x84, 0x85, 0x42, 0x1e, 0xfb, 0x70, 0x1c, 0xf5, 0x15, 0xa2, 0x3f,
-                0xbf, 0x36, 0xfe, 0x93, 0x54, 0x0d, 0x82, 0xd6, 0x9a, 0x72, 0x62, 0x4e, 0x25, 0x4f,
-                0xe3, 0xa0, 0x11, 0xc5, 0xdb, 0xdb, 0xd2, 0xbd, 0xff, 0xb8, 0x83, 0x8a, 0xf3, 0x7d,
-                0x03, 0xce, 0x69, 0x12, 0x6b, 0x2f, 0x68, 0x21, 0x25, 0xb7, 0xa9, 0xb2, 0xa3, 0xee,
-                0x11, 0x8a, 0xe5, 0xad, 0xb4, 0x60, 0xa4, 0x68, 0x7c, 0x24, 0x30, 0x18, 0x7b, 0xfd,
-                0x0f, 0x6c, 0x2a, 0x3d, 0x5d, 0x74, 0x30, 0x1c, 0xbd, 0x8f, 0xd0, 0x26, 0xc8, 0x64,
-                0x4f, 0xbf, 0xa2, 0x65, 0x69, 0x88, 0xe9, 0x58, 0x59, 0x0b, 0x81, 0x6a, 0x1e, 0x64,
-                0x0e, 0x46, 0x71, 0x0e, 0x46, 0xfa, 0x15, 0x94, 0xff, 0x2a, 0x61, 0xd6, 0xf6, 0xe7,
-                0xb4, 0xa9, 0xf6, 0xe0, 0xde, 0x68, 0x3d, 0x95, 0xe5, 0x9d, 0x43, 0x57, 0xf7, 0x9a,
-                0xc4, 0x93, 0x86, 0x6d, 0xab, 0x06, 0x57, 0x76, 0xc0, 0xb1, 0x43, 0x6b, 0x8e, 0x04,
-                0x47, 0x68, 0x43, 0xc2, 0x8b, 0x48, 0x45, 0xea, 0xff, 0x17, 0x83, 0xa8, 0x50, 0xc2,
-                0x4a, 0x90, 0x65, 0xc3, 0x36, 0x51, 0xc4, 0xb3, 0xdd, 0x19, 0x92, 0xf4, 0xf2, 0x08,
-                0xb8, 0x51, 0xbf, 0xff, 0xe9, 0xb7, 0xbb, 0x7a, 0xad, 0x76, 0x7c, 0x23, 0x60, 0xb0,
-                0x5c, 0x11, 0x23, 0x09, 0x66, 0xda, 0x55, 0x7e, 0x31, 0x3a, 0xe6, 0x1c, 0x95, 0x42,
-                0x97, 0x66, 0x10, 0x6b, 0x4b, 0x1b, 0x35, 0x47, 0x64, 0xe4, 0xe1, 0xe4, 0xdf, 0x90,
-                0xc1, 0x2d, 0x24, 0x37, 0x9d, 0x67, 0xba, 0xc6, 0x66, 0x97, 0xaf, 0x23, 0x44, 0x97,
-                0xf2, 0xd6, 0xf9, 0xa6, 0x12, 0x85, 0x0d, 0xd7, 0x1d, 0x1c, 0x98, 0xce, 0x65, 0xd8,
-                0x50, 0x7f, 0xa3, 0x46, 0x35, 0x83, 0x12, 0x39, 0xe2, 0x10, 0xf7, 0xdb, 0xb3, 0x05,
-                0x04, 0x2d, 0x47, 0x50, 0xd9, 0x5a, 0xdf, 0xff, 0xc9, 0x8d, 0xeb, 0x0f, 0x17, 0x13,
-                0xbc, 0x01, 0xaf, 0x5d, 0xb5, 0x99, 0x29, 0x89, 0x76, 0xab, 0xba, 0xdb, 0x0f, 0x4d,
-                0xed, 0x1a, 0x2f, 0xe4, 0xcf, 0x90, 0x60, 0x0e, 0x0d, 0x28, 0xd3, 0x07, 0xc6, 0x41,
-                0xf7, 0x52, 0x3c, 0x16, 0x66, 0x40, 0x1d, 0x78, 0x6f, 0xd2, 0x4a, 0xe1, 0x68, 0x0f,
-                0xe9, 0x26, 0x70, 0x4c, 0xb6, 0xe2, 0xaf, 0x80, 0x1a, 0x0d, 0x82, 0x75, 0x9d, 0xd8,
-                0x7a, 0x8c, 0xd8, 0x7b, 0x85, 0xbb, 0x07, 0x51, 0xa7, 0x08, 0xc9, 0xf4, 0xa7, 0xd3,
-                0x24, 0xe5, 0xc9, 0x3a, 0xd2, 0x2b, 0x86, 0x43, 0xdf, 0xfa, 0x5f, 0x50, 0x79, 0xfc,
-                0x6f, 0x01, 0x6d, 0x94, 0x3c, 0x99, 0x09, 0x27, 0x5c, 0x96, 0xf5, 0xfe, 0x7b, 0x56,
-                0x33, 0x3c, 0x24, 0x01, 0x99, 0x73, 0xd9, 0x4f, 0x06, 0xeb, 0xf6, 0xc0, 0xf6, 0xef,
-                0xdd, 0x42, 0xea, 0xb0, 0x63, 0x49, 0xd5, 0xe8, 0xb9, 0x60, 0xba, 0x8c, 0x68, 0xee,
-                0xfd, 0x44, 0x49, 0x99, 0xf6, 0xfa, 0x3d, 0x6a, 0x3a, 0xe3, 0x1a, 0xe8, 0x54, 0x6e,
-                0xdc, 0x62, 0x78, 0x25, 0x63, 0x7e, 0x1e, 0x86, 0x39, 0x8d, 0x0e, 0xd3, 0xd8, 0x8b,
-                0xfa, 0xea, 0x8b, 0x4b, 0x08, 0x50, 0xd8, 0xa8, 0x28, 0x6e, 0xa9, 0xf3, 0xd1, 0x3f,
-                0xa8, 0xf4, 0x16, 0x53, 0x45, 0x1b, 0x97, 0xb3, 0x8b, 0x06, 0x3a, 0x5f, 0xc6, 0xdb,
-                0xe4, 0xe9, 0x19, 0x94, 0x87, 0xc9, 0x73, 0xef, 0x8f, 0x2c, 0x26, 0x3f, 0x85, 0x05,
-                0xf4, 0xc3, 0xbe, 0xc9, 0xd1, 0x79, 0xbb, 0xd6, 0x5d, 0x1e, 0xdc, 0x58, 0x95, 0xa1,
-                0x6c, 0xc7, 0x98, 0x6b, 0xcf, 0xc4, 0xba, 0xe8, 0x7e, 0xc0, 0xb2, 0x9b, 0xf1, 0xb3,
-                0x97, 0x61, 0x5c, 0x95, 0x13, 0xfa, 0x52, 0xeb, 0xe1, 0xe9, 0xfc, 0xfb, 0xf1, 0x92,
-                0xed, 0x49, 0x26, 0x27, 0x27, 0xa0, 0x8a, 0xd3, 0xc2, 0x95, 0x5b, 0x3d, 0xf2, 0xee,
-                0xad, 0x30, 0x24, 0x3e, 0x06, 0x66, 0xf2, 0x3c, 0x7f, 0x97, 0xe7, 0x84, 0xbe, 0x68,
-                0xcc, 0x22, 0xca, 0x1d, 0x09, 0xd5,
-            ],
-            ock: [
-                0x97, 0x9b, 0x31, 0x5d, 0x3e, 0x1f, 0x5c, 0xa1, 0x8a, 0x92, 0x86, 0xd9, 0x2c, 0xc8,
-                0x8e, 0x63, 0x62, 0x4b, 0x39, 0x9b, 0x29, 0x19, 0xbf, 0x4e, 0x67, 0xda, 0x7c, 0xd3,
-                0x94, 0xf4, 0x5c, 0x49,
-            ],
-            op: [
-                0x04, 0x47, 0x12, 0x42, 0xe1, 0xf4, 0x2b, 0xf0, 0x81, 0xf0, 0x8e, 0x9d, 0x71, 0xfe,
-                0x4f, 0x3a, 0x65, 0x91, 0xa7, 0xc0, 0x1e, 0xe2, 0xcf, 0x35, 0x30, 0x2f, 0x38, 0xd3,
-                0x34, 0xeb, 0x90, 0x2c, 0xb5, 0x9a, 0x18, 0x4d, 0x24, 0xe6, 0x1b, 0x9f, 0x9d, 0x37,
-                0x1d, 0xa4, 0xb1, 0x44, 0x01, 0x72, 0x02, 0x9a, 0x2e, 0xbc, 0x0a, 0x2a, 0xbe, 0xb8,
-                0xaf, 0x2b, 0xd1, 0xa0, 0x8c, 0x67, 0xd9, 0x3f,
-            ],
-            c_out: [
-                0x83, 0xf7, 0xa1, 0xda, 0x72, 0x4d, 0xd1, 0x54, 0xe7, 0xd9, 0x47, 0xc0, 0xfc, 0x83,
-                0x42, 0x87, 0xf3, 0x3c, 0xd4, 0xb3, 0x4a, 0xfa, 0xc0, 0xda, 0x55, 0xe4, 0x37, 0xaf,
-                0xae, 0x67, 0xa9, 0x9c, 0xbd, 0x89, 0x75, 0xc9, 0x54, 0xcf, 0x41, 0xaa, 0x1e, 0x9a,
-                0x8f, 0x99, 0x98, 0x3d, 0x58, 0x6f, 0x5e, 0x35, 0x37, 0xda, 0xb7, 0x2a, 0xe1, 0x82,
-                0x7a, 0xa5, 0xdf, 0xc9, 0xdd, 0xad, 0x06, 0x26, 0x78, 0x84, 0x6f, 0xf8, 0x09, 0x3d,
-                0xfd, 0x15, 0xf6, 0x3d, 0x47, 0xe5, 0xa3, 0xbb, 0x74, 0x39,
-            ],
-            asset: Some([
-                0x61, 0x16, 0xcf, 0xec, 0x26, 0x47, 0xcc, 0xaa, 0xe1, 0xc7, 0x4b, 0x41, 0x6f, 0x3e,
-                0x6a, 0xe8, 0xf7, 0xcc, 0x60, 0xea, 0xaf, 0x7b, 0x6a, 0x59, 0x0d, 0x51, 0x54, 0x41,
-                0x38, 0xe1, 0x73, 0x29,
-            ]),
-        },
-        TestVector {
-            incoming_viewing_key: [
-                0xfc, 0x8c, 0x64, 0x1c, 0x0b, 0x28, 0xbe, 0xbf, 0x85, 0x24, 0x25, 0xae, 0x95, 0x5f,
-                0xe6, 0x40, 0x1c, 0xfd, 0x9e, 0x60, 0x63, 0xf2, 0x50, 0x11, 0x3d, 0xa0, 0xb5, 0x8b,
-                0x2a, 0x0f, 0x49, 0xb9, 0x12, 0x0b, 0x89, 0x9f, 0x08, 0x10, 0x6b, 0x30, 0x86, 0xb2,
-                0xf4, 0x11, 0x63, 0x6f, 0x50, 0xab, 0x48, 0x7c, 0xfb, 0x28, 0x81, 0x89, 0x77, 0x8f,
-                0xe4, 0xe5, 0xa1, 0x91, 0x8b, 0x98, 0xd5, 0x0a,
-            ],
-            ovk: [
-                0xbe, 0xd1, 0x7d, 0xf5, 0xf8, 0x88, 0xc8, 0xca, 0x14, 0x67, 0xae, 0x17, 0xdb, 0xbc,
-                0xde, 0x31, 0xc1, 0x10, 0x5c, 0xb5, 0xbd, 0xa8, 0x8a, 0xc6, 0xc6, 0x27, 0x00, 0x2c,
-                0xe2, 0x1c, 0x02, 0x14,
-            ],
-            default_d: [
-                0xd2, 0xf7, 0x5f, 0x7c, 0xe7, 0x1b, 0xa4, 0xa7, 0xab, 0x69, 0xb8,
-            ],
-            default_pk_d: [
-                0x49, 0x19, 0x01, 0x2e, 0x40, 0x43, 0x82, 0xeb, 0xee, 0x8e, 0x60, 0xe9, 0xd4, 0xf1,
-                0x30, 0x79, 0xc0, 0x8d, 0x9c, 0x6d, 0x50, 0xf9, 0x35, 0x86, 0x7d, 0x33, 0x01, 0xf6,
-                0x89, 0xcf, 0xf9, 0x1e,
-            ],
-            v: 7555450289479839818,
-            rseed: [
-                0x13, 0xeb, 0x7c, 0xea, 0xa5, 0xff, 0x12, 0x90, 0xb0, 0x3e, 0xc9, 0x1c, 0xe6, 0xdd,
-                0x28, 0x13, 0x0c, 0x3a, 0xb0, 0xb2, 0x3b, 0x60, 0x2b, 0xd5, 0xbe, 0x5d, 0xc2, 0x60,
-                0x03, 0xaa, 0xe0, 0x4b,
-            ],
-            memo: [
-                0xff, 0x33, 0xd7, 0xbd, 0x25, 0x90, 0xe9, 0x0c, 0x8c, 0x38, 0x8e, 0xa7, 0x95, 0x51,
-                0x22, 0xdb, 0xac, 0xa6, 0x7b, 0x30, 0x39, 0x5a, 0x92, 0x8b, 0x57, 0xb8, 0x57, 0x51,
-                0x23, 0x20, 0x5a, 0xe1, 0x91, 0x52, 0xe4, 0x1e, 0x00, 0x29, 0x31, 0xb4, 0x57, 0x46,
-                0x19, 0x8e, 0x5d, 0xd9, 0x57, 0x1a, 0x56, 0xa7, 0xe0, 0xd4, 0x23, 0xff, 0x27, 0x98,
-                0x9d, 0x3e, 0xb4, 0x17, 0xec, 0xd3, 0xc3, 0x09, 0x3f, 0xb8, 0x2c, 0x56, 0x58, 0xe2,
-                0x96, 0x24, 0xc5, 0x32, 0x19, 0xa6, 0x0c, 0xd0, 0xa8, 0xc4, 0xda, 0x36, 0x7e, 0x29,
-                0xa7, 0x17, 0x79, 0xa7, 0x30, 0x32, 0x98, 0x5a, 0x3d, 0x1f, 0xd0, 0x3d, 0xd4, 0xd0,
-                0x6e, 0x05, 0x56, 0x6f, 0x3b, 0x84, 0x36, 0x7c, 0xf0, 0xfa, 0xee, 0x9b, 0xc3, 0xbd,
-                0x7a, 0x3a, 0x60, 0x6a, 0x9f, 0xdb, 0x84, 0x9c, 0x5d, 0x82, 0xd0, 0xa6, 0x19, 0x23,
-                0xc2, 0xe5, 0xd8, 0xaa, 0x63, 0xa8, 0xa5, 0x0c, 0x38, 0xbd, 0x03, 0x87, 0x72, 0xc4,
-                0x14, 0x3d, 0x8b, 0x7a, 0xcf, 0xd7, 0x4e, 0x72, 0xc0, 0x4d, 0x89, 0x24, 0x8d, 0xff,
-                0x20, 0xfe, 0x8d, 0xc5, 0xec, 0x21, 0x49, 0x05, 0x4e, 0xa2, 0x41, 0x64, 0xe8, 0x5f,
-                0x67, 0x44, 0xad, 0x0c, 0xac, 0xf1, 0xa8, 0xb7, 0x01, 0x26, 0xf4, 0x82, 0xc0, 0x92,
-                0xed, 0x9f, 0x61, 0x27, 0xd2, 0x05, 0x0d, 0x12, 0xe8, 0x78, 0xa7, 0x96, 0x53, 0xa1,
-                0xe8, 0x4d, 0xae, 0xc3, 0xeb, 0xe6, 0x2d, 0x5f, 0x6c, 0x4a, 0xbe, 0x5c, 0xe9, 0x0a,
-                0x7f, 0xe2, 0xe5, 0x2a, 0x8d, 0x78, 0x46, 0xe8, 0xed, 0xf2, 0xf2, 0xbc, 0xe0, 0x5a,
-                0x03, 0x7c, 0x82, 0x6f, 0x22, 0xca, 0xad, 0x12, 0x61, 0x46, 0x7d, 0xcf, 0xb7, 0xd6,
-                0xb6, 0x13, 0x3d, 0xc2, 0x1e, 0x80, 0x96, 0xc7, 0xe9, 0xf8, 0xe9, 0xe1, 0x0c, 0x1e,
-                0x3f, 0xac, 0x40, 0x58, 0xb6, 0x82, 0xc6, 0x8e, 0x54, 0xfa, 0xca, 0xe0, 0xf9, 0xc2,
-                0xdd, 0x4d, 0x64, 0xd9, 0x04, 0x61, 0x52, 0xb4, 0x76, 0x23, 0x32, 0x93, 0x9f, 0x17,
-                0xe6, 0xaa, 0xf7, 0xd8, 0xb9, 0xd3, 0x58, 0xe2, 0x21, 0x8d, 0x4e, 0x0d, 0x69, 0xa4,
-                0xf1, 0x19, 0xe1, 0xc6, 0x4e, 0xec, 0x4c, 0x8b, 0x53, 0x28, 0x09, 0x70, 0x71, 0x31,
-                0xf0, 0x1f, 0x55, 0xc7, 0xad, 0x04, 0xcf, 0xb6, 0x3f, 0x7c, 0x4a, 0x3d, 0x0a, 0x2b,
-                0x0f, 0xfb, 0x0b, 0x05, 0xa6, 0xbe, 0x05, 0x5b, 0x8c, 0x94, 0xca, 0x80, 0xbb, 0x0a,
-                0x1d, 0x13, 0xcd, 0x4c, 0xd6, 0x9a, 0xb9, 0x83, 0x04, 0xae, 0x25, 0x15, 0xd5, 0xf7,
-                0x69, 0x9d, 0x4a, 0xbe, 0xe5, 0xc2, 0x0b, 0xe6, 0x09, 0xd8, 0x73, 0x51, 0x10, 0x12,
-                0xf2, 0x34, 0xbd, 0x85, 0xa7, 0xef, 0xf5, 0xfb, 0x63, 0x4c, 0xff, 0x26, 0x58, 0xba,
-                0x65, 0x16, 0x04, 0x85, 0x63, 0x09, 0x5e, 0xce, 0xfb, 0x30, 0x15, 0xee, 0x3f, 0x03,
-                0xca, 0x52, 0xa1, 0x77, 0xf2, 0x61, 0xec, 0xdc, 0x26, 0xbc, 0x08, 0x9d, 0x34, 0xc6,
-                0x40, 0x48, 0x46, 0xe9, 0xc6, 0x47, 0xfc, 0xfe, 0x98, 0xcc, 0x6a, 0xcd, 0xbb, 0x46,
-                0x4f, 0x64, 0x27, 0x8a, 0xd8, 0xce, 0x9d, 0x1a, 0xe0, 0xd4, 0x15, 0xbc, 0x0c, 0x05,
-                0x24, 0x5f, 0xdd, 0xaf, 0x4e, 0xbc, 0x8d, 0xc7, 0x03, 0xa8, 0x5c, 0xb2, 0x70, 0xf7,
-                0x96, 0xad, 0x2d, 0x93, 0x7e, 0x2a, 0xc0, 0xd5, 0xe0, 0xa3, 0x48, 0x21, 0x75, 0x80,
-                0x00, 0xaa, 0x59, 0xc9, 0xd4, 0x65, 0x24, 0x85, 0x29, 0x4e, 0xe0, 0xab, 0x29, 0x69,
-                0x6b, 0x21, 0x43, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ],
-            cv_net: [
-                0x71, 0x00, 0xa7, 0x52, 0x93, 0xf4, 0xae, 0xfd, 0x89, 0xa1, 0x66, 0xa5, 0xf8, 0x4d,
-                0x34, 0xda, 0xf4, 0xe5, 0x98, 0x34, 0xcd, 0x65, 0xd7, 0x9f, 0xfc, 0x41, 0xdd, 0xf0,
-                0x68, 0x2d, 0xc2, 0xab,
-            ],
-            rho: [
-                0x31, 0x70, 0x5e, 0xfb, 0xf8, 0x0c, 0x7a, 0x7a, 0xb7, 0x81, 0xdf, 0x53, 0x77, 0xf8,
-                0x4d, 0x4b, 0x32, 0x36, 0xdb, 0x1f, 0x32, 0xac, 0xa7, 0x94, 0x5c, 0xf2, 0x6e, 0xc8,
-                0xb9, 0xd0, 0xb7, 0x32,
-            ],
-            cmx: [
-                0xe1, 0xc7, 0x67, 0xf3, 0x30, 0x15, 0xb5, 0xe2, 0x4a, 0x9a, 0xa5, 0x8b, 0x64, 0x7b,
-                0x6b, 0x61, 0x32, 0x3c, 0xd3, 0x47, 0xe7, 0x21, 0x4c, 0x29, 0x1d, 0x09, 0x95, 0xc0,
-                0xf5, 0xa6, 0x93, 0x2f,
-            ],
-            esk: [
-                0xc0, 0xdb, 0x43, 0x69, 0x10, 0x03, 0x45, 0x7d, 0x61, 0xfb, 0x58, 0x93, 0x20, 0x26,
-                0xf9, 0xdd, 0x2c, 0x35, 0xb9, 0x05, 0x7f, 0xad, 0x50, 0xd8, 0x44, 0x72, 0x83, 0xf9,
-                0x4e, 0xd5, 0x95, 0x3d,
-            ],
-            ephemeral_key: [
-                0xce, 0x67, 0x94, 0x31, 0x5f, 0x46, 0x2d, 0xed, 0xf3, 0xc5, 0x77, 0x4a, 0xac, 0x7f,
-                0x3c, 0x7b, 0x70, 0xba, 0x7d, 0x72, 0x43, 0xbb, 0x0c, 0xc3, 0xb0, 0x67, 0xdc, 0x28,
-                0x38, 0xf1, 0x11, 0xa3,
-            ],
-            shared_secret: [
-                0xea, 0x22, 0x6b, 0x69, 0xec, 0x2d, 0x9f, 0xcf, 0x91, 0x9c, 0xe5, 0x70, 0x06, 0x09,
-                0x89, 0x94, 0xf7, 0x14, 0xb3, 0x9c, 0x34, 0x61, 0x52, 0xbc, 0x11, 0x51, 0xa0, 0xc6,
-                0x9e, 0xe0, 0x04, 0x06,
-            ],
-            k_enc: [
-                0xb4, 0x56, 0x1b, 0xdb, 0xe0, 0xea, 0x44, 0x20, 0x75, 0xe7, 0xe6, 0x6f, 0xb3, 0xc0,
-                0xfa, 0xd3, 0xaf, 0xc2, 0x85, 0x6e, 0xf4, 0xf3, 0x61, 0xb4, 0xac, 0x33, 0xaa, 0xe0,
-                0x15, 0x52, 0xfd, 0x49,
-            ],
-            p_enc: [
-                0x03, 0xd2, 0xf7, 0x5f, 0x7c, 0xe7, 0x1b, 0xa4, 0xa7, 0xab, 0x69, 0xb8, 0x4a, 0x70,
-                0x91, 0xfe, 0x01, 0x5a, 0xda, 0x68, 0x13, 0xeb, 0x7c, 0xea, 0xa5, 0xff, 0x12, 0x90,
-                0xb0, 0x3e, 0xc9, 0x1c, 0xe6, 0xdd, 0x28, 0x13, 0x0c, 0x3a, 0xb0, 0xb2, 0x3b, 0x60,
-                0x2b, 0xd5, 0xbe, 0x5d, 0xc2, 0x60, 0x03, 0xaa, 0xe0, 0x4b, 0x29, 0x8a, 0xc0, 0xaf,
-                0xdc, 0x52, 0x87, 0xd7, 0xad, 0x12, 0x4c, 0xd9, 0x40, 0x5a, 0x62, 0xcd, 0x1c, 0xa0,
-                0x8b, 0x28, 0x2e, 0xfe, 0xf7, 0xf9, 0x28, 0xdf, 0x76, 0xe2, 0x82, 0x1a, 0x41, 0x84,
-                0xff, 0x33, 0xd7, 0xbd, 0x25, 0x90, 0xe9, 0x0c, 0x8c, 0x38, 0x8e, 0xa7, 0x95, 0x51,
-                0x22, 0xdb, 0xac, 0xa6, 0x7b, 0x30, 0x39, 0x5a, 0x92, 0x8b, 0x57, 0xb8, 0x57, 0x51,
-                0x23, 0x20, 0x5a, 0xe1, 0x91, 0x52, 0xe4, 0x1e, 0x00, 0x29, 0x31, 0xb4, 0x57, 0x46,
-                0x19, 0x8e, 0x5d, 0xd9, 0x57, 0x1a, 0x56, 0xa7, 0xe0, 0xd4, 0x23, 0xff, 0x27, 0x98,
-                0x9d, 0x3e, 0xb4, 0x17, 0xec, 0xd3, 0xc3, 0x09, 0x3f, 0xb8, 0x2c, 0x56, 0x58, 0xe2,
-                0x96, 0x24, 0xc5, 0x32, 0x19, 0xa6, 0x0c, 0xd0, 0xa8, 0xc4, 0xda, 0x36, 0x7e, 0x29,
-                0xa7, 0x17, 0x79, 0xa7, 0x30, 0x32, 0x98, 0x5a, 0x3d, 0x1f, 0xd0, 0x3d, 0xd4, 0xd0,
-                0x6e, 0x05, 0x56, 0x6f, 0x3b, 0x84, 0x36, 0x7c, 0xf0, 0xfa, 0xee, 0x9b, 0xc3, 0xbd,
-                0x7a, 0x3a, 0x60, 0x6a, 0x9f, 0xdb, 0x84, 0x9c, 0x5d, 0x82, 0xd0, 0xa6, 0x19, 0x23,
-                0xc2, 0xe5, 0xd8, 0xaa, 0x63, 0xa8, 0xa5, 0x0c, 0x38, 0xbd, 0x03, 0x87, 0x72, 0xc4,
-                0x14, 0x3d, 0x8b, 0x7a, 0xcf, 0xd7, 0x4e, 0x72, 0xc0, 0x4d, 0x89, 0x24, 0x8d, 0xff,
-                0x20, 0xfe, 0x8d, 0xc5, 0xec, 0x21, 0x49, 0x05, 0x4e, 0xa2, 0x41, 0x64, 0xe8, 0x5f,
-                0x67, 0x44, 0xad, 0x0c, 0xac, 0xf1, 0xa8, 0xb7, 0x01, 0x26, 0xf4, 0x82, 0xc0, 0x92,
-                0xed, 0x9f, 0x61, 0x27, 0xd2, 0x05, 0x0d, 0x12, 0xe8, 0x78, 0xa7, 0x96, 0x53, 0xa1,
-                0xe8, 0x4d, 0xae, 0xc3, 0xeb, 0xe6, 0x2d, 0x5f, 0x6c, 0x4a, 0xbe, 0x5c, 0xe9, 0x0a,
-                0x7f, 0xe2, 0xe5, 0x2a, 0x8d, 0x78, 0x46, 0xe8, 0xed, 0xf2, 0xf2, 0xbc, 0xe0, 0x5a,
-                0x03, 0x7c, 0x82, 0x6f, 0x22, 0xca, 0xad, 0x12, 0x61, 0x46, 0x7d, 0xcf, 0xb7, 0xd6,
-                0xb6, 0x13, 0x3d, 0xc2, 0x1e, 0x80, 0x96, 0xc7, 0xe9, 0xf8, 0xe9, 0xe1, 0x0c, 0x1e,
-                0x3f, 0xac, 0x40, 0x58, 0xb6, 0x82, 0xc6, 0x8e, 0x54, 0xfa, 0xca, 0xe0, 0xf9, 0xc2,
-                0xdd, 0x4d, 0x64, 0xd9, 0x04, 0x61, 0x52, 0xb4, 0x76, 0x23, 0x32, 0x93, 0x9f, 0x17,
-                0xe6, 0xaa, 0xf7, 0xd8, 0xb9, 0xd3, 0x58, 0xe2, 0x21, 0x8d, 0x4e, 0x0d, 0x69, 0xa4,
-                0xf1, 0x19, 0xe1, 0xc6, 0x4e, 0xec, 0x4c, 0x8b, 0x53, 0x28, 0x09, 0x70, 0x71, 0x31,
-                0xf0, 0x1f, 0x55, 0xc7, 0xad, 0x04, 0xcf, 0xb6, 0x3f, 0x7c, 0x4a, 0x3d, 0x0a, 0x2b,
-                0x0f, 0xfb, 0x0b, 0x05, 0xa6, 0xbe, 0x05, 0x5b, 0x8c, 0x94, 0xca, 0x80, 0xbb, 0x0a,
-                0x1d, 0x13, 0xcd, 0x4c, 0xd6, 0x9a, 0xb9, 0x83, 0x04, 0xae, 0x25, 0x15, 0xd5, 0xf7,
-                0x69, 0x9d, 0x4a, 0xbe, 0xe5, 0xc2, 0x0b, 0xe6, 0x09, 0xd8, 0x73, 0x51, 0x10, 0x12,
-                0xf2, 0x34, 0xbd, 0x85, 0xa7, 0xef, 0xf5, 0xfb, 0x63, 0x4c, 0xff, 0x26, 0x58, 0xba,
-                0x65, 0x16, 0x04, 0x85, 0x63, 0x09, 0x5e, 0xce, 0xfb, 0x30, 0x15, 0xee, 0x3f, 0x03,
-                0xca, 0x52, 0xa1, 0x77, 0xf2, 0x61, 0xec, 0xdc, 0x26, 0xbc, 0x08, 0x9d, 0x34, 0xc6,
-                0x40, 0x48, 0x46, 0xe9, 0xc6, 0x47, 0xfc, 0xfe, 0x98, 0xcc, 0x6a, 0xcd, 0xbb, 0x46,
-                0x4f, 0x64, 0x27, 0x8a, 0xd8, 0xce, 0x9d, 0x1a, 0xe0, 0xd4, 0x15, 0xbc, 0x0c, 0x05,
-                0x24, 0x5f, 0xdd, 0xaf, 0x4e, 0xbc, 0x8d, 0xc7, 0x03, 0xa8, 0x5c, 0xb2, 0x70, 0xf7,
-                0x96, 0xad, 0x2d, 0x93, 0x7e, 0x2a, 0xc0, 0xd5, 0xe0, 0xa3, 0x48, 0x21, 0x75, 0x80,
-                0x00, 0xaa, 0x59, 0xc9, 0xd4, 0x65, 0x24, 0x85, 0x29, 0x4e, 0xe0, 0xab, 0x29, 0x69,
-                0x6b, 0x21, 0x43, 0x0f,
-            ],
-            c_enc: [
-                0x59, 0x9a, 0x4d, 0x9f, 0x53, 0x3c, 0x46, 0xa9, 0x6f, 0x92, 0xaf, 0x8c, 0x08, 0xae,
-                0x59, 0x71, 0x10, 0x23, 0x0e, 0xb8, 0x41, 0xc2, 0xf7, 0xc9, 0xd4, 0xf1, 0x45, 0x87,
-                0x76, 0x36, 0xc8, 0x9d, 0xd8, 0xf3, 0x84, 0xa9, 0x40, 0xdc, 0x89, 0x72, 0x55, 0x53,
-                0x57, 0xbc, 0x07, 0x48, 0x2a, 0x0a, 0x32, 0x3d, 0x87, 0xae, 0x10, 0xeb, 0x99, 0x82,
-                0x5a, 0xe4, 0xe0, 0x06, 0x0e, 0x25, 0x6c, 0x3c, 0x3b, 0xeb, 0xa3, 0x2f, 0xa2, 0xb2,
-                0xd2, 0x7f, 0x04, 0x6f, 0x7a, 0x93, 0x6d, 0xf8, 0xa9, 0x61, 0xc8, 0x18, 0x4e, 0xe3,
-                0xc6, 0x8e, 0xbc, 0xe9, 0x80, 0x64, 0x45, 0xb4, 0x3e, 0x66, 0x67, 0x19, 0x95, 0xa2,
-                0x43, 0x7a, 0x7f, 0x70, 0x91, 0x47, 0x14, 0x8a, 0x76, 0x03, 0x6d, 0x25, 0x5e, 0xba,
-                0xc4, 0xd0, 0xd8, 0x34, 0x82, 0x93, 0x23, 0x9a, 0x78, 0x64, 0xe7, 0x9b, 0xef, 0xf7,
-                0x6f, 0x61, 0x50, 0xe0, 0xc4, 0xf4, 0x7a, 0x85, 0x26, 0xe3, 0xed, 0x06, 0x75, 0xfa,
-                0xc6, 0xac, 0xcc, 0x30, 0xa4, 0xd6, 0x73, 0xca, 0x80, 0x85, 0x95, 0x96, 0xfe, 0xc9,
-                0xcd, 0x6a, 0x93, 0xfb, 0xa0, 0xe8, 0x9e, 0xf5, 0x3f, 0x3e, 0x26, 0x74, 0xd3, 0x2a,
-                0x4b, 0x43, 0xf9, 0xa4, 0x38, 0x7d, 0xce, 0x33, 0xac, 0xa1, 0xe4, 0xff, 0xdc, 0x6d,
-                0x2d, 0x31, 0x89, 0xc6, 0x23, 0xca, 0x56, 0x4d, 0x03, 0xac, 0x5b, 0x35, 0xb1, 0xa7,
-                0x47, 0xff, 0x44, 0x6b, 0xc2, 0x5e, 0xd2, 0x2d, 0x09, 0x68, 0x2c, 0xef, 0x3a, 0x30,
-                0xff, 0xa5, 0xc4, 0x0e, 0x27, 0x70, 0xf1, 0x84, 0x98, 0xb1, 0x2f, 0x86, 0x8b, 0xa9,
-                0x2a, 0x13, 0xaa, 0x4f, 0xa2, 0x14, 0xb0, 0x62, 0xe3, 0x64, 0x9c, 0xf9, 0xc8, 0x5e,
-                0x7a, 0x8a, 0x55, 0xf5, 0xf3, 0xdd, 0x68, 0x84, 0x2a, 0xea, 0x7c, 0x92, 0x79, 0x2a,
-                0x52, 0x60, 0x0f, 0x86, 0x6c, 0x34, 0xa1, 0x0c, 0x51, 0x14, 0x13, 0x62, 0x02, 0x24,
-                0xfb, 0x85, 0xaf, 0xc6, 0x06, 0xdd, 0x4f, 0x7b, 0x2f, 0x76, 0xbe, 0x76, 0x0c, 0xa1,
-                0x94, 0xb6, 0xd4, 0x88, 0x2e, 0x5a, 0x4a, 0x76, 0x3d, 0x75, 0x0d, 0xb7, 0xe1, 0x68,
-                0xa4, 0x18, 0x11, 0x92, 0x35, 0xda, 0xf9, 0xcb, 0x1b, 0xdb, 0x07, 0xff, 0x46, 0x83,
-                0x3a, 0x87, 0xa3, 0x92, 0x6b, 0x14, 0xa5, 0x26, 0x4f, 0x10, 0x4f, 0x7f, 0x89, 0xf7,
-                0x6f, 0x10, 0x10, 0x8f, 0x2b, 0x6e, 0xa5, 0x05, 0xd4, 0xf0, 0xd2, 0x6d, 0x58, 0x31,
-                0x1c, 0xc7, 0x21, 0x9c, 0x6b, 0xc4, 0x38, 0xd0, 0xe1, 0xb3, 0x17, 0x60, 0x18, 0x73,
-                0x9e, 0x6f, 0x75, 0xd0, 0x73, 0x59, 0xf5, 0xe8, 0x95, 0x7e, 0x12, 0xc3, 0x03, 0xaa,
-                0x52, 0x9b, 0x11, 0xa1, 0x81, 0x66, 0x25, 0xa1, 0x20, 0xf3, 0x6d, 0xcd, 0xdd, 0xff,
-                0x9c, 0x65, 0xbc, 0xac, 0x8f, 0x10, 0x67, 0xc7, 0xfe, 0x88, 0xf6, 0x44, 0x85, 0x94,
-                0xcf, 0x1d, 0xff, 0x8e, 0x29, 0x00, 0xae, 0x84, 0xd2, 0xa7, 0xc8, 0x1b, 0x90, 0x6d,
-                0xd0, 0xbc, 0x86, 0x96, 0xe3, 0x70, 0x98, 0x07, 0x4b, 0x75, 0xd8, 0x38, 0xd8, 0xab,
-                0xdc, 0x90, 0x46, 0x08, 0x2b, 0xe4, 0xa6, 0x09, 0x95, 0xc4, 0xf4, 0xed, 0x80, 0xe2,
-                0xd7, 0x87, 0x38, 0x25, 0x77, 0x3b, 0xa6, 0x3e, 0xe4, 0xcb, 0x97, 0x36, 0x9a, 0x50,
-                0x70, 0xb5, 0x72, 0x5c, 0x5f, 0xeb, 0x32, 0x62, 0x45, 0x87, 0x80, 0x1e, 0x5a, 0xc0,
-                0x30, 0xe6, 0x45, 0xbd, 0xf2, 0xe5, 0x86, 0xcf, 0x98, 0x66, 0xea, 0xfb, 0x76, 0xf5,
-                0x59, 0x76, 0xa3, 0x3d, 0x62, 0xae, 0xdc, 0x76, 0x27, 0x78, 0x3b, 0x48, 0x48, 0x93,
-                0x61, 0xf9, 0x9c, 0xae, 0xb1, 0xb1, 0x9c, 0x55, 0x22, 0x58, 0x9f, 0xd2, 0x1d, 0x51,
-                0x45, 0x49, 0xd7, 0x4a, 0xb1, 0x92, 0x25, 0xed, 0x6e, 0x4c, 0x20, 0x3a, 0xdd, 0xfa,
-                0x55, 0xfc, 0x9e, 0xc9, 0x89, 0xb6, 0x69, 0x02, 0x3c, 0xf3, 0x05, 0xb4, 0x2b, 0x33,
-                0x0f, 0xc2, 0x30, 0x80, 0xab, 0xe4, 0x25, 0x01, 0xe5, 0x9c, 0x85, 0x1c, 0x54, 0xc7,
-                0x49, 0x66, 0xf6, 0x0b, 0xe9, 0xdc, 0x56, 0x1a, 0x2d, 0x91, 0xf5, 0xd3, 0x2a, 0xdd,
-                0x19, 0xb8, 0x9a, 0xca, 0x7a, 0x73, 0x85, 0x39, 0x59, 0x33, 0x48, 0x6f, 0xab, 0x00,
-                0xcc, 0x53, 0x03, 0xc5, 0xf3, 0xf0,
-            ],
-            ock: [
-                0x55, 0x0e, 0xbf, 0x98, 0x83, 0x6c, 0xce, 0x43, 0x52, 0x25, 0xa1, 0x4b, 0xa6, 0x52,
-                0xa7, 0xd5, 0x58, 0xcf, 0x5f, 0x3f, 0x7a, 0xfb, 0x00, 0xb0, 0x24, 0x70, 0xe8, 0xe4,
-                0xd2, 0x6d, 0xb7, 0x9c,
-            ],
-            op: [
-                0x49, 0x19, 0x01, 0x2e, 0x40, 0x43, 0x82, 0xeb, 0xee, 0x8e, 0x60, 0xe9, 0xd4, 0xf1,
-                0x30, 0x79, 0xc0, 0x8d, 0x9c, 0x6d, 0x50, 0xf9, 0x35, 0x86, 0x7d, 0x33, 0x01, 0xf6,
-                0x89, 0xcf, 0xf9, 0x1e, 0xc0, 0xdb, 0x43, 0x69, 0x10, 0x03, 0x45, 0x7d, 0x61, 0xfb,
-                0x58, 0x93, 0x20, 0x26, 0xf9, 0xdd, 0x2c, 0x35, 0xb9, 0x05, 0x7f, 0xad, 0x50, 0xd8,
-                0x44, 0x72, 0x83, 0xf9, 0x4e, 0xd5, 0x95, 0x3d,
-            ],
-            c_out: [
-                0x9a, 0x01, 0xb7, 0x5e, 0x27, 0xea, 0x97, 0x51, 0x45, 0x5d, 0x54, 0xf2, 0xa5, 0x2b,
-                0x88, 0x4b, 0x45, 0x6a, 0x6f, 0xc3, 0xda, 0xdb, 0xec, 0x79, 0xbf, 0x4d, 0x10, 0xbe,
-                0x06, 0x7b, 0xef, 0x3e, 0xa2, 0xa5, 0xc0, 0x59, 0x81, 0xd4, 0x06, 0x05, 0x6a, 0x2f,
-                0xf6, 0x4c, 0xb4, 0xc6, 0xfd, 0x46, 0x7d, 0xa8, 0x0b, 0xa1, 0x17, 0x48, 0xe9, 0xe2,
-                0xae, 0x07, 0xb7, 0x62, 0xdf, 0x9d, 0x4a, 0x23, 0x58, 0x77, 0xf5, 0x8f, 0x43, 0x24,
-                0xd8, 0x00, 0x3c, 0x32, 0x4f, 0xd9, 0xc6, 0x39, 0xbc, 0xa6,
-            ],
-            asset: Some([
-                0x29, 0x8a, 0xc0, 0xaf, 0xdc, 0x52, 0x87, 0xd7, 0xad, 0x12, 0x4c, 0xd9, 0x40, 0x5a,
-                0x62, 0xcd, 0x1c, 0xa0, 0x8b, 0x28, 0x2e, 0xfe, 0xf7, 0xf9, 0x28, 0xdf, 0x76, 0xe2,
-                0x82, 0x1a, 0x41, 0x84,
-            ]),
-        },
-        TestVector {
-            incoming_viewing_key: [
-                0x53, 0x3d, 0xc3, 0xd4, 0x93, 0xf2, 0xb8, 0x7a, 0x03, 0x3d, 0xf5, 0x07, 0x05, 0xf2,
-                0x90, 0x54, 0x16, 0x38, 0xe9, 0x08, 0x7d, 0xcd, 0xbc, 0xfe, 0x52, 0x7e, 0x77, 0x5a,
-                0xaf, 0x09, 0x30, 0x29, 0xac, 0xec, 0x74, 0xdd, 0xe6, 0x02, 0xfc, 0x7c, 0x73, 0xcb,
-                0x38, 0x50, 0xbd, 0xfb, 0xf2, 0x61, 0x79, 0x4c, 0x9c, 0x29, 0x9d, 0x0b, 0x98, 0xee,
-                0x0f, 0x20, 0x71, 0xd6, 0xd4, 0xe3, 0x7b, 0x05,
-            ],
-            ovk: [
-                0x32, 0x4d, 0xce, 0x2a, 0x1e, 0xa1, 0xe4, 0x30, 0x4f, 0x49, 0xe4, 0x3a, 0xe0, 0x65,
-                0xe3, 0xfb, 0x19, 0x6f, 0x76, 0xd9, 0xb8, 0x79, 0xc7, 0x20, 0x08, 0x62, 0xea, 0xd1,
-                0x8d, 0xea, 0x5f, 0xb6,
-            ],
-            default_d: [
-                0x20, 0x8c, 0x6d, 0x90, 0x6c, 0xfa, 0x93, 0xf1, 0x2d, 0x6a, 0x7e,
-            ],
-            default_pk_d: [
-                0x64, 0xce, 0xac, 0xec, 0x3c, 0x2e, 0xa7, 0x9c, 0x4c, 0xd3, 0xe2, 0xf0, 0xfb, 0xb9,
-                0xe1, 0xd4, 0x39, 0x55, 0xae, 0x66, 0xd8, 0x93, 0x92, 0xbf, 0x48, 0xaf, 0xb6, 0xc4,
-                0xab, 0x00, 0xa0, 0x28,
-            ],
-            v: 12711846894898776584,
-            rseed: [
-                0x7b, 0xdc, 0x8b, 0xa3, 0xe4, 0xe3, 0xd1, 0xd9, 0x33, 0xbf, 0xb5, 0x80, 0xf5, 0xb3,
-                0xe8, 0x7a, 0x2a, 0x06, 0x51, 0x70, 0x51, 0x41, 0x0f, 0xe1, 0xb4, 0xff, 0x1e, 0xa0,
-                0xad, 0xe8, 0x24, 0xf3,
-            ],
-            memo: [
-                0xff, 0x38, 0x51, 0x54, 0x56, 0xa5, 0x7c, 0x7a, 0x91, 0x6a, 0x74, 0x38, 0x8e, 0xe8,
-                0xf1, 0x28, 0x1f, 0x9a, 0xde, 0x0a, 0xe2, 0xa2, 0x61, 0x3a, 0x06, 0x12, 0xc4, 0x69,
-                0xdf, 0x79, 0x2b, 0x8d, 0xf4, 0xca, 0xe4, 0xfc, 0x25, 0xc1, 0xca, 0xdb, 0xa9, 0x5a,
-                0x80, 0x7c, 0xe6, 0x1e, 0x5a, 0x53, 0x03, 0xfa, 0xaf, 0x9e, 0x14, 0x65, 0x39, 0x96,
-                0xb5, 0xa8, 0xad, 0xc3, 0x4f, 0xd4, 0x75, 0xef, 0x14, 0x99, 0x09, 0x4b, 0xab, 0xaf,
-                0x1f, 0x3f, 0x07, 0xda, 0x9a, 0x39, 0x0b, 0x1d, 0x9f, 0xc9, 0xa0, 0x83, 0x27, 0x98,
-                0x7a, 0xdf, 0xe9, 0x56, 0x48, 0x63, 0xfb, 0xdf, 0xa8, 0xf6, 0xb4, 0x6a, 0x88, 0x41,
-                0x58, 0x30, 0x99, 0xaf, 0xb7, 0x87, 0x01, 0x18, 0xfa, 0xce, 0x76, 0x34, 0x7e, 0x40,
-                0xb6, 0xfd, 0x8c, 0xd1, 0x55, 0x82, 0xae, 0x8e, 0x23, 0xbe, 0x9a, 0x02, 0x19, 0xbc,
-                0x3e, 0x4e, 0x45, 0x46, 0xa3, 0x0d, 0x3b, 0xbb, 0xbd, 0x16, 0x86, 0x08, 0x68, 0x76,
-                0xbe, 0x0e, 0x4c, 0x85, 0x9b, 0xe7, 0x1f, 0xb5, 0x8f, 0x4f, 0xab, 0x3d, 0x28, 0xc0,
-                0xb4, 0xf7, 0xe7, 0x5a, 0xd1, 0xed, 0xb7, 0xf8, 0x89, 0x46, 0xfb, 0x40, 0xcf, 0xa5,
-                0x78, 0x6a, 0x0f, 0xcb, 0xa1, 0x30, 0x3c, 0x83, 0x47, 0xec, 0xee, 0x93, 0xd4, 0x6d,
-                0x14, 0x0b, 0xb5, 0xf6, 0x95, 0x31, 0xd6, 0x66, 0x54, 0x8b, 0x10, 0x9c, 0xe7, 0x64,
-                0xbe, 0xad, 0x7c, 0x87, 0xbd, 0x4c, 0x87, 0x64, 0x94, 0xde, 0x82, 0xdb, 0x6e, 0x50,
-                0x73, 0xa6, 0xc9, 0x4f, 0x7c, 0x09, 0x9a, 0x40, 0xd7, 0xa3, 0x1c, 0x4a, 0x04, 0xb6,
-                0x9c, 0x9f, 0xcc, 0xf3, 0xc7, 0xdd, 0x56, 0xf5, 0x54, 0x47, 0x76, 0xc5, 0x3b, 0x4d,
-                0xf7, 0x95, 0x39, 0x81, 0xd5, 0x5a, 0x96, 0xa6, 0xdc, 0xff, 0x99, 0x04, 0xa9, 0x08,
-                0x42, 0xe5, 0xba, 0xfe, 0xc8, 0x84, 0x0c, 0x2d, 0x25, 0x5b, 0xf5, 0xad, 0x61, 0xc4,
-                0x60, 0xf9, 0x8f, 0xeb, 0x82, 0xa1, 0x0f, 0xa1, 0xc0, 0x99, 0xf6, 0x27, 0x76, 0x79,
-                0x82, 0x36, 0xc5, 0xca, 0x7f, 0x1e, 0x46, 0xeb, 0xdb, 0x2b, 0x14, 0x4d, 0x87, 0x13,
-                0xe5, 0x6c, 0x77, 0x2f, 0x2c, 0x3b, 0x86, 0x0e, 0xa5, 0xb0, 0x3a, 0x88, 0x54, 0xbc,
-                0x6e, 0x65, 0x90, 0xd6, 0x3c, 0xc0, 0xea, 0x54, 0xf1, 0x0b, 0x73, 0xba, 0x24, 0x1b,
-                0xf7, 0x4b, 0x63, 0x55, 0x51, 0xa2, 0xaa, 0xca, 0x96, 0x87, 0xac, 0x52, 0x69, 0xfd,
-                0x36, 0x8b, 0x26, 0xd7, 0x0a, 0x73, 0x7f, 0x26, 0x76, 0x85, 0x99, 0x8a, 0x3f, 0x7d,
-                0x26, 0x37, 0x91, 0x49, 0x09, 0xc7, 0x46, 0x49, 0x5d, 0x24, 0xc4, 0x98, 0x63, 0x5e,
-                0xf9, 0x7a, 0xc6, 0x6a, 0x40, 0x08, 0x94, 0xc0, 0x9f, 0x73, 0x48, 0x8e, 0xb7, 0xcf,
-                0x33, 0xf6, 0xda, 0xd1, 0x66, 0x6a, 0x05, 0xf9, 0x1a, 0xd7, 0x75, 0x79, 0x65, 0xc2,
-                0x99, 0x36, 0xe7, 0xfa, 0x48, 0xd7, 0x7e, 0x89, 0xee, 0x09, 0x62, 0xf5, 0x8c, 0x05,
-                0x1d, 0x11, 0xd0, 0x55, 0xfc, 0xe2, 0x04, 0xa5, 0x62, 0xde, 0x68, 0x08, 0x8a, 0x1b,
-                0x26, 0x48, 0xb8, 0x17, 0x4c, 0xbc, 0xfc, 0x8b, 0x5b, 0x5c, 0xd0, 0x77, 0x11, 0x5a,
-                0xfd, 0xe1, 0x84, 0x05, 0x05, 0x4e, 0x5d, 0xa9, 0xa0, 0x43, 0x10, 0x34, 0x2c, 0x5d,
-                0x3b, 0x52, 0x6e, 0x0b, 0x02, 0xc5, 0xca, 0x17, 0x22, 0xba, 0xde, 0xee, 0x23, 0xd1,
-                0x45, 0xe8, 0xeb, 0x22, 0x13, 0xfc, 0x4a, 0xf1, 0xe4, 0x50, 0xe4, 0xd5, 0x21, 0x7c,
-                0x66, 0x17, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ],
-            cv_net: [
-                0x5d, 0xd1, 0x3d, 0xcf, 0x9a, 0xf3, 0x52, 0xf5, 0xfe, 0x0b, 0x2b, 0xcb, 0xd0, 0xdb,
-                0xd7, 0xda, 0xfb, 0xbe, 0x53, 0xb0, 0xa9, 0x6b, 0x08, 0x1c, 0x90, 0xba, 0xde, 0xd9,
-                0xbe, 0x4b, 0x4f, 0x87,
-            ],
-            rho: [
-                0x56, 0xbc, 0x48, 0x21, 0xa5, 0x3d, 0x5e, 0x9e, 0x6d, 0x7a, 0x04, 0x44, 0x44, 0x45,
-                0x4f, 0xfb, 0xc2, 0x36, 0x9c, 0xb1, 0x48, 0xeb, 0x76, 0xf1, 0xed, 0xf1, 0xb5, 0xc7,
-                0x41, 0x84, 0x28, 0x2a,
-            ],
-            cmx: [
-                0xd7, 0x60, 0xac, 0xdb, 0xca, 0xda, 0xd1, 0x88, 0x08, 0x4f, 0xe4, 0x1a, 0x5c, 0x03,
-                0xc2, 0xc8, 0xce, 0x34, 0xe1, 0x5f, 0x9d, 0xf4, 0x7b, 0x86, 0x9c, 0x44, 0xc7, 0x21,
-                0x13, 0xa4, 0x0c, 0x3d,
-            ],
-            esk: [
-                0x9b, 0x32, 0x77, 0x19, 0x3b, 0x63, 0x60, 0x8e, 0x6a, 0x3d, 0xdf, 0x7c, 0xe2, 0xd2,
-                0x33, 0x58, 0x4e, 0x66, 0x17, 0xd6, 0xf6, 0xa2, 0x1c, 0xdc, 0x86, 0x48, 0x56, 0x2c,
-                0xbd, 0x86, 0x3f, 0x09,
-            ],
-            ephemeral_key: [
-                0x5a, 0x48, 0x58, 0x15, 0xc4, 0xa7, 0x47, 0x06, 0xe9, 0xde, 0x87, 0xfa, 0x60, 0xa2,
-                0x81, 0x6f, 0x89, 0x0b, 0xe3, 0xdb, 0x54, 0xeb, 0x3f, 0x4b, 0xaf, 0x37, 0xdb, 0xc9,
-                0xbd, 0xe5, 0xfe, 0x9d,
-            ],
-            shared_secret: [
-                0x96, 0x8d, 0xf2, 0xe8, 0x5d, 0x7b, 0xd1, 0x08, 0xf5, 0x72, 0x12, 0x53, 0x93, 0x76,
-                0xaf, 0x25, 0x83, 0x2e, 0xf4, 0xdb, 0xd6, 0x40, 0x2a, 0x41, 0x4d, 0x73, 0xc5, 0x6b,
-                0xee, 0xe4, 0xf2, 0xa8,
-            ],
-            k_enc: [
-                0xf7, 0x73, 0x91, 0x24, 0x3f, 0xdb, 0x35, 0xb2, 0x26, 0x94, 0xdb, 0x91, 0xde, 0xbd,
-                0x78, 0x55, 0x79, 0x3c, 0xa7, 0x1e, 0x82, 0xbd, 0xc2, 0xee, 0x74, 0xc9, 0xb7, 0xb6,
-                0x97, 0xc0, 0x24, 0x71,
-            ],
-            p_enc: [
-                0x03, 0x20, 0x8c, 0x6d, 0x90, 0x6c, 0xfa, 0x93, 0xf1, 0x2d, 0x6a, 0x7e, 0x08, 0x0a,
-                0x98, 0x91, 0x66, 0x8d, 0x69, 0xb0, 0x7b, 0xdc, 0x8b, 0xa3, 0xe4, 0xe3, 0xd1, 0xd9,
-                0x33, 0xbf, 0xb5, 0x80, 0xf5, 0xb3, 0xe8, 0x7a, 0x2a, 0x06, 0x51, 0x70, 0x51, 0x41,
-                0x0f, 0xe1, 0xb4, 0xff, 0x1e, 0xa0, 0xad, 0xe8, 0x24, 0xf3, 0xf9, 0x78, 0x1e, 0xbe,
-                0x31, 0x7a, 0x07, 0x10, 0xae, 0x54, 0x61, 0xe3, 0x4f, 0xe6, 0xf1, 0xb1, 0xaa, 0x9b,
-                0x4e, 0x67, 0xb1, 0x49, 0x10, 0x98, 0x48, 0x02, 0xc2, 0xa7, 0xe3, 0x81, 0x93, 0xbc,
-                0xff, 0x38, 0x51, 0x54, 0x56, 0xa5, 0x7c, 0x7a, 0x91, 0x6a, 0x74, 0x38, 0x8e, 0xe8,
-                0xf1, 0x28, 0x1f, 0x9a, 0xde, 0x0a, 0xe2, 0xa2, 0x61, 0x3a, 0x06, 0x12, 0xc4, 0x69,
-                0xdf, 0x79, 0x2b, 0x8d, 0xf4, 0xca, 0xe4, 0xfc, 0x25, 0xc1, 0xca, 0xdb, 0xa9, 0x5a,
-                0x80, 0x7c, 0xe6, 0x1e, 0x5a, 0x53, 0x03, 0xfa, 0xaf, 0x9e, 0x14, 0x65, 0x39, 0x96,
-                0xb5, 0xa8, 0xad, 0xc3, 0x4f, 0xd4, 0x75, 0xef, 0x14, 0x99, 0x09, 0x4b, 0xab, 0xaf,
-                0x1f, 0x3f, 0x07, 0xda, 0x9a, 0x39, 0x0b, 0x1d, 0x9f, 0xc9, 0xa0, 0x83, 0x27, 0x98,
-                0x7a, 0xdf, 0xe9, 0x56, 0x48, 0x63, 0xfb, 0xdf, 0xa8, 0xf6, 0xb4, 0x6a, 0x88, 0x41,
-                0x58, 0x30, 0x99, 0xaf, 0xb7, 0x87, 0x01, 0x18, 0xfa, 0xce, 0x76, 0x34, 0x7e, 0x40,
-                0xb6, 0xfd, 0x8c, 0xd1, 0x55, 0x82, 0xae, 0x8e, 0x23, 0xbe, 0x9a, 0x02, 0x19, 0xbc,
-                0x3e, 0x4e, 0x45, 0x46, 0xa3, 0x0d, 0x3b, 0xbb, 0xbd, 0x16, 0x86, 0x08, 0x68, 0x76,
-                0xbe, 0x0e, 0x4c, 0x85, 0x9b, 0xe7, 0x1f, 0xb5, 0x8f, 0x4f, 0xab, 0x3d, 0x28, 0xc0,
-                0xb4, 0xf7, 0xe7, 0x5a, 0xd1, 0xed, 0xb7, 0xf8, 0x89, 0x46, 0xfb, 0x40, 0xcf, 0xa5,
-                0x78, 0x6a, 0x0f, 0xcb, 0xa1, 0x30, 0x3c, 0x83, 0x47, 0xec, 0xee, 0x93, 0xd4, 0x6d,
-                0x14, 0x0b, 0xb5, 0xf6, 0x95, 0x31, 0xd6, 0x66, 0x54, 0x8b, 0x10, 0x9c, 0xe7, 0x64,
-                0xbe, 0xad, 0x7c, 0x87, 0xbd, 0x4c, 0x87, 0x64, 0x94, 0xde, 0x82, 0xdb, 0x6e, 0x50,
-                0x73, 0xa6, 0xc9, 0x4f, 0x7c, 0x09, 0x9a, 0x40, 0xd7, 0xa3, 0x1c, 0x4a, 0x04, 0xb6,
-                0x9c, 0x9f, 0xcc, 0xf3, 0xc7, 0xdd, 0x56, 0xf5, 0x54, 0x47, 0x76, 0xc5, 0x3b, 0x4d,
-                0xf7, 0x95, 0x39, 0x81, 0xd5, 0x5a, 0x96, 0xa6, 0xdc, 0xff, 0x99, 0x04, 0xa9, 0x08,
-                0x42, 0xe5, 0xba, 0xfe, 0xc8, 0x84, 0x0c, 0x2d, 0x25, 0x5b, 0xf5, 0xad, 0x61, 0xc4,
-                0x60, 0xf9, 0x8f, 0xeb, 0x82, 0xa1, 0x0f, 0xa1, 0xc0, 0x99, 0xf6, 0x27, 0x76, 0x79,
-                0x82, 0x36, 0xc5, 0xca, 0x7f, 0x1e, 0x46, 0xeb, 0xdb, 0x2b, 0x14, 0x4d, 0x87, 0x13,
-                0xe5, 0x6c, 0x77, 0x2f, 0x2c, 0x3b, 0x86, 0x0e, 0xa5, 0xb0, 0x3a, 0x88, 0x54, 0xbc,
-                0x6e, 0x65, 0x90, 0xd6, 0x3c, 0xc0, 0xea, 0x54, 0xf1, 0x0b, 0x73, 0xba, 0x24, 0x1b,
-                0xf7, 0x4b, 0x63, 0x55, 0x51, 0xa2, 0xaa, 0xca, 0x96, 0x87, 0xac, 0x52, 0x69, 0xfd,
-                0x36, 0x8b, 0x26, 0xd7, 0x0a, 0x73, 0x7f, 0x26, 0x76, 0x85, 0x99, 0x8a, 0x3f, 0x7d,
-                0x26, 0x37, 0x91, 0x49, 0x09, 0xc7, 0x46, 0x49, 0x5d, 0x24, 0xc4, 0x98, 0x63, 0x5e,
-                0xf9, 0x7a, 0xc6, 0x6a, 0x40, 0x08, 0x94, 0xc0, 0x9f, 0x73, 0x48, 0x8e, 0xb7, 0xcf,
-                0x33, 0xf6, 0xda, 0xd1, 0x66, 0x6a, 0x05, 0xf9, 0x1a, 0xd7, 0x75, 0x79, 0x65, 0xc2,
-                0x99, 0x36, 0xe7, 0xfa, 0x48, 0xd7, 0x7e, 0x89, 0xee, 0x09, 0x62, 0xf5, 0x8c, 0x05,
-                0x1d, 0x11, 0xd0, 0x55, 0xfc, 0xe2, 0x04, 0xa5, 0x62, 0xde, 0x68, 0x08, 0x8a, 0x1b,
-                0x26, 0x48, 0xb8, 0x17, 0x4c, 0xbc, 0xfc, 0x8b, 0x5b, 0x5c, 0xd0, 0x77, 0x11, 0x5a,
-                0xfd, 0xe1, 0x84, 0x05, 0x05, 0x4e, 0x5d, 0xa9, 0xa0, 0x43, 0x10, 0x34, 0x2c, 0x5d,
-                0x3b, 0x52, 0x6e, 0x0b, 0x02, 0xc5, 0xca, 0x17, 0x22, 0xba, 0xde, 0xee, 0x23, 0xd1,
-                0x45, 0xe8, 0xeb, 0x22, 0x13, 0xfc, 0x4a, 0xf1, 0xe4, 0x50, 0xe4, 0xd5, 0x21, 0x7c,
-                0x66, 0x17, 0x00, 0x8c,
-            ],
-            c_enc: [
-                0xf9, 0x09, 0x97, 0x73, 0x8b, 0x14, 0xd8, 0xa8, 0x4e, 0x32, 0x74, 0xbb, 0x70, 0x76,
-                0x31, 0x15, 0xb7, 0x2e, 0x0a, 0x3d, 0xde, 0x8e, 0xa4, 0x70, 0x91, 0x1f, 0xb4, 0x58,
-                0x70, 0xb0, 0x14, 0x8e, 0x7d, 0x37, 0x2b, 0xf2, 0x26, 0x8b, 0x3e, 0xe8, 0xda, 0xe5,
-                0xfd, 0xe5, 0xea, 0x9b, 0x61, 0x59, 0x8e, 0xf1, 0x1b, 0x73, 0x14, 0x4f, 0x75, 0x53,
-                0xb2, 0x13, 0xa0, 0x4c, 0x85, 0xf2, 0x5c, 0x54, 0x6c, 0x8a, 0x38, 0xa6, 0x0e, 0x50,
-                0x86, 0x08, 0xb9, 0xca, 0x59, 0x3b, 0x94, 0xd8, 0x68, 0x8d, 0x6e, 0xff, 0xa5, 0x36,
-                0x04, 0xd4, 0xdb, 0xc0, 0xf3, 0x45, 0x03, 0xaa, 0xe4, 0x6f, 0x3c, 0x8a, 0x8d, 0x2e,
-                0x46, 0xa8, 0x1f, 0x09, 0x12, 0x6c, 0x45, 0x36, 0xfd, 0x02, 0x58, 0xf5, 0x97, 0x40,
-                0xad, 0x0d, 0xb8, 0x02, 0xcc, 0x02, 0x42, 0x53, 0x4d, 0xdf, 0x52, 0xa6, 0xbf, 0x6a,
-                0x03, 0x4d, 0xe6, 0x26, 0xf0, 0x18, 0x84, 0x4a, 0xdc, 0xb2, 0x6d, 0xcd, 0xc2, 0x85,
-                0x16, 0x37, 0x16, 0xdd, 0x54, 0x65, 0x1c, 0x88, 0x73, 0x53, 0xf1, 0xff, 0xef, 0xa0,
-                0x37, 0x71, 0x2a, 0xc0, 0xdf, 0x3a, 0x92, 0x98, 0x19, 0x06, 0x87, 0x54, 0x9d, 0x79,
-                0xc6, 0xa3, 0x60, 0x0c, 0xc1, 0xc7, 0x29, 0xa3, 0x93, 0xd4, 0x4f, 0xec, 0xe5, 0x7f,
-                0xd4, 0xcb, 0x0c, 0x0f, 0xb0, 0xc7, 0x86, 0x1b, 0x92, 0x5b, 0x94, 0xcd, 0x6a, 0x26,
-                0x90, 0xf0, 0x02, 0xc4, 0x3a, 0x16, 0x6e, 0x56, 0x77, 0x72, 0x9f, 0x35, 0x52, 0xae,
-                0xe0, 0xf2, 0xc1, 0x95, 0xaa, 0x91, 0xb2, 0xdd, 0xe3, 0x65, 0xdd, 0x14, 0xf2, 0xf0,
-                0x7b, 0x3c, 0x38, 0x34, 0x7f, 0x6c, 0x0d, 0xab, 0x82, 0x84, 0x1e, 0xba, 0xde, 0x1e,
-                0xf8, 0x13, 0xf2, 0xcd, 0x88, 0x5b, 0x57, 0x84, 0x37, 0x44, 0x45, 0x24, 0x93, 0x6a,
-                0x65, 0x46, 0xc4, 0x55, 0xd6, 0xc9, 0x2e, 0x6d, 0x3d, 0xc5, 0x38, 0xb6, 0xcd, 0x9f,
-                0x6d, 0x4c, 0xc0, 0xd7, 0x4d, 0x7b, 0xc2, 0x46, 0x7e, 0x21, 0x5b, 0xe8, 0xc3, 0xd4,
-                0xff, 0x91, 0x8a, 0x2d, 0x98, 0x71, 0x00, 0xff, 0x34, 0x02, 0x4c, 0x88, 0x62, 0x79,
-                0xd6, 0x4c, 0xaf, 0xdf, 0xd9, 0x0f, 0x1c, 0x04, 0xc4, 0x6b, 0xc9, 0xd5, 0xe9, 0xe2,
-                0xaf, 0xd0, 0x3a, 0xb7, 0x55, 0xe4, 0x0f, 0x08, 0x7e, 0xb5, 0x1e, 0xe3, 0xd1, 0x02,
-                0xb6, 0xb0, 0x69, 0xb6, 0x50, 0xf5, 0xd8, 0x55, 0x03, 0x35, 0x47, 0x1b, 0x24, 0x46,
-                0x5d, 0x93, 0x4d, 0x63, 0x34, 0x39, 0xb1, 0x08, 0xd9, 0x04, 0x2b, 0x37, 0xf9, 0xf7,
-                0x2e, 0x74, 0xfd, 0x6b, 0xa0, 0x01, 0x58, 0x5b, 0x08, 0x62, 0xdb, 0x99, 0x4a, 0x5e,
-                0xc1, 0x2d, 0xc9, 0x1e, 0x01, 0x48, 0x6a, 0x8d, 0xc6, 0x8a, 0xb9, 0xa3, 0x41, 0x93,
-                0x52, 0x61, 0x73, 0xec, 0xc0, 0xd1, 0x55, 0xb5, 0xcd, 0xd6, 0xbc, 0x07, 0xe6, 0x3e,
-                0x41, 0xaf, 0x9e, 0x52, 0x4c, 0xd3, 0xe6, 0x55, 0x5d, 0x38, 0xb4, 0x6d, 0xb2, 0xd9,
-                0x9e, 0x5b, 0xa4, 0xa4, 0x95, 0xff, 0x30, 0xfe, 0xf2, 0x54, 0xc9, 0xfe, 0x7b, 0x79,
-                0x0c, 0xe5, 0x6a, 0x40, 0xf4, 0x00, 0x27, 0xbb, 0x62, 0x05, 0x86, 0x38, 0xc4, 0x94,
-                0x17, 0x7b, 0x7f, 0x5c, 0x8f, 0x29, 0x44, 0x9e, 0x9e, 0xc3, 0xbd, 0xb3, 0xab, 0x04,
-                0x16, 0x0d, 0x96, 0xd0, 0xd4, 0x04, 0x79, 0x5d, 0x54, 0x28, 0x40, 0x82, 0xb6, 0x35,
-                0x7d, 0x58, 0x1d, 0xc2, 0x64, 0x81, 0x13, 0x67, 0xbb, 0xb1, 0x31, 0x9a, 0x31, 0xf7,
-                0x66, 0x4a, 0x4e, 0xca, 0x93, 0x2a, 0xbb, 0xd7, 0x33, 0xa7, 0x1a, 0x31, 0xaf, 0x23,
-                0x11, 0xc4, 0x9a, 0xc9, 0xaf, 0x22, 0xf8, 0x16, 0x7b, 0x25, 0x51, 0xac, 0xf5, 0x73,
-                0xd9, 0x1b, 0x40, 0x98, 0xc4, 0xde, 0xa8, 0xa9, 0x79, 0x9d, 0x9d, 0x54, 0x52, 0x0c,
-                0xc6, 0x3e, 0x55, 0x71, 0x8a, 0x24, 0x85, 0xbf, 0x6f, 0x63, 0x16, 0x30, 0x7c, 0xea,
-                0x21, 0x5e, 0x22, 0x22, 0x8d, 0x45, 0x34, 0x9a, 0x03, 0x50, 0x31, 0xa4, 0xcb, 0x67,
-                0x7b, 0x52, 0x3a, 0x3a, 0x51, 0x25, 0x2c, 0x6c, 0x61, 0xd0, 0xe2, 0x43, 0x2b, 0x94,
-                0xac, 0x9c, 0x0d, 0xb5, 0x40, 0xf3, 0x5b, 0x1d, 0xde, 0x91, 0xa3, 0xaf, 0x37, 0xa6,
-                0x71, 0xb8, 0xaa, 0x9f, 0x69, 0xf0,
-            ],
-            ock: [
-                0x53, 0x29, 0x6e, 0xed, 0x43, 0xb4, 0xeb, 0x30, 0xa4, 0x3d, 0x88, 0x90, 0x2f, 0x74,
-                0x04, 0x26, 0x62, 0x1d, 0x85, 0x21, 0x3a, 0x36, 0xc5, 0x20, 0xa1, 0x84, 0xa4, 0x3a,
-                0xfb, 0xd4, 0x89, 0x6d,
-            ],
-            op: [
-                0x64, 0xce, 0xac, 0xec, 0x3c, 0x2e, 0xa7, 0x9c, 0x4c, 0xd3, 0xe2, 0xf0, 0xfb, 0xb9,
-                0xe1, 0xd4, 0x39, 0x55, 0xae, 0x66, 0xd8, 0x93, 0x92, 0xbf, 0x48, 0xaf, 0xb6, 0xc4,
-                0xab, 0x00, 0xa0, 0x28, 0x9b, 0x32, 0x77, 0x19, 0x3b, 0x63, 0x60, 0x8e, 0x6a, 0x3d,
-                0xdf, 0x7c, 0xe2, 0xd2, 0x33, 0x58, 0x4e, 0x66, 0x17, 0xd6, 0xf6, 0xa2, 0x1c, 0xdc,
-                0x86, 0x48, 0x56, 0x2c, 0xbd, 0x86, 0x3f, 0x09,
-            ],
-            c_out: [
-                0x38, 0xee, 0x14, 0xef, 0xb0, 0x63, 0x94, 0x64, 0x44, 0x6f, 0x5f, 0xb8, 0x79, 0x5d,
-                0x23, 0xf8, 0x8c, 0xf5, 0x65, 0x37, 0xe6, 0x4e, 0x1a, 0x46, 0x63, 0x17, 0xb3, 0x6f,
-                0x22, 0x2e, 0x00, 0x5b, 0x92, 0x4c, 0xc9, 0x10, 0xd6, 0x29, 0x06, 0x6e, 0x05, 0x07,
-                0xcb, 0x91, 0x2b, 0x0b, 0xc1, 0xd3, 0x16, 0xc2, 0x00, 0xb1, 0xa9, 0x56, 0x49, 0xc0,
-                0xc5, 0x30, 0xb4, 0xf3, 0xd0, 0x43, 0x06, 0x8e, 0xf6, 0xf4, 0x2d, 0xcb, 0xef, 0xd0,
-                0x2a, 0x34, 0x80, 0xe3, 0x2a, 0xa4, 0x5e, 0x33, 0xce, 0x25,
-            ],
-            asset: Some([
-                0xf9, 0x78, 0x1e, 0xbe, 0x31, 0x7a, 0x07, 0x10, 0xae, 0x54, 0x61, 0xe3, 0x4f, 0xe6,
-                0xf1, 0xb1, 0xaa, 0x9b, 0x4e, 0x67, 0xb1, 0x49, 0x10, 0x98, 0x48, 0x02, 0xc2, 0xa7,
-                0xe3, 0x81, 0x93, 0xbc,
-            ]),
-        },
-        TestVector {
-            incoming_viewing_key: [
-                0x77, 0x5c, 0x7f, 0x5c, 0xab, 0x43, 0x86, 0x88, 0x64, 0x3d, 0xdd, 0x15, 0x8d, 0xda,
-                0xed, 0xf9, 0xa0, 0xea, 0xef, 0x61, 0x4b, 0x54, 0x90, 0x60, 0xf1, 0xe4, 0xd7, 0xcc,
-                0x3e, 0x7e, 0x8b, 0x64, 0x49, 0x9a, 0x81, 0x8a, 0x6d, 0x0e, 0x33, 0x57, 0x68, 0x6e,
-                0x65, 0xbc, 0x27, 0x4e, 0x3f, 0x7d, 0x45, 0x5b, 0x91, 0x1f, 0x13, 0x9f, 0x19, 0xf0,
-                0x81, 0x61, 0x57, 0x51, 0x91, 0x3e, 0xb4, 0x12,
-            ],
-            ovk: [
-                0x45, 0xe1, 0x59, 0x6c, 0xbf, 0x46, 0x70, 0xb7, 0xe0, 0x5d, 0xfd, 0xaf, 0xbb, 0x0c,
-                0xf3, 0xdd, 0xee, 0x28, 0xd7, 0x6a, 0x82, 0x42, 0x8e, 0x8a, 0xba, 0x43, 0x64, 0xe8,
-                0x4b, 0xac, 0x37, 0x92,
-            ],
-            default_d: [
-                0x2d, 0x0e, 0x22, 0xbe, 0xb8, 0x62, 0xfe, 0x52, 0xc1, 0x4c, 0xf5,
-            ],
-            default_pk_d: [
-                0x9a, 0xe4, 0x94, 0xa9, 0xfc, 0xff, 0x9b, 0x74, 0x49, 0x14, 0x53, 0x31, 0x04, 0x4f,
-                0x9a, 0x02, 0x53, 0xe5, 0x24, 0xa0, 0x2c, 0x77, 0x95, 0xe9, 0x8f, 0x83, 0xec, 0x7d,
-                0x96, 0xdc, 0xe6, 0xb7,
-            ],
-            v: 10238534295395242511,
-            rseed: [
-                0xad, 0x8c, 0x7d, 0x94, 0x37, 0xe2, 0x0e, 0x2a, 0x1f, 0x20, 0xe8, 0x18, 0xf9, 0x05,
-                0x7c, 0x5a, 0xba, 0xaa, 0x2e, 0x5c, 0x15, 0xb9, 0x49, 0x45, 0xcd, 0x42, 0x4c, 0x28,
-                0xa5, 0xfa, 0x38, 0x5d,
-            ],
-            memo: [
-                0xff, 0xad, 0xfe, 0x49, 0x07, 0xb2, 0x74, 0xd8, 0x42, 0x70, 0x7d, 0xb3, 0x69, 0x7a,
-                0x5a, 0xe6, 0xc8, 0xf5, 0x42, 0xe5, 0xec, 0xc0, 0x7f, 0xe4, 0x73, 0x50, 0xd1, 0x01,
-                0x46, 0x70, 0x21, 0x2e, 0xfe, 0x81, 0xfb, 0x7c, 0x73, 0xe8, 0x45, 0x0d, 0xf8, 0x14,
-                0xef, 0x62, 0x32, 0xf7, 0x49, 0x0f, 0x63, 0xcc, 0xf0, 0x74, 0x80, 0xf8, 0x84, 0xa6,
-                0x6e, 0xaf, 0xfc, 0x28, 0xfe, 0xa4, 0x48, 0xd7, 0xb4, 0x01, 0xcd, 0xae, 0x10, 0xe7,
-                0xc0, 0xc7, 0xf9, 0xa7, 0xb1, 0x53, 0x31, 0x96, 0x9f, 0xc8, 0xcb, 0x36, 0x39, 0x67,
-                0x73, 0xde, 0x19, 0x19, 0x31, 0xc7, 0x50, 0xf6, 0xce, 0x5c, 0xaa, 0xf2, 0x97, 0x68,
-                0xeb, 0xb2, 0x7d, 0xac, 0xc7, 0x38, 0x05, 0x6a, 0x81, 0x25, 0xb4, 0x77, 0x2b, 0xf8,
-                0x7a, 0xe1, 0x0a, 0x8a, 0x30, 0x9b, 0x9b, 0xd6, 0x55, 0x04, 0x3c, 0xfc, 0x31, 0x59,
-                0x49, 0x43, 0x68, 0xc5, 0xab, 0x8c, 0xad, 0xb7, 0xf6, 0x71, 0xe9, 0x62, 0x6b, 0xd2,
-                0x63, 0xe3, 0x11, 0x81, 0xa6, 0x04, 0xb5, 0x06, 0xa0, 0x3b, 0x43, 0x9a, 0x7f, 0xfe,
-                0x43, 0x55, 0x89, 0x24, 0x77, 0xe2, 0xbd, 0xf3, 0x38, 0xc6, 0x2c, 0x39, 0x22, 0xf7,
-                0xd3, 0xc9, 0xa5, 0x6c, 0x71, 0x03, 0xd9, 0x11, 0x94, 0x8a, 0x84, 0xb5, 0xae, 0x2d,
-                0xbb, 0x16, 0xa3, 0x76, 0x1a, 0xdd, 0x05, 0x3a, 0x0f, 0x96, 0x7e, 0x6b, 0x5b, 0xc9,
-                0x42, 0x11, 0xb6, 0x54, 0x71, 0x53, 0x26, 0x7c, 0x6e, 0xe1, 0xca, 0xd0, 0xd9, 0x74,
-                0xa7, 0x10, 0x88, 0x58, 0x37, 0x35, 0xe4, 0xf6, 0x3d, 0x33, 0x15, 0x6d, 0xad, 0xd5,
-                0x4c, 0x2f, 0xaf, 0x89, 0x11, 0x4a, 0x12, 0x7b, 0x97, 0xb9, 0x4c, 0xc2, 0xa2, 0x2e,
-                0xf3, 0x03, 0xf4, 0x59, 0xd0, 0x4f, 0xc0, 0xb5, 0x3a, 0xce, 0x59, 0x18, 0xd4, 0x7f,
-                0xf3, 0x3a, 0x55, 0x8b, 0xd7, 0x1a, 0x75, 0xf3, 0x55, 0xfb, 0xd0, 0x6b, 0xbc, 0xcf,
-                0x4e, 0x02, 0xc3, 0xc0, 0xa4, 0xb6, 0x3d, 0x0c, 0xc9, 0x49, 0x80, 0x1d, 0x63, 0xa6,
-                0x4c, 0xb2, 0xd3, 0x23, 0x73, 0xb2, 0xc7, 0xb2, 0x74, 0xab, 0x2d, 0xb4, 0x68, 0x21,
-                0x42, 0xc8, 0xb2, 0x1d, 0x84, 0xc4, 0x81, 0xf5, 0xef, 0x21, 0xe4, 0xb5, 0xe3, 0x60,
-                0x34, 0x51, 0xbf, 0x94, 0x77, 0x4d, 0x0e, 0xf4, 0x7f, 0x63, 0xfa, 0x6a, 0xbb, 0x78,
-                0xd2, 0x1c, 0x19, 0x3c, 0xbe, 0x65, 0xb6, 0x95, 0xfe, 0x67, 0x42, 0x3c, 0x1e, 0x2d,
-                0x31, 0x2e, 0x27, 0x76, 0xfa, 0x24, 0xec, 0xe8, 0x46, 0x83, 0xe7, 0x48, 0x76, 0xc5,
-                0x5e, 0xa0, 0x36, 0x9e, 0x4e, 0xa0, 0xe8, 0x64, 0x94, 0xe0, 0x0d, 0xde, 0x23, 0x6a,
-                0x16, 0x89, 0x73, 0x1f, 0x0a, 0x5d, 0x82, 0x03, 0xaf, 0xde, 0x5c, 0x42, 0x36, 0x40,
-                0xb8, 0x1e, 0x4f, 0x63, 0x1c, 0x98, 0x1c, 0x11, 0xa2, 0xe1, 0xd1, 0x84, 0xc6, 0x7c,
-                0x52, 0x8d, 0xf9, 0x2d, 0x53, 0xae, 0xc4, 0x4a, 0x40, 0xa4, 0xea, 0x2a, 0x13, 0x1b,
-                0x47, 0x33, 0xcf, 0xe4, 0x5c, 0x6b, 0x00, 0x12, 0xc3, 0xe9, 0xe2, 0x09, 0x75, 0xba,
-                0xae, 0xcb, 0x02, 0x32, 0xdf, 0x88, 0x0b, 0xd7, 0xd1, 0xde, 0x13, 0xe1, 0x34, 0x94,
-                0x62, 0xec, 0x8d, 0x5d, 0xf3, 0xe7, 0x80, 0xff, 0xa7, 0x2e, 0xba, 0x8a, 0x8d, 0xf7,
-                0xfc, 0xf3, 0x98, 0xec, 0x23, 0x05, 0x13, 0xca, 0x9d, 0x61, 0x23, 0xf8, 0xb9, 0xd8,
-                0x17, 0x85, 0x60, 0xda, 0xf9, 0x75, 0x11, 0x19, 0x55, 0xa2, 0xbc, 0xa3, 0x42, 0x3e,
-                0xee, 0xfc, 0x52, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ],
-            cv_net: [
-                0x43, 0x94, 0x47, 0xab, 0x14, 0x5a, 0x6f, 0x0e, 0x5a, 0x3b, 0x43, 0x63, 0x04, 0x4c,
-                0x73, 0x07, 0x93, 0xf4, 0x36, 0x33, 0x1f, 0xfe, 0x66, 0x30, 0xc7, 0xca, 0x2d, 0x9b,
-                0x23, 0x2a, 0xe1, 0x98,
-            ],
-            rho: [
-                0xd6, 0xff, 0xc4, 0x74, 0x88, 0xad, 0x05, 0x93, 0x89, 0x70, 0xc4, 0xb1, 0x56, 0xd0,
-                0x53, 0xb9, 0x3b, 0xcb, 0xb4, 0x37, 0x57, 0x1c, 0x62, 0xf3, 0x75, 0x60, 0x7e, 0x90,
-                0x4e, 0xb3, 0xa2, 0x08,
-            ],
-            cmx: [
-                0x8f, 0x56, 0xd1, 0x3f, 0xd9, 0xc8, 0x3e, 0xb7, 0x1b, 0x95, 0x87, 0x7a, 0x4f, 0x29,
-                0x39, 0x64, 0xbf, 0x3f, 0x73, 0x1d, 0x8d, 0xf2, 0x04, 0x32, 0x2c, 0xed, 0xcb, 0x38,
-                0x68, 0x21, 0x90, 0x3c,
-            ],
-            esk: [
-                0x24, 0x50, 0xae, 0xde, 0xb9, 0x7e, 0x62, 0xd7, 0x9c, 0xcb, 0x44, 0xb0, 0xb0, 0x4f,
-                0xe7, 0x93, 0x92, 0x5d, 0x49, 0xc4, 0xc0, 0x1f, 0x49, 0x2e, 0xa9, 0xec, 0x88, 0x17,
-                0x18, 0x65, 0x40, 0x33,
-            ],
-            ephemeral_key: [
-                0x51, 0x66, 0x26, 0x31, 0x6e, 0xea, 0x63, 0xa6, 0x45, 0xae, 0x56, 0x23, 0x81, 0x5a,
-                0x31, 0x74, 0xb3, 0xed, 0x36, 0x64, 0xc3, 0x3e, 0x6a, 0x51, 0x81, 0xa9, 0xf5, 0xb5,
-                0x42, 0x76, 0x7a, 0x2d,
-            ],
-            shared_secret: [
-                0xf6, 0x04, 0x23, 0x98, 0x7f, 0x0e, 0x67, 0x6d, 0x1a, 0x3b, 0xb6, 0xef, 0xe0, 0x39,
-                0x42, 0x1d, 0xbb, 0xc8, 0x24, 0xb6, 0x90, 0xc1, 0x94, 0xa4, 0x90, 0xe4, 0x17, 0x1d,
-                0xde, 0x21, 0x58, 0x19,
-            ],
-            k_enc: [
-                0x20, 0x98, 0x25, 0x7e, 0x2b, 0x9b, 0x7f, 0xc0, 0x62, 0x82, 0x38, 0x03, 0x38, 0x59,
-                0x7d, 0xcb, 0x62, 0x7d, 0xdf, 0x47, 0x3e, 0x83, 0xa7, 0x2e, 0x61, 0xb0, 0xf2, 0x2c,
-                0xcf, 0xaf, 0xbe, 0x4e,
-            ],
-            p_enc: [
-                0x03, 0x2d, 0x0e, 0x22, 0xbe, 0xb8, 0x62, 0xfe, 0x52, 0xc1, 0x4c, 0xf5, 0x0f, 0x12,
-                0xb0, 0x11, 0xb2, 0x94, 0x16, 0x8e, 0xad, 0x8c, 0x7d, 0x94, 0x37, 0xe2, 0x0e, 0x2a,
-                0x1f, 0x20, 0xe8, 0x18, 0xf9, 0x05, 0x7c, 0x5a, 0xba, 0xaa, 0x2e, 0x5c, 0x15, 0xb9,
-                0x49, 0x45, 0xcd, 0x42, 0x4c, 0x28, 0xa5, 0xfa, 0x38, 0x5d, 0x76, 0xba, 0x24, 0x3f,
-                0x28, 0x42, 0xb7, 0xb5, 0xfc, 0x74, 0x6a, 0xe5, 0x1b, 0x0b, 0xc4, 0xbd, 0x4f, 0xc9,
-                0xfd, 0x83, 0x35, 0x65, 0xea, 0x85, 0x2b, 0x92, 0xb2, 0x24, 0xf6, 0x99, 0x03, 0x18,
-                0xff, 0xad, 0xfe, 0x49, 0x07, 0xb2, 0x74, 0xd8, 0x42, 0x70, 0x7d, 0xb3, 0x69, 0x7a,
-                0x5a, 0xe6, 0xc8, 0xf5, 0x42, 0xe5, 0xec, 0xc0, 0x7f, 0xe4, 0x73, 0x50, 0xd1, 0x01,
-                0x46, 0x70, 0x21, 0x2e, 0xfe, 0x81, 0xfb, 0x7c, 0x73, 0xe8, 0x45, 0x0d, 0xf8, 0x14,
-                0xef, 0x62, 0x32, 0xf7, 0x49, 0x0f, 0x63, 0xcc, 0xf0, 0x74, 0x80, 0xf8, 0x84, 0xa6,
-                0x6e, 0xaf, 0xfc, 0x28, 0xfe, 0xa4, 0x48, 0xd7, 0xb4, 0x01, 0xcd, 0xae, 0x10, 0xe7,
-                0xc0, 0xc7, 0xf9, 0xa7, 0xb1, 0x53, 0x31, 0x96, 0x9f, 0xc8, 0xcb, 0x36, 0x39, 0x67,
-                0x73, 0xde, 0x19, 0x19, 0x31, 0xc7, 0x50, 0xf6, 0xce, 0x5c, 0xaa, 0xf2, 0x97, 0x68,
-                0xeb, 0xb2, 0x7d, 0xac, 0xc7, 0x38, 0x05, 0x6a, 0x81, 0x25, 0xb4, 0x77, 0x2b, 0xf8,
-                0x7a, 0xe1, 0x0a, 0x8a, 0x30, 0x9b, 0x9b, 0xd6, 0x55, 0x04, 0x3c, 0xfc, 0x31, 0x59,
-                0x49, 0x43, 0x68, 0xc5, 0xab, 0x8c, 0xad, 0xb7, 0xf6, 0x71, 0xe9, 0x62, 0x6b, 0xd2,
-                0x63, 0xe3, 0x11, 0x81, 0xa6, 0x04, 0xb5, 0x06, 0xa0, 0x3b, 0x43, 0x9a, 0x7f, 0xfe,
-                0x43, 0x55, 0x89, 0x24, 0x77, 0xe2, 0xbd, 0xf3, 0x38, 0xc6, 0x2c, 0x39, 0x22, 0xf7,
-                0xd3, 0xc9, 0xa5, 0x6c, 0x71, 0x03, 0xd9, 0x11, 0x94, 0x8a, 0x84, 0xb5, 0xae, 0x2d,
-                0xbb, 0x16, 0xa3, 0x76, 0x1a, 0xdd, 0x05, 0x3a, 0x0f, 0x96, 0x7e, 0x6b, 0x5b, 0xc9,
-                0x42, 0x11, 0xb6, 0x54, 0x71, 0x53, 0x26, 0x7c, 0x6e, 0xe1, 0xca, 0xd0, 0xd9, 0x74,
-                0xa7, 0x10, 0x88, 0x58, 0x37, 0x35, 0xe4, 0xf6, 0x3d, 0x33, 0x15, 0x6d, 0xad, 0xd5,
-                0x4c, 0x2f, 0xaf, 0x89, 0x11, 0x4a, 0x12, 0x7b, 0x97, 0xb9, 0x4c, 0xc2, 0xa2, 0x2e,
-                0xf3, 0x03, 0xf4, 0x59, 0xd0, 0x4f, 0xc0, 0xb5, 0x3a, 0xce, 0x59, 0x18, 0xd4, 0x7f,
-                0xf3, 0x3a, 0x55, 0x8b, 0xd7, 0x1a, 0x75, 0xf3, 0x55, 0xfb, 0xd0, 0x6b, 0xbc, 0xcf,
-                0x4e, 0x02, 0xc3, 0xc0, 0xa4, 0xb6, 0x3d, 0x0c, 0xc9, 0x49, 0x80, 0x1d, 0x63, 0xa6,
-                0x4c, 0xb2, 0xd3, 0x23, 0x73, 0xb2, 0xc7, 0xb2, 0x74, 0xab, 0x2d, 0xb4, 0x68, 0x21,
-                0x42, 0xc8, 0xb2, 0x1d, 0x84, 0xc4, 0x81, 0xf5, 0xef, 0x21, 0xe4, 0xb5, 0xe3, 0x60,
-                0x34, 0x51, 0xbf, 0x94, 0x77, 0x4d, 0x0e, 0xf4, 0x7f, 0x63, 0xfa, 0x6a, 0xbb, 0x78,
-                0xd2, 0x1c, 0x19, 0x3c, 0xbe, 0x65, 0xb6, 0x95, 0xfe, 0x67, 0x42, 0x3c, 0x1e, 0x2d,
-                0x31, 0x2e, 0x27, 0x76, 0xfa, 0x24, 0xec, 0xe8, 0x46, 0x83, 0xe7, 0x48, 0x76, 0xc5,
-                0x5e, 0xa0, 0x36, 0x9e, 0x4e, 0xa0, 0xe8, 0x64, 0x94, 0xe0, 0x0d, 0xde, 0x23, 0x6a,
-                0x16, 0x89, 0x73, 0x1f, 0x0a, 0x5d, 0x82, 0x03, 0xaf, 0xde, 0x5c, 0x42, 0x36, 0x40,
-                0xb8, 0x1e, 0x4f, 0x63, 0x1c, 0x98, 0x1c, 0x11, 0xa2, 0xe1, 0xd1, 0x84, 0xc6, 0x7c,
-                0x52, 0x8d, 0xf9, 0x2d, 0x53, 0xae, 0xc4, 0x4a, 0x40, 0xa4, 0xea, 0x2a, 0x13, 0x1b,
-                0x47, 0x33, 0xcf, 0xe4, 0x5c, 0x6b, 0x00, 0x12, 0xc3, 0xe9, 0xe2, 0x09, 0x75, 0xba,
-                0xae, 0xcb, 0x02, 0x32, 0xdf, 0x88, 0x0b, 0xd7, 0xd1, 0xde, 0x13, 0xe1, 0x34, 0x94,
-                0x62, 0xec, 0x8d, 0x5d, 0xf3, 0xe7, 0x80, 0xff, 0xa7, 0x2e, 0xba, 0x8a, 0x8d, 0xf7,
-                0xfc, 0xf3, 0x98, 0xec, 0x23, 0x05, 0x13, 0xca, 0x9d, 0x61, 0x23, 0xf8, 0xb9, 0xd8,
-                0x17, 0x85, 0x60, 0xda, 0xf9, 0x75, 0x11, 0x19, 0x55, 0xa2, 0xbc, 0xa3, 0x42, 0x3e,
-                0xee, 0xfc, 0x52, 0x7b,
-            ],
-            c_enc: [
-                0xa4, 0x01, 0xab, 0x60, 0x1f, 0x8d, 0x69, 0xd9, 0x38, 0x0c, 0x3d, 0xef, 0x1f, 0x1a,
-                0x34, 0xbe, 0x6c, 0xfa, 0x4d, 0x83, 0x8b, 0xf8, 0x7f, 0x00, 0xe3, 0x6b, 0xe6, 0xbe,
-                0x68, 0x60, 0xbe, 0xa8, 0x3d, 0xab, 0xdd, 0x00, 0xab, 0xe7, 0xe0, 0xd1, 0x21, 0x90,
-                0xfb, 0x54, 0xb0, 0xf2, 0xad, 0xcf, 0xef, 0x9e, 0xf4, 0x2b, 0xa2, 0x31, 0x77, 0x6a,
-                0xd3, 0xee, 0x09, 0x86, 0xdb, 0x3f, 0x4f, 0xc0, 0xa8, 0xa1, 0xc6, 0xa7, 0xfe, 0x54,
-                0xa6, 0x6b, 0xd7, 0x68, 0xa9, 0xde, 0xd2, 0x5b, 0xb1, 0x89, 0xd5, 0x87, 0x1c, 0xaf,
-                0x4d, 0xf8, 0x95, 0x6c, 0x2f, 0x30, 0x70, 0x15, 0x89, 0xa4, 0xdc, 0xdb, 0x68, 0x11,
-                0x6d, 0x0f, 0x50, 0x9b, 0x34, 0x1e, 0x8f, 0x25, 0x8e, 0x17, 0x38, 0xb5, 0x51, 0x9c,
-                0x99, 0xf1, 0xdb, 0xd0, 0x86, 0x31, 0x56, 0x2f, 0x90, 0xd1, 0x5e, 0x72, 0x8a, 0x85,
-                0x25, 0xa1, 0x1b, 0xfe, 0x53, 0x95, 0x24, 0x5d, 0x71, 0x79, 0xcf, 0x8e, 0x97, 0xa8,
-                0x3f, 0xaa, 0x4c, 0xf3, 0xb2, 0xa8, 0xb5, 0xef, 0x62, 0x13, 0xe3, 0x30, 0x89, 0xb4,
-                0xeb, 0x03, 0xe7, 0xc2, 0xf0, 0x12, 0x11, 0xfc, 0x53, 0xbc, 0x01, 0x16, 0x40, 0x05,
-                0x01, 0x5d, 0xbf, 0x33, 0xc6, 0x50, 0xa3, 0xf8, 0x33, 0xba, 0x67, 0x77, 0xcf, 0xf1,
-                0xd7, 0x38, 0xe2, 0x1c, 0x58, 0xdc, 0x05, 0xc3, 0xb4, 0xec, 0xb9, 0x7a, 0x6c, 0xe0,
-                0xb0, 0xc5, 0xee, 0x94, 0x4c, 0x24, 0xb3, 0x3b, 0xb0, 0xce, 0x32, 0xbe, 0x02, 0x3e,
-                0x21, 0x3f, 0xf7, 0xc9, 0xd4, 0x12, 0x4f, 0xc9, 0xdc, 0x4a, 0xa7, 0xca, 0x47, 0x13,
-                0x86, 0x48, 0xe2, 0xbb, 0x80, 0x7c, 0xea, 0x7a, 0x58, 0xe7, 0x67, 0xd3, 0x27, 0x07,
-                0x4a, 0xe5, 0xe3, 0x9c, 0x3c, 0x17, 0xb7, 0x7c, 0x09, 0x0a, 0xf9, 0x42, 0x5b, 0xc6,
-                0x40, 0xd2, 0x1d, 0xd6, 0x81, 0xa6, 0x37, 0x45, 0xe9, 0x02, 0x59, 0xe2, 0xd1, 0x09,
-                0x0c, 0x88, 0x48, 0x8e, 0x21, 0x48, 0xb9, 0xee, 0x24, 0x31, 0xc5, 0xae, 0xf5, 0x10,
-                0x95, 0xb3, 0x5a, 0x37, 0x7c, 0xfa, 0x76, 0x5d, 0x82, 0x24, 0x98, 0x83, 0x00, 0x04,
-                0x71, 0x79, 0xa5, 0x09, 0x40, 0x28, 0xbe, 0x52, 0x7d, 0x5d, 0xe1, 0xc2, 0x69, 0xff,
-                0x45, 0x2c, 0x0a, 0xaf, 0x5a, 0x47, 0x7e, 0x93, 0x90, 0xa0, 0xf0, 0xa8, 0x68, 0x11,
-                0x3c, 0x7c, 0xd1, 0x9e, 0x2e, 0xac, 0x54, 0x0d, 0xc6, 0x59, 0xda, 0x29, 0x60, 0x06,
-                0x77, 0x6e, 0xda, 0x0d, 0xf9, 0x81, 0xc4, 0x11, 0xc1, 0x50, 0x01, 0xa9, 0x8b, 0x6a,
-                0xd6, 0x58, 0xd9, 0xa6, 0x4c, 0x12, 0x6a, 0xbe, 0xfc, 0x73, 0x9a, 0xa1, 0xf4, 0x44,
-                0xbb, 0x83, 0xf3, 0xf1, 0x4d, 0x11, 0x3d, 0x02, 0x8f, 0xae, 0x10, 0xe4, 0xc5, 0xdb,
-                0xe7, 0x78, 0x51, 0x96, 0x83, 0xcd, 0xf4, 0xc2, 0xf4, 0x6c, 0x4a, 0x52, 0xae, 0x12,
-                0x09, 0xe1, 0x12, 0x7f, 0x9d, 0xc4, 0xed, 0x86, 0x7d, 0x8e, 0xda, 0x02, 0x4a, 0x68,
-                0x9f, 0x6b, 0x15, 0xb8, 0x05, 0x38, 0x03, 0x02, 0x44, 0x02, 0xa1, 0xce, 0x6f, 0x1c,
-                0x63, 0x6f, 0x2e, 0xfc, 0xf9, 0xd0, 0x60, 0x51, 0x5c, 0xd6, 0x14, 0x71, 0x8d, 0x51,
-                0x52, 0x7d, 0x26, 0x7a, 0xd8, 0x95, 0xfa, 0xd8, 0xec, 0xfb, 0x23, 0x51, 0xf8, 0x92,
-                0x45, 0x0d, 0xc8, 0x74, 0xe8, 0x74, 0x39, 0x2c, 0x91, 0xed, 0x3a, 0xf1, 0x18, 0x38,
-                0xc4, 0xb5, 0x48, 0x2e, 0x8c, 0x92, 0xeb, 0xc7, 0xa0, 0x08, 0x8e, 0x49, 0xd2, 0xb0,
-                0xb4, 0xa1, 0xbd, 0x33, 0x3b, 0x38, 0x7f, 0x49, 0xe3, 0x0f, 0xd2, 0x1a, 0x6e, 0xdc,
-                0x89, 0x94, 0x83, 0x4f, 0x28, 0xe9, 0xf2, 0x52, 0x9a, 0x7e, 0x27, 0x24, 0x21, 0x6d,
-                0x9e, 0x1a, 0xe5, 0xb4, 0x6e, 0xb1, 0x9a, 0x53, 0xea, 0x2b, 0x97, 0x99, 0x65, 0xf7,
-                0x5b, 0x83, 0xf6, 0x86, 0xed, 0xc0, 0x1d, 0x25, 0x7a, 0x06, 0x58, 0xd7, 0x4e, 0x25,
-                0xc0, 0xe1, 0xa8, 0xb0, 0x65, 0x60, 0x43, 0x1f, 0x85, 0x10, 0x5c, 0xf9, 0x8a, 0x1f,
-                0xfe, 0x28, 0x40, 0x8a, 0x64, 0xf4, 0xc0, 0x27, 0x8d, 0x36, 0xed, 0xea, 0x76, 0x40,
-                0xa2, 0x18, 0x26, 0xc3, 0x5d, 0x13, 0x20, 0x25, 0x08, 0x07, 0x2b, 0x68, 0x82, 0xf4,
-                0xd8, 0x2e, 0x93, 0x3c, 0x89, 0xe1,
-            ],
-            ock: [
-                0x2a, 0x2e, 0x0d, 0x99, 0x69, 0xf0, 0x2e, 0xbd, 0xb6, 0xd9, 0xc8, 0xe7, 0xe6, 0xfd,
-                0xde, 0x20, 0x85, 0x12, 0x4b, 0x19, 0xad, 0x70, 0x90, 0xcc, 0x26, 0x15, 0x1d, 0x4d,
-                0xa4, 0x2a, 0x00, 0x3e,
-            ],
-            op: [
-                0x9a, 0xe4, 0x94, 0xa9, 0xfc, 0xff, 0x9b, 0x74, 0x49, 0x14, 0x53, 0x31, 0x04, 0x4f,
-                0x9a, 0x02, 0x53, 0xe5, 0x24, 0xa0, 0x2c, 0x77, 0x95, 0xe9, 0x8f, 0x83, 0xec, 0x7d,
-                0x96, 0xdc, 0xe6, 0xb7, 0x24, 0x50, 0xae, 0xde, 0xb9, 0x7e, 0x62, 0xd7, 0x9c, 0xcb,
-                0x44, 0xb0, 0xb0, 0x4f, 0xe7, 0x93, 0x92, 0x5d, 0x49, 0xc4, 0xc0, 0x1f, 0x49, 0x2e,
-                0xa9, 0xec, 0x88, 0x17, 0x18, 0x65, 0x40, 0x33,
-            ],
-            c_out: [
-                0x74, 0x6a, 0xae, 0x9d, 0xa6, 0x1c, 0x02, 0xae, 0xaa, 0x8b, 0xed, 0xbe, 0x2b, 0x6c,
-                0x84, 0x1b, 0xc4, 0x36, 0x17, 0x3c, 0x7c, 0x91, 0x13, 0x66, 0x3a, 0x39, 0xc1, 0x74,
-                0x69, 0x29, 0x0b, 0xd2, 0x19, 0xea, 0xdc, 0x4a, 0x97, 0x5a, 0xd0, 0x52, 0xd0, 0x5d,
-                0xc0, 0xa3, 0x08, 0xf3, 0x63, 0xf9, 0x22, 0x68, 0x2d, 0x75, 0x21, 0x9d, 0xaa, 0x33,
-                0x6f, 0x69, 0xb5, 0x9e, 0x86, 0x7c, 0x85, 0xd9, 0x37, 0x34, 0x4c, 0x19, 0xd3, 0x88,
-                0x01, 0x63, 0x19, 0xb3, 0xf6, 0x0f, 0x76, 0xd0, 0x28, 0x93,
-            ],
-            asset: Some([
-                0x76, 0xba, 0x24, 0x3f, 0x28, 0x42, 0xb7, 0xb5, 0xfc, 0x74, 0x6a, 0xe5, 0x1b, 0x0b,
-                0xc4, 0xbd, 0x4f, 0xc9, 0xfd, 0x83, 0x35, 0x65, 0xea, 0x85, 0x2b, 0x92, 0xb2, 0x24,
-                0xf6, 0x99, 0x03, 0x18,
-            ]),
-        },
-        TestVector {
-            incoming_viewing_key: [
-                0x9c, 0xe9, 0x20, 0x37, 0x6a, 0x6a, 0x54, 0x1e, 0x6a, 0xad, 0x66, 0x0e, 0xfa, 0x09,
-                0x8d, 0xc5, 0x4c, 0x18, 0xfc, 0xeb, 0x13, 0xd0, 0x99, 0x9f, 0xbc, 0xc7, 0xfd, 0x45,
-                0xa5, 0x7c, 0xcc, 0x10, 0xb8, 0xaa, 0x86, 0xc4, 0x54, 0x0d, 0x0a, 0x9f, 0xc6, 0x6d,
-                0xf8, 0x5d, 0xad, 0xd6, 0x21, 0x56, 0x36, 0x5e, 0x28, 0xa3, 0xe9, 0x80, 0xb9, 0x8d,
-                0x13, 0x1b, 0x50, 0x3a, 0xa0, 0x6a, 0x6c, 0x19,
-            ],
-            ovk: [
-                0xf8, 0x1a, 0xd6, 0x17, 0xfa, 0x26, 0xf0, 0xdf, 0xb8, 0x36, 0x55, 0xb8, 0xa2, 0x9a,
-                0x7f, 0x83, 0x42, 0x32, 0x42, 0x5e, 0x8c, 0x47, 0x45, 0x88, 0xf1, 0x8d, 0xd3, 0x26,
-                0xaa, 0x39, 0x6c, 0x3e,
-            ],
-            default_d: [
-                0xfb, 0x8e, 0xa2, 0xcc, 0x0a, 0xd2, 0x30, 0x91, 0x32, 0xfd, 0x11,
-            ],
-            default_pk_d: [
-                0xcc, 0x18, 0xe4, 0xb6, 0x5f, 0x89, 0x34, 0x06, 0x31, 0x5d, 0xb7, 0x1f, 0xac, 0x06,
-                0x5d, 0x71, 0xd0, 0xea, 0xba, 0x7c, 0xf3, 0xc2, 0xba, 0x94, 0x77, 0x12, 0x32, 0x75,
-                0x43, 0x4b, 0x1e, 0xb0,
-            ],
-            v: 2690686290017047047,
-            rseed: [
-                0x0b, 0x39, 0x05, 0xa4, 0xe3, 0xbd, 0x01, 0xc5, 0x4d, 0xf8, 0x64, 0x34, 0x43, 0xbe,
-                0x0f, 0x88, 0x90, 0x32, 0xea, 0x32, 0x5b, 0xf0, 0x71, 0x07, 0xfd, 0x41, 0xd6, 0x73,
-                0xee, 0xba, 0xe6, 0xfa,
-            ],
-            memo: [
-                0xff, 0x63, 0x7b, 0x70, 0xcc, 0x0e, 0xd3, 0xf0, 0x09, 0x58, 0xdf, 0xb8, 0xdc, 0xf0,
-                0x0e, 0x85, 0xa1, 0xd0, 0xa6, 0xa8, 0x90, 0x81, 0x40, 0xc2, 0xf4, 0x34, 0xc2, 0xe2,
-                0x60, 0xef, 0xb0, 0xbc, 0xa2, 0x00, 0x35, 0x04, 0xc9, 0x99, 0x93, 0xa9, 0xe1, 0xc0,
-                0xff, 0x9c, 0xef, 0xe6, 0xa6, 0x65, 0xd7, 0x91, 0x42, 0x86, 0x90, 0xe4, 0x7e, 0xf8,
-                0xc1, 0x31, 0xa8, 0xe9, 0xbf, 0xb4, 0xc3, 0x08, 0x02, 0x35, 0x03, 0x2d, 0x73, 0x1b,
-                0x0d, 0x38, 0x41, 0x22, 0x5f, 0x1c, 0x11, 0xe2, 0xc2, 0x8e, 0xe8, 0x4d, 0x35, 0xf9,
-                0x22, 0x61, 0x00, 0x56, 0x59, 0x72, 0xeb, 0x26, 0x9d, 0x27, 0x8e, 0xf6, 0x49, 0x79,
-                0xbf, 0x65, 0x15, 0xed, 0x4a, 0x68, 0x40, 0xb0, 0x88, 0x3a, 0x9e, 0x6e, 0xf6, 0x4a,
-                0x0e, 0xfc, 0xae, 0x1c, 0xf2, 0x1d, 0xfe, 0x74, 0x85, 0x4e, 0x84, 0xc2, 0x74, 0x9f,
-                0xac, 0x03, 0x82, 0x52, 0x75, 0xc9, 0xb6, 0x30, 0x21, 0x84, 0xc7, 0x2d, 0xf4, 0xc4,
-                0xbb, 0x28, 0x62, 0xe4, 0xe8, 0xa7, 0xd9, 0xa4, 0xa2, 0x82, 0x86, 0x6f, 0x9a, 0x7b,
-                0x2c, 0xfc, 0x9a, 0x56, 0x31, 0x3d, 0xa0, 0xc4, 0x7a, 0x34, 0xb7, 0xb9, 0xcd, 0xa3,
-                0xac, 0xe8, 0x18, 0x5f, 0x07, 0xdf, 0x36, 0xe4, 0x48, 0xa7, 0x6a, 0xa4, 0x77, 0xf2,
-                0x24, 0xd8, 0x7a, 0x07, 0x4f, 0x43, 0xaf, 0x5d, 0x5f, 0x79, 0xb3, 0xab, 0x11, 0x28,
-                0xf0, 0x81, 0x91, 0x44, 0x7f, 0xa6, 0x46, 0xbf, 0xdd, 0xe5, 0xb5, 0x1e, 0x23, 0x3c,
-                0xa6, 0x15, 0x5d, 0x10, 0x15, 0x85, 0xbc, 0x2c, 0x40, 0x15, 0x8a, 0xc2, 0x10, 0x6e,
-                0x66, 0xa2, 0x6e, 0x46, 0x42, 0x33, 0x70, 0x63, 0x68, 0x76, 0xb4, 0x34, 0xa7, 0x4f,
-                0x8c, 0xe8, 0x06, 0x00, 0x50, 0xb0, 0x82, 0xa7, 0x9b, 0x61, 0xbb, 0x5d, 0x34, 0x4e,
-                0xb5, 0xa1, 0x15, 0x83, 0x26, 0xce, 0xd9, 0xa9, 0xd9, 0xf5, 0x4f, 0xb2, 0xfe, 0x8f,
-                0x9f, 0x05, 0xcd, 0x11, 0x1e, 0xe4, 0x6c, 0x47, 0x10, 0xf6, 0xf6, 0x3a, 0x62, 0x69,
-                0x45, 0x57, 0xef, 0x1b, 0x12, 0xc8, 0x80, 0x06, 0xb6, 0x78, 0x72, 0x50, 0x5f, 0x4e,
-                0x88, 0x3b, 0x58, 0x59, 0x07, 0x92, 0x9a, 0x2f, 0x3f, 0xdb, 0x0d, 0x8f, 0x79, 0x14,
-                0xc4, 0x2d, 0xde, 0x2d, 0x20, 0x00, 0xf5, 0xae, 0x02, 0xd4, 0x18, 0x21, 0xc8, 0xe1,
-                0xee, 0x01, 0x38, 0xeb, 0xcb, 0x72, 0x8d, 0x7c, 0x6c, 0x3c, 0x80, 0x02, 0x7e, 0x43,
-                0x75, 0x94, 0xc6, 0x70, 0xfd, 0x6f, 0x39, 0x08, 0x22, 0x2e, 0xe7, 0xa1, 0xb9, 0x17,
-                0xf8, 0x27, 0x1a, 0xbe, 0x66, 0x0e, 0x39, 0xe0, 0x51, 0xaa, 0xa6, 0xfc, 0xa1, 0x86,
-                0x22, 0x76, 0xe2, 0xba, 0xa0, 0xfe, 0x0b, 0x16, 0x2a, 0xeb, 0xcf, 0xe3, 0xd9, 0x34,
-                0x9c, 0x8d, 0x15, 0x4b, 0xb7, 0xee, 0x28, 0x21, 0x2c, 0x1b, 0xaa, 0x70, 0x5d, 0x82,
-                0x07, 0x0d, 0x70, 0x32, 0xf2, 0x69, 0x5d, 0x17, 0x96, 0x80, 0x9f, 0xab, 0x41, 0x24,
-                0x69, 0x26, 0xaf, 0x99, 0x2b, 0x6e, 0xee, 0x95, 0xa9, 0xa0, 0x6b, 0xc4, 0x56, 0x2c,
-                0x5f, 0x2f, 0x1b, 0x19, 0x54, 0x95, 0x00, 0x37, 0x2e, 0x7a, 0xd5, 0x79, 0xa6, 0xd6,
-                0xd7, 0x8b, 0x33, 0x15, 0x31, 0x30, 0xfb, 0x44, 0x8f, 0xb7, 0x9e, 0x8a, 0x66, 0x9d,
-                0xb8, 0xa0, 0xf3, 0x5c, 0xdf, 0x9a, 0xe5, 0xd3, 0x2d, 0x73, 0x2f, 0xc7, 0x94, 0x18,
-                0xe2, 0x3b, 0x45, 0x1d, 0xdc, 0x95, 0xa2, 0x2a, 0xba, 0xbb, 0x05, 0x6e, 0xc6, 0xb5,
-                0xe8, 0xba, 0x4f, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ],
-            cv_net: [
-                0xf4, 0x5c, 0xba, 0x14, 0x6a, 0xe7, 0x18, 0x85, 0xfd, 0x61, 0xb4, 0xa0, 0xf3, 0x6b,
-                0x95, 0x26, 0xa6, 0xe9, 0x4a, 0x49, 0x70, 0x10, 0xe3, 0x2a, 0x8a, 0x76, 0xbc, 0xdf,
-                0xa7, 0x20, 0xb8, 0xa6,
-            ],
-            rho: [
-                0x85, 0x2f, 0x5c, 0x39, 0xd3, 0xf3, 0x55, 0xa3, 0x85, 0xe2, 0xab, 0xd2, 0x54, 0x3a,
-                0xa5, 0xed, 0x09, 0xc6, 0xee, 0x3b, 0x7f, 0x39, 0x34, 0x14, 0xe1, 0x1c, 0xd4, 0x20,
-                0x4c, 0x3f, 0x8d, 0x26,
-            ],
-            cmx: [
-                0x69, 0x4b, 0x6f, 0x3a, 0xb8, 0x37, 0xa9, 0x26, 0xd6, 0x77, 0x3e, 0xc4, 0xa6, 0x76,
-                0x5d, 0xef, 0x82, 0x89, 0x33, 0x74, 0x2d, 0x93, 0x29, 0xfc, 0x88, 0x67, 0x1c, 0xcd,
-                0x81, 0x21, 0xa4, 0x23,
-            ],
-            esk: [
-                0xaa, 0x84, 0x16, 0x79, 0xd4, 0xd2, 0x40, 0xb0, 0xab, 0xc4, 0xa5, 0xd8, 0x9a, 0xa8,
-                0xd6, 0xb3, 0xb0, 0x86, 0x92, 0x23, 0xed, 0x76, 0x3b, 0x67, 0x6a, 0x72, 0xcb, 0x74,
-                0xfb, 0x18, 0xd1, 0x17,
-            ],
-            ephemeral_key: [
-                0x3c, 0x04, 0xbe, 0x6e, 0x42, 0xa6, 0xca, 0x7f, 0x5d, 0xda, 0x0d, 0x82, 0xdf, 0x30,
-                0x7b, 0xd9, 0x6b, 0xb7, 0xb1, 0xae, 0x8d, 0x62, 0x31, 0x87, 0xe3, 0x9c, 0x00, 0xa4,
-                0x8c, 0x25, 0xaa, 0x9d,
-            ],
-            shared_secret: [
-                0x3a, 0x60, 0x2b, 0xaf, 0xb8, 0xa2, 0x66, 0x5a, 0x74, 0xdf, 0x34, 0xab, 0x6e, 0x3c,
-                0x48, 0x8b, 0x09, 0xe2, 0x28, 0x4e, 0xa1, 0x7d, 0x56, 0x02, 0x62, 0xe2, 0x1f, 0x7f,
-                0x3c, 0xba, 0xa3, 0x95,
-            ],
-            k_enc: [
-                0x1b, 0x6d, 0xd1, 0x03, 0x49, 0x63, 0x67, 0xc9, 0x2b, 0x36, 0x8f, 0xc2, 0xf1, 0xc6,
-                0x2e, 0x56, 0xc8, 0xc9, 0xfb, 0xe3, 0x4a, 0x35, 0x84, 0x1f, 0xe1, 0xa3, 0x70, 0x96,
-                0x43, 0xe1, 0x35, 0xe1,
-            ],
-            p_enc: [
-                0x03, 0xfb, 0x8e, 0xa2, 0xcc, 0x0a, 0xd2, 0x30, 0x91, 0x32, 0xfd, 0x11, 0x07, 0xd2,
-                0x7a, 0xc6, 0xec, 0x3c, 0x57, 0x25, 0x0b, 0x39, 0x05, 0xa4, 0xe3, 0xbd, 0x01, 0xc5,
-                0x4d, 0xf8, 0x64, 0x34, 0x43, 0xbe, 0x0f, 0x88, 0x90, 0x32, 0xea, 0x32, 0x5b, 0xf0,
-                0x71, 0x07, 0xfd, 0x41, 0xd6, 0x73, 0xee, 0xba, 0xe6, 0xfa, 0x64, 0xd0, 0x87, 0x40,
-                0x89, 0x86, 0xe7, 0x3d, 0x6e, 0x28, 0x4f, 0xea, 0x9a, 0x23, 0xc3, 0x93, 0x11, 0x78,
-                0x2f, 0x86, 0xca, 0xbf, 0xf9, 0x45, 0x5e, 0x4c, 0xf6, 0x99, 0xe5, 0xf5, 0xd4, 0xbc,
-                0xff, 0x63, 0x7b, 0x70, 0xcc, 0x0e, 0xd3, 0xf0, 0x09, 0x58, 0xdf, 0xb8, 0xdc, 0xf0,
-                0x0e, 0x85, 0xa1, 0xd0, 0xa6, 0xa8, 0x90, 0x81, 0x40, 0xc2, 0xf4, 0x34, 0xc2, 0xe2,
-                0x60, 0xef, 0xb0, 0xbc, 0xa2, 0x00, 0x35, 0x04, 0xc9, 0x99, 0x93, 0xa9, 0xe1, 0xc0,
-                0xff, 0x9c, 0xef, 0xe6, 0xa6, 0x65, 0xd7, 0x91, 0x42, 0x86, 0x90, 0xe4, 0x7e, 0xf8,
-                0xc1, 0x31, 0xa8, 0xe9, 0xbf, 0xb4, 0xc3, 0x08, 0x02, 0x35, 0x03, 0x2d, 0x73, 0x1b,
-                0x0d, 0x38, 0x41, 0x22, 0x5f, 0x1c, 0x11, 0xe2, 0xc2, 0x8e, 0xe8, 0x4d, 0x35, 0xf9,
-                0x22, 0x61, 0x00, 0x56, 0x59, 0x72, 0xeb, 0x26, 0x9d, 0x27, 0x8e, 0xf6, 0x49, 0x79,
-                0xbf, 0x65, 0x15, 0xed, 0x4a, 0x68, 0x40, 0xb0, 0x88, 0x3a, 0x9e, 0x6e, 0xf6, 0x4a,
-                0x0e, 0xfc, 0xae, 0x1c, 0xf2, 0x1d, 0xfe, 0x74, 0x85, 0x4e, 0x84, 0xc2, 0x74, 0x9f,
-                0xac, 0x03, 0x82, 0x52, 0x75, 0xc9, 0xb6, 0x30, 0x21, 0x84, 0xc7, 0x2d, 0xf4, 0xc4,
-                0xbb, 0x28, 0x62, 0xe4, 0xe8, 0xa7, 0xd9, 0xa4, 0xa2, 0x82, 0x86, 0x6f, 0x9a, 0x7b,
-                0x2c, 0xfc, 0x9a, 0x56, 0x31, 0x3d, 0xa0, 0xc4, 0x7a, 0x34, 0xb7, 0xb9, 0xcd, 0xa3,
-                0xac, 0xe8, 0x18, 0x5f, 0x07, 0xdf, 0x36, 0xe4, 0x48, 0xa7, 0x6a, 0xa4, 0x77, 0xf2,
-                0x24, 0xd8, 0x7a, 0x07, 0x4f, 0x43, 0xaf, 0x5d, 0x5f, 0x79, 0xb3, 0xab, 0x11, 0x28,
-                0xf0, 0x81, 0x91, 0x44, 0x7f, 0xa6, 0x46, 0xbf, 0xdd, 0xe5, 0xb5, 0x1e, 0x23, 0x3c,
-                0xa6, 0x15, 0x5d, 0x10, 0x15, 0x85, 0xbc, 0x2c, 0x40, 0x15, 0x8a, 0xc2, 0x10, 0x6e,
-                0x66, 0xa2, 0x6e, 0x46, 0x42, 0x33, 0x70, 0x63, 0x68, 0x76, 0xb4, 0x34, 0xa7, 0x4f,
-                0x8c, 0xe8, 0x06, 0x00, 0x50, 0xb0, 0x82, 0xa7, 0x9b, 0x61, 0xbb, 0x5d, 0x34, 0x4e,
-                0xb5, 0xa1, 0x15, 0x83, 0x26, 0xce, 0xd9, 0xa9, 0xd9, 0xf5, 0x4f, 0xb2, 0xfe, 0x8f,
-                0x9f, 0x05, 0xcd, 0x11, 0x1e, 0xe4, 0x6c, 0x47, 0x10, 0xf6, 0xf6, 0x3a, 0x62, 0x69,
-                0x45, 0x57, 0xef, 0x1b, 0x12, 0xc8, 0x80, 0x06, 0xb6, 0x78, 0x72, 0x50, 0x5f, 0x4e,
-                0x88, 0x3b, 0x58, 0x59, 0x07, 0x92, 0x9a, 0x2f, 0x3f, 0xdb, 0x0d, 0x8f, 0x79, 0x14,
-                0xc4, 0x2d, 0xde, 0x2d, 0x20, 0x00, 0xf5, 0xae, 0x02, 0xd4, 0x18, 0x21, 0xc8, 0xe1,
-                0xee, 0x01, 0x38, 0xeb, 0xcb, 0x72, 0x8d, 0x7c, 0x6c, 0x3c, 0x80, 0x02, 0x7e, 0x43,
-                0x75, 0x94, 0xc6, 0x70, 0xfd, 0x6f, 0x39, 0x08, 0x22, 0x2e, 0xe7, 0xa1, 0xb9, 0x17,
-                0xf8, 0x27, 0x1a, 0xbe, 0x66, 0x0e, 0x39, 0xe0, 0x51, 0xaa, 0xa6, 0xfc, 0xa1, 0x86,
-                0x22, 0x76, 0xe2, 0xba, 0xa0, 0xfe, 0x0b, 0x16, 0x2a, 0xeb, 0xcf, 0xe3, 0xd9, 0x34,
-                0x9c, 0x8d, 0x15, 0x4b, 0xb7, 0xee, 0x28, 0x21, 0x2c, 0x1b, 0xaa, 0x70, 0x5d, 0x82,
-                0x07, 0x0d, 0x70, 0x32, 0xf2, 0x69, 0x5d, 0x17, 0x96, 0x80, 0x9f, 0xab, 0x41, 0x24,
-                0x69, 0x26, 0xaf, 0x99, 0x2b, 0x6e, 0xee, 0x95, 0xa9, 0xa0, 0x6b, 0xc4, 0x56, 0x2c,
-                0x5f, 0x2f, 0x1b, 0x19, 0x54, 0x95, 0x00, 0x37, 0x2e, 0x7a, 0xd5, 0x79, 0xa6, 0xd6,
-                0xd7, 0x8b, 0x33, 0x15, 0x31, 0x30, 0xfb, 0x44, 0x8f, 0xb7, 0x9e, 0x8a, 0x66, 0x9d,
-                0xb8, 0xa0, 0xf3, 0x5c, 0xdf, 0x9a, 0xe5, 0xd3, 0x2d, 0x73, 0x2f, 0xc7, 0x94, 0x18,
-                0xe2, 0x3b, 0x45, 0x1d, 0xdc, 0x95, 0xa2, 0x2a, 0xba, 0xbb, 0x05, 0x6e, 0xc6, 0xb5,
-                0xe8, 0xba, 0x4f, 0x52,
-            ],
-            c_enc: [
-                0xb4, 0x15, 0x88, 0x23, 0x1d, 0x6b, 0xa2, 0x9c, 0xc5, 0xb9, 0xaa, 0xf0, 0xc1, 0xf0,
-                0xba, 0x44, 0x16, 0x6e, 0xdb, 0x8a, 0x27, 0x29, 0xca, 0xba, 0x53, 0x71, 0xe7, 0xac,
-                0x36, 0x90, 0x0f, 0xaa, 0x64, 0xf5, 0x76, 0x0d, 0xce, 0x55, 0x20, 0xda, 0x82, 0x8d,
-                0x5e, 0x25, 0xbd, 0x83, 0x51, 0x95, 0x11, 0x64, 0x12, 0x11, 0x80, 0x9d, 0xff, 0xd8,
-                0xcf, 0xeb, 0xff, 0xf3, 0xcd, 0xdc, 0xd2, 0x75, 0x88, 0x1e, 0x39, 0xb6, 0x3d, 0xac,
-                0x4d, 0x98, 0x6b, 0x10, 0xc0, 0xe4, 0xc5, 0x52, 0x63, 0xde, 0x3e, 0x02, 0x54, 0x94,
-                0x81, 0x8a, 0x38, 0x08, 0xd9, 0xab, 0xc6, 0xec, 0x38, 0x8f, 0x95, 0x26, 0x73, 0x95,
-                0x0a, 0xa2, 0xd0, 0xe4, 0xba, 0x00, 0x53, 0x75, 0xac, 0x60, 0x5d, 0xc8, 0x25, 0xde,
-                0x4d, 0xd8, 0x93, 0x8b, 0x94, 0x7f, 0xf7, 0x19, 0x4c, 0xfe, 0x7c, 0x1d, 0x79, 0xa1,
-                0x27, 0x15, 0x5d, 0x11, 0xcb, 0xe3, 0x43, 0xf3, 0x2f, 0xd1, 0x0c, 0x7d, 0xae, 0x39,
-                0x1f, 0x00, 0xb4, 0x4f, 0xbe, 0x30, 0x1c, 0x63, 0xfd, 0x4b, 0xf1, 0xc0, 0xdf, 0xb6,
-                0xc9, 0xec, 0xb4, 0xc3, 0xf3, 0xfe, 0xf5, 0x40, 0xb6, 0x7e, 0xb9, 0x23, 0x13, 0x71,
-                0x9c, 0x5a, 0x30, 0x7a, 0xd3, 0x95, 0x6b, 0xb9, 0x4e, 0x29, 0x86, 0x85, 0x2a, 0x64,
-                0x5a, 0x95, 0xd6, 0xdc, 0x75, 0xaa, 0x27, 0x4c, 0xcf, 0xd2, 0x71, 0xd0, 0xea, 0xe2,
-                0x65, 0x81, 0xf5, 0xf5, 0x5d, 0x64, 0x74, 0xaa, 0xad, 0x37, 0x4c, 0x86, 0x45, 0x05,
-                0xe6, 0x92, 0x37, 0xf6, 0x66, 0x99, 0xee, 0x39, 0xe9, 0xfc, 0xf5, 0xb1, 0xb7, 0x03,
-                0x35, 0x1e, 0x71, 0xf6, 0x3b, 0x02, 0x33, 0x40, 0x82, 0xee, 0xbe, 0xd8, 0x68, 0xb5,
-                0x61, 0x2a, 0x33, 0x95, 0x78, 0x5a, 0x33, 0x2a, 0x52, 0x43, 0xe4, 0x98, 0x6e, 0x1f,
-                0xf5, 0xb4, 0x2d, 0x06, 0x69, 0xc1, 0x5c, 0x45, 0xff, 0x81, 0xe2, 0x2e, 0xea, 0xe4,
-                0xde, 0x7d, 0x9a, 0x4f, 0x57, 0x24, 0xc8, 0x96, 0x03, 0x94, 0x92, 0x5b, 0xa1, 0xa1,
-                0x90, 0x0f, 0xa2, 0xb5, 0x59, 0x3d, 0x55, 0x45, 0x5e, 0x0b, 0xe0, 0x31, 0x8c, 0x80,
-                0x23, 0x81, 0xec, 0x9c, 0x0a, 0x83, 0xc2, 0xe5, 0xf9, 0x33, 0x9f, 0x02, 0x9c, 0x44,
-                0x24, 0x72, 0x8f, 0x91, 0x9d, 0x18, 0x4f, 0x36, 0x16, 0x50, 0xba, 0x65, 0xd6, 0x98,
-                0xa8, 0xd1, 0x67, 0xbe, 0xd9, 0xdd, 0x01, 0xfa, 0x70, 0x74, 0xe4, 0x6a, 0xf6, 0x57,
-                0x16, 0xdd, 0xd9, 0x7e, 0x7b, 0xb6, 0x00, 0x13, 0x05, 0x96, 0x8c, 0xd5, 0xb4, 0x87,
-                0x0d, 0xf2, 0x00, 0x42, 0xe7, 0x69, 0xe0, 0x2d, 0xf1, 0x8b, 0x9f, 0xde, 0x9f, 0xda,
-                0xa7, 0x6b, 0x00, 0xca, 0x26, 0x45, 0x9d, 0x54, 0x37, 0x19, 0x19, 0x72, 0xd7, 0x08,
-                0xde, 0xda, 0xbf, 0x1d, 0x61, 0x7f, 0x73, 0x3a, 0x60, 0xeb, 0xfe, 0xc6, 0xac, 0xf0,
-                0x0b, 0xb1, 0xdf, 0xbf, 0x11, 0x2d, 0x3a, 0xaa, 0xc9, 0xfb, 0xd2, 0x30, 0xcc, 0xaa,
-                0x9c, 0xf3, 0x58, 0x45, 0x93, 0x54, 0xac, 0x5b, 0x29, 0xbd, 0xb7, 0x3a, 0x45, 0x27,
-                0x1b, 0x1f, 0x9e, 0xd0, 0x0e, 0x3e, 0x20, 0xb1, 0x2f, 0xed, 0x5c, 0xd5, 0x6a, 0xbb,
-                0xb0, 0xb9, 0x4a, 0x9e, 0xee, 0x5f, 0xf8, 0xf9, 0x36, 0x1d, 0xfd, 0x6c, 0x94, 0x08,
-                0x5d, 0x28, 0x98, 0xe5, 0x46, 0xeb, 0x92, 0xe6, 0xdb, 0xe9, 0xf0, 0x2e, 0xb5, 0xbf,
-                0x7d, 0x12, 0x67, 0x5d, 0x3c, 0x6a, 0xc7, 0x18, 0x4b, 0x26, 0x01, 0xe4, 0xf4, 0x05,
-                0x37, 0x3a, 0x4f, 0x1c, 0x5d, 0xf7, 0x6b, 0x3c, 0xb5, 0x29, 0x99, 0xd8, 0x0f, 0x59,
-                0xb3, 0x94, 0xbc, 0xed, 0x9f, 0x66, 0xbc, 0xf7, 0xdc, 0x37, 0xc2, 0xb4, 0xc6, 0xf7,
-                0x74, 0x5b, 0xc6, 0xf0, 0x37, 0x74, 0xfa, 0xc6, 0x24, 0x5d, 0x7c, 0x63, 0x6d, 0xfc,
-                0x5f, 0x76, 0x58, 0xb2, 0xd2, 0xfd, 0x84, 0xac, 0xa9, 0xe0, 0xef, 0xcd, 0xe0, 0x09,
-                0x3e, 0x62, 0x29, 0x38, 0xb7, 0x5d, 0xae, 0x66, 0xcf, 0x63, 0xf6, 0xd2, 0x35, 0x17,
-                0x2e, 0x5a, 0x0b, 0xbe, 0xcd, 0x15, 0x56, 0x6c, 0x61, 0xfe, 0x5a, 0x58, 0x94, 0x7c,
-                0x18, 0xb9, 0xb5, 0xa1, 0x21, 0x11, 0x25, 0x94, 0x3b, 0x09, 0x32, 0x24, 0x96, 0x7b,
-                0x7e, 0x44, 0x16, 0x70, 0x64, 0xc9,
-            ],
-            ock: [
-                0x67, 0x1c, 0xed, 0xd6, 0xf5, 0x73, 0xa4, 0x6f, 0xf1, 0xea, 0xd0, 0x48, 0x21, 0x98,
-                0x56, 0x36, 0xe2, 0x3f, 0xb1, 0x5c, 0x6f, 0x48, 0x05, 0xfd, 0x57, 0x63, 0x12, 0xc2,
-                0x07, 0x02, 0xa4, 0x24,
-            ],
-            op: [
-                0xcc, 0x18, 0xe4, 0xb6, 0x5f, 0x89, 0x34, 0x06, 0x31, 0x5d, 0xb7, 0x1f, 0xac, 0x06,
-                0x5d, 0x71, 0xd0, 0xea, 0xba, 0x7c, 0xf3, 0xc2, 0xba, 0x94, 0x77, 0x12, 0x32, 0x75,
-                0x43, 0x4b, 0x1e, 0xb0, 0xaa, 0x84, 0x16, 0x79, 0xd4, 0xd2, 0x40, 0xb0, 0xab, 0xc4,
-                0xa5, 0xd8, 0x9a, 0xa8, 0xd6, 0xb3, 0xb0, 0x86, 0x92, 0x23, 0xed, 0x76, 0x3b, 0x67,
-                0x6a, 0x72, 0xcb, 0x74, 0xfb, 0x18, 0xd1, 0x17,
-            ],
-            c_out: [
-                0x59, 0x97, 0x53, 0xe4, 0x0a, 0xda, 0xea, 0xff, 0x6f, 0xaa, 0xf5, 0xa6, 0xf3, 0x0e,
-                0x39, 0x13, 0x8f, 0xde, 0x82, 0x0f, 0x7b, 0xec, 0x7c, 0x8d, 0x0f, 0xd8, 0x4b, 0x48,
-                0x36, 0x94, 0xe5, 0x0c, 0x4b, 0xdd, 0xee, 0x2f, 0xb1, 0xa4, 0xf9, 0x95, 0xb1, 0xa3,
-                0xba, 0x40, 0xf4, 0x66, 0xb4, 0x2e, 0x8b, 0x5d, 0x01, 0x38, 0xfd, 0x30, 0xbf, 0xf6,
-                0xae, 0x8c, 0xb1, 0x55, 0xf4, 0x0c, 0xdc, 0x37, 0x39, 0xfa, 0xbf, 0x2f, 0x00, 0xda,
-                0x3a, 0xc6, 0xa7, 0x36, 0x3b, 0xc2, 0xf4, 0xaa, 0x10, 0xfe,
-            ],
-            asset: Some([
-                0x64, 0xd0, 0x87, 0x40, 0x89, 0x86, 0xe7, 0x3d, 0x6e, 0x28, 0x4f, 0xea, 0x9a, 0x23,
-                0xc3, 0x93, 0x11, 0x78, 0x2f, 0x86, 0xca, 0xbf, 0xf9, 0x45, 0x5e, 0x4c, 0xf6, 0x99,
-                0xe5, 0xf5, 0xd4, 0xbc,
-            ]),
-        },
-        TestVector {
-            incoming_viewing_key: [
-                0xb4, 0x9e, 0x3c, 0x5b, 0xb9, 0x9e, 0x47, 0xc5, 0x3d, 0x6e, 0x5c, 0x34, 0x7c, 0x99,
-                0x8f, 0x30, 0x2d, 0x3f, 0xf4, 0x75, 0x23, 0xe7, 0xc3, 0xd7, 0xb6, 0x4c, 0x82, 0x98,
-                0xdc, 0x7b, 0x10, 0xe9, 0x54, 0xdf, 0x06, 0x00, 0x0b, 0xc0, 0xcc, 0x30, 0xec, 0xf6,
-                0x75, 0x5d, 0x92, 0x7e, 0xee, 0xce, 0xe6, 0xec, 0x9e, 0x8e, 0x0c, 0xba, 0xa3, 0x1b,
-                0x71, 0xe0, 0xa4, 0x33, 0x4a, 0xd6, 0x42, 0x1b,
-            ],
-            ovk: [
-                0x97, 0x9f, 0x06, 0x58, 0x66, 0x73, 0xbc, 0x6f, 0xf1, 0xc5, 0xd3, 0xb3, 0x20, 0xf3,
-                0x49, 0xa5, 0xb3, 0xa8, 0xb3, 0x55, 0x59, 0x22, 0x96, 0xaa, 0xf6, 0x1c, 0x5b, 0x72,
-                0x52, 0xf7, 0x3e, 0xc0,
-            ],
-            default_d: [
-                0x8d, 0xb1, 0x31, 0xa6, 0x5b, 0xa6, 0xca, 0x91, 0xc9, 0xe9, 0x7b,
-            ],
-            default_pk_d: [
-                0x6f, 0xce, 0x26, 0xab, 0xe6, 0xc0, 0xb6, 0x84, 0x37, 0x36, 0x96, 0x46, 0xee, 0xe1,
-                0xe9, 0xdc, 0xa5, 0x1a, 0x42, 0x58, 0xf3, 0xae, 0x72, 0x23, 0x87, 0xf6, 0xd0, 0xdf,
-                0xf4, 0x1a, 0x1f, 0x88,
-            ],
-            v: 5531329397987978327,
-            rseed: [
-                0x1f, 0xbd, 0x83, 0xd5, 0x4a, 0xaf, 0x44, 0x1e, 0x31, 0x9e, 0xa4, 0x7a, 0x86, 0x2a,
-                0xd0, 0x29, 0x3c, 0xed, 0xf5, 0xdd, 0x9e, 0xda, 0xde, 0xee, 0x33, 0xcb, 0x52, 0x2c,
-                0xd0, 0x11, 0x8b, 0xbd,
-            ],
-            memo: [
-                0xff, 0x81, 0x1a, 0xce, 0x9a, 0x23, 0xbd, 0xa3, 0x9a, 0xba, 0x72, 0xf1, 0x56, 0x6f,
-                0xc1, 0x68, 0x84, 0x97, 0xd2, 0xa7, 0x92, 0x8c, 0x36, 0x70, 0x15, 0x25, 0x67, 0x8b,
-                0xc9, 0x72, 0x14, 0xb3, 0x1b, 0x37, 0xba, 0xb4, 0x6b, 0x88, 0xf2, 0x7f, 0x04, 0x48,
-                0xde, 0xcb, 0x31, 0x62, 0x2d, 0x0f, 0x0f, 0x87, 0xa8, 0x55, 0xba, 0x54, 0x00, 0x03,
-                0x32, 0x03, 0x1f, 0x73, 0xab, 0xff, 0xd4, 0x65, 0x91, 0xda, 0x0b, 0x88, 0x72, 0x35,
-                0x04, 0xed, 0xb2, 0x33, 0x72, 0x30, 0xda, 0xd2, 0xac, 0xc0, 0xd8, 0xbb, 0x68, 0xbc,
-                0x83, 0x7a, 0x2f, 0xf9, 0x30, 0xbf, 0xf0, 0x6f, 0xde, 0x74, 0xeb, 0x90, 0xaa, 0xe4,
-                0xf6, 0x0d, 0xbb, 0x6e, 0xb8, 0x27, 0xea, 0x99, 0x88, 0x4a, 0xcd, 0x62, 0x85, 0xa9,
-                0x88, 0x92, 0x80, 0x2c, 0xf5, 0x9d, 0x5d, 0x60, 0xd0, 0x16, 0x63, 0x38, 0x7b, 0x3e,
-                0xd2, 0x72, 0x3b, 0xd6, 0x48, 0x9e, 0x9c, 0x2c, 0x10, 0x6d, 0x4a, 0xa2, 0xde, 0x23,
-                0xce, 0xd1, 0x6c, 0x72, 0x04, 0x29, 0xc7, 0x75, 0x3a, 0x77, 0x38, 0xec, 0x7d, 0x9d,
-                0xb8, 0x62, 0x42, 0x29, 0xed, 0xd2, 0x17, 0xb8, 0x0d, 0x74, 0x87, 0x5a, 0x14, 0xca,
-                0xe4, 0x86, 0x3f, 0x13, 0x9e, 0x9c, 0x0b, 0x13, 0x1b, 0x2a, 0x4c, 0x28, 0x07, 0x1a,
-                0x38, 0xec, 0x61, 0xf6, 0x68, 0x01, 0xaa, 0x59, 0x56, 0xfc, 0xb2, 0xa4, 0x6b, 0x95,
-                0x87, 0x66, 0x5b, 0x75, 0x71, 0xaa, 0x03, 0x48, 0x1f, 0xd8, 0xd9, 0xd5, 0x69, 0x8f,
-                0x83, 0x6f, 0xc8, 0x63, 0x5e, 0x69, 0xe3, 0xbd, 0xe4, 0x2f, 0x4a, 0xc0, 0x71, 0x32,
-                0x8b, 0x54, 0x09, 0xf6, 0xe4, 0x2d, 0x79, 0x0a, 0xed, 0xd7, 0x3b, 0xc1, 0xa2, 0x35,
-                0x47, 0x23, 0xb3, 0xb8, 0x19, 0xd0, 0x63, 0x7a, 0x6f, 0xa4, 0x66, 0x39, 0x46, 0xa3,
-                0x0a, 0xc5, 0xaf, 0xdd, 0x30, 0xce, 0x83, 0x0f, 0x67, 0x91, 0xb4, 0x57, 0x52, 0x70,
-                0xa1, 0x72, 0x0f, 0x91, 0x86, 0x6e, 0x2b, 0x86, 0xf4, 0x78, 0x88, 0x94, 0xc8, 0xda,
-                0x62, 0xd8, 0xb9, 0x1f, 0xaf, 0x52, 0x0e, 0x3b, 0xed, 0xbc, 0x12, 0x06, 0xa5, 0xa5,
-                0xe6, 0xef, 0xd3, 0xdf, 0xde, 0x08, 0x43, 0xc3, 0xb0, 0x67, 0x57, 0x64, 0x3f, 0xc0,
-                0x06, 0x00, 0x88, 0x38, 0xca, 0x47, 0x30, 0x87, 0xf8, 0x97, 0x79, 0x18, 0xcc, 0x1b,
-                0x81, 0xc9, 0xe6, 0x8e, 0x3b, 0x88, 0x8f, 0xe6, 0xf7, 0xc6, 0x30, 0xf1, 0xbc, 0x7a,
-                0xe1, 0x88, 0xf5, 0x12, 0x84, 0x20, 0x41, 0xca, 0xda, 0x1e, 0x05, 0xf8, 0x66, 0xd2,
-                0x56, 0x2d, 0xbe, 0x09, 0xc4, 0xb4, 0x30, 0x68, 0xf7, 0x54, 0xda, 0xd3, 0x4d, 0xf0,
-                0xfc, 0xfc, 0x18, 0x1f, 0x31, 0x80, 0x1a, 0x79, 0x92, 0xd2, 0xf1, 0x6b, 0xe0, 0x21,
-                0x1b, 0x4a, 0x22, 0xf6, 0x2a, 0xab, 0x64, 0x70, 0x1b, 0xf4, 0xa4, 0xe6, 0xd6, 0x66,
-                0xfc, 0x30, 0x4a, 0x5c, 0x79, 0xc6, 0x09, 0xac, 0xc4, 0x3b, 0x00, 0xb4, 0x86, 0x48,
-                0x93, 0xd3, 0x7d, 0x50, 0x07, 0xf0, 0xc3, 0x29, 0xa4, 0x75, 0x50, 0x52, 0x57, 0x75,
-                0x70, 0xdd, 0x38, 0xfa, 0xc0, 0x43, 0xcd, 0x91, 0xc1, 0x2e, 0xe3, 0x4e, 0x9c, 0xfa,
-                0xe3, 0x92, 0xa7, 0x8b, 0xda, 0xbd, 0x4e, 0xe3, 0x1d, 0xc0, 0xde, 0xb0, 0x2f, 0xe7,
-                0xb1, 0xd8, 0xb0, 0x17, 0x8a, 0xc9, 0x51, 0x31, 0x05, 0xfc, 0xc7, 0xe3, 0x0b, 0xa8,
-                0xe0, 0x16, 0xaa, 0x36, 0xa6, 0xb5, 0xdf, 0x5e, 0x5a, 0x19, 0x09, 0xf6, 0x3a, 0xba,
-                0x09, 0x5d, 0x98, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ],
-            cv_net: [
-                0x1a, 0xa2, 0x3d, 0x96, 0x79, 0xbc, 0x66, 0x04, 0xb6, 0x25, 0x2c, 0x4f, 0x48, 0x1b,
-                0x3a, 0x2a, 0xf5, 0x46, 0x32, 0xf8, 0x30, 0x08, 0x14, 0x68, 0x29, 0x65, 0x94, 0x5e,
-                0x7e, 0x33, 0x2a, 0x0d,
-            ],
-            rho: [
-                0x09, 0x1d, 0x83, 0x73, 0x3a, 0x9f, 0xfb, 0x18, 0xc1, 0x7a, 0xd1, 0x93, 0x8d, 0xd2,
-                0x67, 0x93, 0xc3, 0xfe, 0xfa, 0xda, 0xee, 0xa8, 0xe2, 0x3c, 0x44, 0xd5, 0xe0, 0x18,
-                0x4b, 0xc8, 0x45, 0x10,
-            ],
-            cmx: [
-                0x76, 0xf1, 0xbd, 0x50, 0xf9, 0xb9, 0x06, 0xcb, 0x9f, 0xf2, 0xdd, 0x91, 0x8a, 0x36,
-                0x7e, 0x5f, 0xb1, 0xa2, 0xef, 0x39, 0xf1, 0x4f, 0x6c, 0xe9, 0x4f, 0xf9, 0xf0, 0x91,
-                0x55, 0xf8, 0xc2, 0x11,
-            ],
-            esk: [
-                0x2f, 0x98, 0x2d, 0xec, 0xa7, 0x60, 0x51, 0x41, 0xd9, 0xc9, 0xa1, 0xe6, 0xfb, 0x57,
-                0xe2, 0xb8, 0x01, 0xb4, 0x49, 0x6f, 0xbd, 0xd4, 0xc0, 0xa8, 0xb9, 0x5f, 0xc8, 0x7e,
-                0xa7, 0x37, 0x3e, 0x2f,
-            ],
-            ephemeral_key: [
-                0xda, 0x72, 0x84, 0xa0, 0xe0, 0xde, 0x52, 0x09, 0x3c, 0xc2, 0xe1, 0x9c, 0x0a, 0xf1,
-                0x93, 0xbd, 0xb4, 0x2c, 0x80, 0xc9, 0xc7, 0xf9, 0xf2, 0x36, 0x00, 0xe6, 0x08, 0x01,
-                0x72, 0xc5, 0xf5, 0x39,
-            ],
-            shared_secret: [
-                0x9b, 0xcf, 0xb9, 0x6f, 0x4c, 0xf1, 0x83, 0xc1, 0x7f, 0xb1, 0x99, 0xda, 0x16, 0x5f,
-                0xbf, 0x8a, 0x47, 0x47, 0x7e, 0x00, 0x36, 0x6d, 0x1c, 0xb7, 0x3b, 0x32, 0xec, 0x0e,
-                0x3a, 0xc1, 0x98, 0x0f,
-            ],
-            k_enc: [
-                0x21, 0xe0, 0x97, 0x87, 0x0a, 0xee, 0xc0, 0x19, 0x76, 0x86, 0xee, 0x37, 0x22, 0x78,
-                0xfe, 0x4a, 0xa2, 0x23, 0x8d, 0x87, 0x65, 0x32, 0x63, 0x84, 0x8a, 0x2f, 0xf5, 0x27,
-                0x9f, 0x2b, 0x1d, 0x9b,
-            ],
-            p_enc: [
-                0x03, 0x8d, 0xb1, 0x31, 0xa6, 0x5b, 0xa6, 0xca, 0x91, 0xc9, 0xe9, 0x7b, 0x57, 0xac,
-                0xbf, 0xfe, 0xc7, 0x3a, 0xc3, 0x4c, 0x1f, 0xbd, 0x83, 0xd5, 0x4a, 0xaf, 0x44, 0x1e,
-                0x31, 0x9e, 0xa4, 0x7a, 0x86, 0x2a, 0xd0, 0x29, 0x3c, 0xed, 0xf5, 0xdd, 0x9e, 0xda,
-                0xde, 0xee, 0x33, 0xcb, 0x52, 0x2c, 0xd0, 0x11, 0x8b, 0xbd, 0xc3, 0xcc, 0x4f, 0x43,
-                0xfa, 0x01, 0x88, 0x52, 0x1b, 0xc6, 0x1b, 0x21, 0xdd, 0x04, 0xe3, 0x7a, 0x83, 0xec,
-                0xe6, 0x8c, 0xa7, 0xa2, 0xfa, 0x6c, 0x8f, 0x9e, 0x34, 0xa6, 0x29, 0x03, 0x35, 0xaa,
-                0xff, 0x81, 0x1a, 0xce, 0x9a, 0x23, 0xbd, 0xa3, 0x9a, 0xba, 0x72, 0xf1, 0x56, 0x6f,
-                0xc1, 0x68, 0x84, 0x97, 0xd2, 0xa7, 0x92, 0x8c, 0x36, 0x70, 0x15, 0x25, 0x67, 0x8b,
-                0xc9, 0x72, 0x14, 0xb3, 0x1b, 0x37, 0xba, 0xb4, 0x6b, 0x88, 0xf2, 0x7f, 0x04, 0x48,
-                0xde, 0xcb, 0x31, 0x62, 0x2d, 0x0f, 0x0f, 0x87, 0xa8, 0x55, 0xba, 0x54, 0x00, 0x03,
-                0x32, 0x03, 0x1f, 0x73, 0xab, 0xff, 0xd4, 0x65, 0x91, 0xda, 0x0b, 0x88, 0x72, 0x35,
-                0x04, 0xed, 0xb2, 0x33, 0x72, 0x30, 0xda, 0xd2, 0xac, 0xc0, 0xd8, 0xbb, 0x68, 0xbc,
-                0x83, 0x7a, 0x2f, 0xf9, 0x30, 0xbf, 0xf0, 0x6f, 0xde, 0x74, 0xeb, 0x90, 0xaa, 0xe4,
-                0xf6, 0x0d, 0xbb, 0x6e, 0xb8, 0x27, 0xea, 0x99, 0x88, 0x4a, 0xcd, 0x62, 0x85, 0xa9,
-                0x88, 0x92, 0x80, 0x2c, 0xf5, 0x9d, 0x5d, 0x60, 0xd0, 0x16, 0x63, 0x38, 0x7b, 0x3e,
-                0xd2, 0x72, 0x3b, 0xd6, 0x48, 0x9e, 0x9c, 0x2c, 0x10, 0x6d, 0x4a, 0xa2, 0xde, 0x23,
-                0xce, 0xd1, 0x6c, 0x72, 0x04, 0x29, 0xc7, 0x75, 0x3a, 0x77, 0x38, 0xec, 0x7d, 0x9d,
-                0xb8, 0x62, 0x42, 0x29, 0xed, 0xd2, 0x17, 0xb8, 0x0d, 0x74, 0x87, 0x5a, 0x14, 0xca,
-                0xe4, 0x86, 0x3f, 0x13, 0x9e, 0x9c, 0x0b, 0x13, 0x1b, 0x2a, 0x4c, 0x28, 0x07, 0x1a,
-                0x38, 0xec, 0x61, 0xf6, 0x68, 0x01, 0xaa, 0x59, 0x56, 0xfc, 0xb2, 0xa4, 0x6b, 0x95,
-                0x87, 0x66, 0x5b, 0x75, 0x71, 0xaa, 0x03, 0x48, 0x1f, 0xd8, 0xd9, 0xd5, 0x69, 0x8f,
-                0x83, 0x6f, 0xc8, 0x63, 0x5e, 0x69, 0xe3, 0xbd, 0xe4, 0x2f, 0x4a, 0xc0, 0x71, 0x32,
-                0x8b, 0x54, 0x09, 0xf6, 0xe4, 0x2d, 0x79, 0x0a, 0xed, 0xd7, 0x3b, 0xc1, 0xa2, 0x35,
-                0x47, 0x23, 0xb3, 0xb8, 0x19, 0xd0, 0x63, 0x7a, 0x6f, 0xa4, 0x66, 0x39, 0x46, 0xa3,
-                0x0a, 0xc5, 0xaf, 0xdd, 0x30, 0xce, 0x83, 0x0f, 0x67, 0x91, 0xb4, 0x57, 0x52, 0x70,
-                0xa1, 0x72, 0x0f, 0x91, 0x86, 0x6e, 0x2b, 0x86, 0xf4, 0x78, 0x88, 0x94, 0xc8, 0xda,
-                0x62, 0xd8, 0xb9, 0x1f, 0xaf, 0x52, 0x0e, 0x3b, 0xed, 0xbc, 0x12, 0x06, 0xa5, 0xa5,
-                0xe6, 0xef, 0xd3, 0xdf, 0xde, 0x08, 0x43, 0xc3, 0xb0, 0x67, 0x57, 0x64, 0x3f, 0xc0,
-                0x06, 0x00, 0x88, 0x38, 0xca, 0x47, 0x30, 0x87, 0xf8, 0x97, 0x79, 0x18, 0xcc, 0x1b,
-                0x81, 0xc9, 0xe6, 0x8e, 0x3b, 0x88, 0x8f, 0xe6, 0xf7, 0xc6, 0x30, 0xf1, 0xbc, 0x7a,
-                0xe1, 0x88, 0xf5, 0x12, 0x84, 0x20, 0x41, 0xca, 0xda, 0x1e, 0x05, 0xf8, 0x66, 0xd2,
-                0x56, 0x2d, 0xbe, 0x09, 0xc4, 0xb4, 0x30, 0x68, 0xf7, 0x54, 0xda, 0xd3, 0x4d, 0xf0,
-                0xfc, 0xfc, 0x18, 0x1f, 0x31, 0x80, 0x1a, 0x79, 0x92, 0xd2, 0xf1, 0x6b, 0xe0, 0x21,
-                0x1b, 0x4a, 0x22, 0xf6, 0x2a, 0xab, 0x64, 0x70, 0x1b, 0xf4, 0xa4, 0xe6, 0xd6, 0x66,
-                0xfc, 0x30, 0x4a, 0x5c, 0x79, 0xc6, 0x09, 0xac, 0xc4, 0x3b, 0x00, 0xb4, 0x86, 0x48,
-                0x93, 0xd3, 0x7d, 0x50, 0x07, 0xf0, 0xc3, 0x29, 0xa4, 0x75, 0x50, 0x52, 0x57, 0x75,
-                0x70, 0xdd, 0x38, 0xfa, 0xc0, 0x43, 0xcd, 0x91, 0xc1, 0x2e, 0xe3, 0x4e, 0x9c, 0xfa,
-                0xe3, 0x92, 0xa7, 0x8b, 0xda, 0xbd, 0x4e, 0xe3, 0x1d, 0xc0, 0xde, 0xb0, 0x2f, 0xe7,
-                0xb1, 0xd8, 0xb0, 0x17, 0x8a, 0xc9, 0x51, 0x31, 0x05, 0xfc, 0xc7, 0xe3, 0x0b, 0xa8,
-                0xe0, 0x16, 0xaa, 0x36, 0xa6, 0xb5, 0xdf, 0x5e, 0x5a, 0x19, 0x09, 0xf6, 0x3a, 0xba,
-                0x09, 0x5d, 0x98, 0x77,
-            ],
-            c_enc: [
-                0x13, 0xd7, 0xdf, 0xcd, 0x1d, 0x75, 0x4d, 0xcd, 0x16, 0x52, 0x32, 0x83, 0x8f, 0x14,
-                0xdd, 0x80, 0x5e, 0x12, 0xcc, 0x7e, 0x75, 0x15, 0x43, 0xd2, 0xa6, 0x8e, 0x23, 0x7a,
-                0x92, 0x3b, 0xce, 0xeb, 0xa3, 0x5a, 0x62, 0x43, 0xc6, 0xa4, 0xc5, 0xf0, 0xd2, 0xa4,
-                0xc3, 0x86, 0x07, 0xa6, 0xf1, 0x1b, 0x17, 0xfd, 0xd6, 0xc6, 0x92, 0x66, 0xf2, 0xc9,
-                0x6a, 0xdc, 0x44, 0x6f, 0x2e, 0x2d, 0x07, 0x3e, 0xe9, 0xea, 0xe2, 0x9a, 0x37, 0xef,
-                0x5d, 0x03, 0xf6, 0x78, 0xf5, 0x56, 0x29, 0x45, 0xb2, 0x08, 0x27, 0x76, 0xce, 0x9f,
-                0x39, 0x08, 0x87, 0x3a, 0x99, 0xa6, 0xa2, 0x8b, 0xae, 0xdc, 0x7f, 0x54, 0x89, 0xce,
-                0x4b, 0x30, 0xd8, 0x43, 0x66, 0xc5, 0x46, 0xb4, 0x36, 0x67, 0x91, 0x44, 0xf9, 0x27,
-                0xf7, 0x1c, 0x65, 0x09, 0x69, 0xda, 0x22, 0x42, 0x28, 0x5a, 0x86, 0x27, 0x96, 0x54,
-                0x89, 0xb7, 0x0b, 0x35, 0x6c, 0xf7, 0x4e, 0x07, 0x8a, 0xa2, 0x7d, 0xa8, 0xf9, 0x2f,
-                0xb3, 0x09, 0x57, 0x12, 0x62, 0xf2, 0xd4, 0xc3, 0x36, 0xf7, 0x12, 0x15, 0x9b, 0x3e,
-                0x9b, 0x43, 0x24, 0x38, 0x5b, 0xb3, 0x26, 0x2a, 0xc5, 0xf3, 0x13, 0x57, 0xaf, 0x9e,
-                0x1a, 0xaa, 0x75, 0xd0, 0x1c, 0x06, 0x31, 0xbf, 0xdd, 0x34, 0xc5, 0x9b, 0x27, 0xd5,
-                0x3b, 0xeb, 0xf1, 0xaa, 0x54, 0xe9, 0xc4, 0xaa, 0x98, 0x0f, 0x24, 0x7b, 0xf4, 0x22,
-                0xa0, 0xe6, 0xdb, 0xf5, 0x54, 0x6e, 0xdc, 0x10, 0x0f, 0xce, 0x6c, 0xce, 0xc8, 0x32,
-                0x7e, 0xb4, 0x8a, 0x9a, 0x39, 0xe4, 0xc2, 0xa9, 0x12, 0xb2, 0x98, 0x85, 0xe0, 0xc3,
-                0xe7, 0x33, 0x55, 0x58, 0xbd, 0x85, 0x84, 0x38, 0xd0, 0x35, 0xd2, 0xf2, 0xbe, 0x1d,
-                0x35, 0x66, 0xe4, 0x22, 0xfe, 0x37, 0xc0, 0xcb, 0x2e, 0x05, 0x8d, 0xad, 0x8c, 0xc6,
-                0x45, 0x62, 0xa5, 0x50, 0x1b, 0x54, 0xa4, 0x4f, 0x9a, 0x77, 0x77, 0xc6, 0xd2, 0x77,
-                0x04, 0xa4, 0xce, 0xad, 0x26, 0xa1, 0xc2, 0x56, 0x01, 0x8d, 0xc1, 0xbb, 0xfa, 0x58,
-                0x84, 0xa0, 0x6c, 0xc7, 0x25, 0x23, 0xaf, 0xfb, 0x43, 0xf5, 0xc5, 0xbc, 0x2f, 0x1d,
-                0x36, 0x04, 0x0f, 0x85, 0xf7, 0xe8, 0xc0, 0x62, 0xc1, 0xf2, 0x26, 0x50, 0x9d, 0x20,
-                0xf9, 0xa4, 0x88, 0x5e, 0x15, 0x70, 0x4f, 0x73, 0x01, 0xdf, 0x60, 0x3d, 0xa1, 0xfc,
-                0x5b, 0xca, 0x84, 0xf8, 0x55, 0xc1, 0x17, 0xcb, 0x30, 0x55, 0xc5, 0x70, 0x83, 0x45,
-                0x7e, 0x1d, 0x14, 0x85, 0x7c, 0x2b, 0xf9, 0x41, 0xe8, 0x20, 0x73, 0x5c, 0x58, 0x8a,
-                0xae, 0x6f, 0x66, 0x45, 0xdc, 0x3f, 0xbd, 0x30, 0x65, 0xab, 0xa1, 0x7f, 0xd2, 0x48,
-                0x2a, 0x1b, 0x37, 0xb2, 0xf3, 0x88, 0x07, 0x5e, 0x46, 0xbb, 0x9d, 0x37, 0x27, 0xcc,
-                0x73, 0xdb, 0xae, 0x0e, 0x96, 0xa8, 0x44, 0x5f, 0xda, 0x8f, 0x87, 0x64, 0xf9, 0x68,
-                0x0b, 0xf6, 0xc5, 0x91, 0xa8, 0x48, 0x10, 0xfa, 0x0c, 0x1b, 0x5a, 0x2f, 0x2a, 0xa9,
-                0xad, 0xbb, 0x88, 0x64, 0x22, 0x31, 0x72, 0x1e, 0xd6, 0xea, 0x12, 0x16, 0xab, 0x9b,
-                0xfa, 0x0e, 0x12, 0x4c, 0xe4, 0x74, 0x94, 0x44, 0x53, 0x4d, 0x68, 0x70, 0x19, 0x74,
-                0x60, 0xf7, 0x49, 0xef, 0xb0, 0x28, 0x8f, 0x96, 0x28, 0x3f, 0xc9, 0x37, 0xef, 0xbb,
-                0x14, 0x59, 0xaa, 0x73, 0xc2, 0x7b, 0x6b, 0x2b, 0x5c, 0x57, 0x7d, 0x46, 0x60, 0xf9,
-                0x8e, 0x81, 0x8c, 0xaa, 0xad, 0xbe, 0x45, 0x4e, 0xcd, 0x16, 0xc1, 0xd8, 0xa9, 0x9b,
-                0x77, 0x97, 0x8e, 0x93, 0xd6, 0x9d, 0xcb, 0x8b, 0xf0, 0xe8, 0x4a, 0x0a, 0x91, 0x3f,
-                0x55, 0xcc, 0x16, 0x50, 0xc2, 0xb9, 0x2d, 0x4c, 0x9d, 0xcd, 0xb1, 0x2e, 0xe2, 0x36,
-                0x7e, 0xd9, 0x79, 0xb9, 0x53, 0x5f, 0xe1, 0x5c, 0x87, 0xd1, 0x7f, 0x37, 0xa3, 0x24,
-                0x84, 0x7f, 0x16, 0x45, 0x39, 0x75, 0x7d, 0x83, 0x00, 0x87, 0xf6, 0x39, 0xeb, 0x6c,
-                0x3e, 0xfb, 0x8d, 0xa4, 0xff, 0xa5, 0xd7, 0xca, 0x58, 0x34, 0x4d, 0x65, 0x81, 0x76,
-                0x64, 0xa7, 0x4e, 0xaf, 0xa1, 0xa4, 0x7f, 0x69, 0xf1, 0xc8, 0x10, 0x6b, 0x6f, 0x5f,
-                0x96, 0x4f, 0x4c, 0x73, 0x68, 0xed, 0x11, 0x06, 0x29, 0x54, 0xd2, 0xe8, 0xd3, 0x0c,
-                0xcc, 0xac, 0xba, 0xd9, 0xa2, 0xfa,
-            ],
-            ock: [
-                0x57, 0x97, 0xef, 0x48, 0x70, 0xb0, 0x86, 0x50, 0xfa, 0x99, 0xad, 0xae, 0x58, 0x85,
-                0x19, 0x9e, 0x3b, 0x04, 0x4b, 0x2a, 0x0a, 0x8c, 0xe1, 0x61, 0x43, 0x42, 0xb5, 0xdc,
-                0xb2, 0x8e, 0x6e, 0x09,
-            ],
-            op: [
-                0x6f, 0xce, 0x26, 0xab, 0xe6, 0xc0, 0xb6, 0x84, 0x37, 0x36, 0x96, 0x46, 0xee, 0xe1,
-                0xe9, 0xdc, 0xa5, 0x1a, 0x42, 0x58, 0xf3, 0xae, 0x72, 0x23, 0x87, 0xf6, 0xd0, 0xdf,
-                0xf4, 0x1a, 0x1f, 0x88, 0x2f, 0x98, 0x2d, 0xec, 0xa7, 0x60, 0x51, 0x41, 0xd9, 0xc9,
-                0xa1, 0xe6, 0xfb, 0x57, 0xe2, 0xb8, 0x01, 0xb4, 0x49, 0x6f, 0xbd, 0xd4, 0xc0, 0xa8,
-                0xb9, 0x5f, 0xc8, 0x7e, 0xa7, 0x37, 0x3e, 0x2f,
-            ],
-            c_out: [
-                0xb8, 0xb4, 0x6c, 0x7e, 0xc4, 0xa8, 0x74, 0x2a, 0x22, 0xd3, 0xcd, 0x11, 0x74, 0x1c,
-                0x23, 0x04, 0x22, 0x1c, 0xa5, 0x97, 0x29, 0x4e, 0x08, 0xa4, 0xc7, 0x1b, 0x17, 0xc7,
-                0x26, 0x5d, 0x4d, 0xa7, 0x7c, 0xfe, 0x84, 0xb8, 0x7e, 0x76, 0xed, 0xaa, 0xec, 0xc2,
-                0x24, 0xb8, 0x36, 0xde, 0x22, 0x4c, 0x73, 0x58, 0x13, 0x19, 0xa0, 0xba, 0x27, 0x88,
-                0xdb, 0xf8, 0x3b, 0xcf, 0x47, 0xa4, 0x8e, 0xeb, 0x02, 0xb4, 0x3a, 0x18, 0x02, 0x7b,
-                0x8f, 0x59, 0x11, 0x65, 0xc2, 0x86, 0xe8, 0xb6, 0x54, 0xec,
-            ],
-            asset: Some([
-                0xc3, 0xcc, 0x4f, 0x43, 0xfa, 0x01, 0x88, 0x52, 0x1b, 0xc6, 0x1b, 0x21, 0xdd, 0x04,
-                0xe3, 0x7a, 0x83, 0xec, 0xe6, 0x8c, 0xa7, 0xa2, 0xfa, 0x6c, 0x8f, 0x9e, 0x34, 0xa6,
-                0x29, 0x03, 0x35, 0xaa,
-            ]),
-        },
-        TestVector {
-            incoming_viewing_key: [
-                0xa6, 0x68, 0x13, 0x52, 0xa3, 0x52, 0x26, 0x91, 0x10, 0x0f, 0x53, 0xfc, 0x34, 0xab,
-                0x73, 0x32, 0x8a, 0xf1, 0xb9, 0xf3, 0xa4, 0xa0, 0x6d, 0xbd, 0x3a, 0x14, 0x99, 0x67,
-                0x09, 0xe6, 0xf2, 0x84, 0x31, 0xee, 0x72, 0xf2, 0x69, 0xae, 0xd7, 0x5d, 0x36, 0x34,
-                0x89, 0x36, 0x90, 0x5e, 0xbb, 0x91, 0x80, 0x7d, 0x74, 0xd5, 0x0c, 0xb2, 0x7f, 0xcd,
-                0x8b, 0x4f, 0xb6, 0xf4, 0x48, 0xc3, 0x62, 0x03,
-            ],
-            ovk: [
-                0x78, 0xf1, 0x45, 0xea, 0x29, 0xd2, 0x71, 0xb9, 0x40, 0xc6, 0x99, 0x41, 0xe4, 0xc3,
-                0xfd, 0x2d, 0x71, 0xf3, 0xb1, 0x90, 0x69, 0x0e, 0xe1, 0x6f, 0x5d, 0x14, 0xac, 0x22,
-                0x24, 0xe6, 0xfc, 0x89,
-            ],
-            default_d: [
-                0x11, 0x6e, 0x79, 0x94, 0x55, 0xae, 0xa1, 0x91, 0x8f, 0xbf, 0xd4,
-            ],
-            default_pk_d: [
-                0x3e, 0x5e, 0x46, 0xeb, 0x0f, 0xe8, 0xe6, 0xf0, 0xcf, 0x6a, 0xab, 0x2b, 0x41, 0xfb,
-                0xcf, 0xfb, 0xb2, 0x98, 0xf8, 0xd5, 0x34, 0xc8, 0xd9, 0xd3, 0x11, 0xe4, 0xc6, 0x10,
-                0x3a, 0x56, 0x6a, 0xaa,
-            ],
-            v: 15093716717054627455,
-            rseed: [
-                0x7e, 0x62, 0x25, 0x8d, 0x65, 0xa1, 0x92, 0x15, 0x7c, 0xdf, 0x2e, 0xc3, 0x21, 0x40,
-                0x7f, 0x68, 0x2f, 0x5e, 0xec, 0x6a, 0x32, 0x97, 0xab, 0x20, 0xb7, 0x06, 0x1c, 0x62,
-                0x24, 0x57, 0x16, 0xa4,
-            ],
-            memo: [
-                0xff, 0x4f, 0x71, 0xfb, 0xfc, 0x34, 0xc7, 0x9b, 0x44, 0xe0, 0x9e, 0x42, 0x12, 0xac,
-                0x26, 0x53, 0xf6, 0xc4, 0x03, 0x64, 0x3e, 0x1c, 0x5b, 0x9a, 0xd1, 0x34, 0xd8, 0x9c,
-                0x68, 0x0b, 0x70, 0x72, 0x83, 0xaf, 0x54, 0x32, 0x6f, 0xc4, 0xf8, 0x4d, 0x6a, 0x58,
-                0x29, 0xa0, 0xad, 0x48, 0x30, 0x80, 0x6c, 0x05, 0x75, 0x84, 0x92, 0xcd, 0x6a, 0xc4,
-                0x6b, 0xa0, 0x1a, 0x2b, 0x37, 0x22, 0xb5, 0xe4, 0xcd, 0xaf, 0xbb, 0x3f, 0x36, 0x78,
-                0x5f, 0x42, 0x4a, 0xf0, 0x44, 0xda, 0xc5, 0xdb, 0x5f, 0x7d, 0xf8, 0x39, 0xeb, 0x63,
-                0xc0, 0xc1, 0x7d, 0x8b, 0x0c, 0x79, 0xdb, 0x86, 0x30, 0x94, 0x20, 0x15, 0xbe, 0x13,
-                0xf7, 0x9a, 0xf6, 0xf4, 0x3e, 0x5a, 0xb0, 0x77, 0x81, 0x14, 0x79, 0x8f, 0x44, 0x22,
-                0x58, 0xee, 0xdc, 0x43, 0x6f, 0xcc, 0x38, 0x6b, 0x36, 0xb5, 0x7e, 0x19, 0x17, 0xd7,
-                0x20, 0x17, 0x73, 0x66, 0xf4, 0x24, 0xb0, 0xa5, 0x4b, 0x0b, 0x60, 0xf4, 0xfb, 0x13,
-                0x58, 0xc2, 0x0a, 0xa4, 0x1d, 0xc5, 0x02, 0xe1, 0xdd, 0x8a, 0x16, 0x33, 0xf3, 0xd8,
-                0xe3, 0x27, 0x6b, 0x59, 0xe7, 0xd2, 0xc4, 0xe6, 0x24, 0xa6, 0xf5, 0x36, 0x95, 0xbc,
-                0xaf, 0x24, 0x7e, 0x36, 0x48, 0x3f, 0x13, 0xb2, 0x04, 0x42, 0x22, 0x37, 0xfc, 0x6a,
-                0xb3, 0xeb, 0xa0, 0x2f, 0xc4, 0x14, 0x2b, 0x42, 0x97, 0xeb, 0xb5, 0x68, 0x3d, 0xb8,
-                0xd2, 0x43, 0x19, 0x70, 0x6a, 0xd2, 0x6a, 0xaf, 0xd8, 0x1c, 0x53, 0xb7, 0x40, 0xf3,
-                0x45, 0x43, 0xa6, 0xb3, 0xe9, 0xf5, 0xbb, 0x7d, 0x5c, 0x49, 0xe8, 0xc3, 0x7f, 0x61,
-                0x49, 0x21, 0x25, 0x4f, 0x32, 0x12, 0x39, 0x4c, 0x79, 0x7d, 0x1c, 0xee, 0x78, 0x99,
-                0xb7, 0xb4, 0xb6, 0x5b, 0x59, 0xb7, 0x34, 0x2f, 0x92, 0x53, 0x1c, 0x1d, 0x59, 0xe1,
-                0x79, 0x70, 0xb7, 0x31, 0x74, 0x14, 0x43, 0x8c, 0xd8, 0x0b, 0xd0, 0xf9, 0xa6, 0x7c,
-                0x9b, 0x9e, 0x55, 0x2f, 0x01, 0x3c, 0x11, 0x5a, 0x95, 0x4f, 0x35, 0xe0, 0x61, 0x6c,
-                0x68, 0xd4, 0x31, 0x63, 0xd3, 0x34, 0xda, 0xc3, 0x82, 0x70, 0x33, 0xe5, 0xad, 0x84,
-                0x88, 0xbf, 0xd9, 0xc4, 0xbb, 0xbe, 0x8f, 0x59, 0x35, 0xc6, 0xc5, 0xea, 0x04, 0xc3,
-                0xad, 0x49, 0xc7, 0x47, 0xa9, 0xe7, 0x23, 0x1b, 0xcd, 0x7d, 0x16, 0x21, 0x5e, 0x6e,
-                0x80, 0x73, 0x7d, 0x6b, 0x54, 0xfe, 0xc8, 0xb8, 0x84, 0x02, 0xf0, 0x47, 0x52, 0x45,
-                0xe1, 0x74, 0xa7, 0x45, 0xb8, 0x31, 0xf8, 0xfe, 0x03, 0xa7, 0x6f, 0xb9, 0xce, 0xca,
-                0x4d, 0x22, 0xb7, 0x83, 0xc3, 0x28, 0xc6, 0x91, 0x5c, 0x43, 0x40, 0x50, 0x64, 0xae,
-                0x56, 0xbc, 0x89, 0xe6, 0x4d, 0x15, 0x78, 0xe4, 0xd3, 0xa3, 0x4b, 0xb9, 0x55, 0x91,
-                0xea, 0xf1, 0xd3, 0xda, 0x02, 0xa4, 0x54, 0x9f, 0xa8, 0x0d, 0xb0, 0xff, 0x7c, 0xb0,
-                0x39, 0x93, 0xb6, 0x8a, 0xe1, 0x5a, 0x30, 0xe8, 0x79, 0x49, 0xaa, 0x08, 0x0e, 0x94,
-                0xab, 0xde, 0x68, 0x89, 0x8c, 0x33, 0x92, 0xa2, 0x17, 0xd6, 0x49, 0x61, 0x6b, 0xbe,
-                0x73, 0x9b, 0x13, 0xd1, 0x4d, 0xf0, 0x3f, 0xf2, 0x76, 0x71, 0x48, 0x9b, 0xe0, 0xb4,
-                0xbe, 0xba, 0xaf, 0xa7, 0xd1, 0xe6, 0x39, 0xd5, 0xb3, 0xe9, 0x94, 0xff, 0xb6, 0xb7,
-                0xa2, 0x09, 0xf6, 0xad, 0xfe, 0x8d, 0x1e, 0x5c, 0xcf, 0x01, 0x0c, 0x19, 0x16, 0x8a,
-                0xeb, 0x18, 0xaa, 0x9d, 0x68, 0x7e, 0x24, 0xad, 0xc0, 0xb1, 0x13, 0x5c, 0x70, 0xc9,
-                0x70, 0xe0, 0x90, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            ],
-            cv_net: [
-                0x91, 0x6d, 0xc3, 0x82, 0x2a, 0x4e, 0x3b, 0xb4, 0x1f, 0xa8, 0x33, 0xc2, 0x73, 0xa9,
-                0xd3, 0x7d, 0x17, 0x17, 0xa4, 0x8d, 0x8f, 0x00, 0x6c, 0x1f, 0xf5, 0x86, 0x21, 0x46,
-                0x29, 0x55, 0x39, 0x1c,
-            ],
-            rho: [
-                0x57, 0x87, 0x18, 0x97, 0x6d, 0xa3, 0xdc, 0xb4, 0x30, 0x32, 0x71, 0x52, 0x20, 0x72,
-                0xd0, 0x28, 0x44, 0x22, 0x13, 0x50, 0x86, 0x4e, 0xed, 0x56, 0x3d, 0xab, 0x30, 0x22,
-                0x7f, 0x28, 0x4b, 0x2e,
-            ],
-            cmx: [
-                0x89, 0xe6, 0xa2, 0xb9, 0x70, 0x84, 0xe3, 0xd3, 0x34, 0x4f, 0xee, 0xb4, 0x64, 0x65,
-                0x05, 0x72, 0x51, 0xb1, 0x9d, 0xa0, 0xce, 0xdf, 0x79, 0x71, 0x94, 0xc5, 0x97, 0xf9,
-                0xf7, 0x7e, 0xf2, 0x1f,
-            ],
-            esk: [
-                0xe4, 0x00, 0x13, 0x04, 0x47, 0xc1, 0xbd, 0x1a, 0x0c, 0x13, 0x02, 0xf5, 0x10, 0xe9,
-                0xeb, 0x09, 0xed, 0x76, 0xda, 0xbc, 0xfe, 0x2a, 0x69, 0x1c, 0xc4, 0x69, 0x2d, 0x0c,
-                0x1b, 0x30, 0x33, 0x01,
-            ],
-            ephemeral_key: [
-                0x27, 0xcb, 0x40, 0x68, 0x0f, 0xb1, 0xd9, 0x19, 0x64, 0x6e, 0x74, 0x20, 0xe6, 0xa8,
-                0xb5, 0x20, 0xe1, 0x9a, 0x17, 0x3f, 0x1e, 0x79, 0x4d, 0x2b, 0x49, 0x2b, 0xfa, 0xbb,
-                0x83, 0xce, 0x6c, 0xa0,
-            ],
-            shared_secret: [
-                0x1c, 0xd0, 0x66, 0x91, 0x6c, 0x19, 0xfa, 0x33, 0x69, 0xaa, 0x3c, 0x6a, 0x53, 0x76,
-                0x97, 0xf4, 0xb4, 0x26, 0x44, 0xda, 0x20, 0xca, 0x46, 0x79, 0x93, 0x2b, 0x7c, 0x90,
-                0x5f, 0x2d, 0x69, 0x00,
-            ],
-            k_enc: [
-                0xce, 0x9d, 0x22, 0x0d, 0x3a, 0xfe, 0xc6, 0x23, 0x21, 0xdd, 0xf1, 0x97, 0xa6, 0x36,
-                0xdc, 0xb3, 0x45, 0x58, 0x83, 0xb7, 0x35, 0x82, 0x8c, 0x65, 0xe7, 0x16, 0x6c, 0x15,
-                0xd8, 0xcc, 0xfc, 0xf9,
-            ],
-            p_enc: [
-                0x03, 0x11, 0x6e, 0x79, 0x94, 0x55, 0xae, 0xa1, 0x91, 0x8f, 0xbf, 0xd4, 0x7f, 0x8e,
-                0x6a, 0x5c, 0x62, 0xa7, 0x77, 0xd1, 0x7e, 0x62, 0x25, 0x8d, 0x65, 0xa1, 0x92, 0x15,
-                0x7c, 0xdf, 0x2e, 0xc3, 0x21, 0x40, 0x7f, 0x68, 0x2f, 0x5e, 0xec, 0x6a, 0x32, 0x97,
-                0xab, 0x20, 0xb7, 0x06, 0x1c, 0x62, 0x24, 0x57, 0x16, 0xa4, 0x96, 0x86, 0xaa, 0x36,
-                0x36, 0xbd, 0x37, 0x5b, 0xd3, 0x13, 0x6b, 0xee, 0x0b, 0xda, 0xab, 0xcf, 0xac, 0x88,
-                0x1b, 0xc7, 0x01, 0x81, 0x27, 0x21, 0xe6, 0xfb, 0x75, 0xaa, 0x07, 0x2d, 0x2d, 0x18,
-                0xff, 0x4f, 0x71, 0xfb, 0xfc, 0x34, 0xc7, 0x9b, 0x44, 0xe0, 0x9e, 0x42, 0x12, 0xac,
-                0x26, 0x53, 0xf6, 0xc4, 0x03, 0x64, 0x3e, 0x1c, 0x5b, 0x9a, 0xd1, 0x34, 0xd8, 0x9c,
-                0x68, 0x0b, 0x70, 0x72, 0x83, 0xaf, 0x54, 0x32, 0x6f, 0xc4, 0xf8, 0x4d, 0x6a, 0x58,
-                0x29, 0xa0, 0xad, 0x48, 0x30, 0x80, 0x6c, 0x05, 0x75, 0x84, 0x92, 0xcd, 0x6a, 0xc4,
-                0x6b, 0xa0, 0x1a, 0x2b, 0x37, 0x22, 0xb5, 0xe4, 0xcd, 0xaf, 0xbb, 0x3f, 0x36, 0x78,
-                0x5f, 0x42, 0x4a, 0xf0, 0x44, 0xda, 0xc5, 0xdb, 0x5f, 0x7d, 0xf8, 0x39, 0xeb, 0x63,
-                0xc0, 0xc1, 0x7d, 0x8b, 0x0c, 0x79, 0xdb, 0x86, 0x30, 0x94, 0x20, 0x15, 0xbe, 0x13,
-                0xf7, 0x9a, 0xf6, 0xf4, 0x3e, 0x5a, 0xb0, 0x77, 0x81, 0x14, 0x79, 0x8f, 0x44, 0x22,
-                0x58, 0xee, 0xdc, 0x43, 0x6f, 0xcc, 0x38, 0x6b, 0x36, 0xb5, 0x7e, 0x19, 0x17, 0xd7,
-                0x20, 0x17, 0x73, 0x66, 0xf4, 0x24, 0xb0, 0xa5, 0x4b, 0x0b, 0x60, 0xf4, 0xfb, 0x13,
-                0x58, 0xc2, 0x0a, 0xa4, 0x1d, 0xc5, 0x02, 0xe1, 0xdd, 0x8a, 0x16, 0x33, 0xf3, 0xd8,
-                0xe3, 0x27, 0x6b, 0x59, 0xe7, 0xd2, 0xc4, 0xe6, 0x24, 0xa6, 0xf5, 0x36, 0x95, 0xbc,
-                0xaf, 0x24, 0x7e, 0x36, 0x48, 0x3f, 0x13, 0xb2, 0x04, 0x42, 0x22, 0x37, 0xfc, 0x6a,
-                0xb3, 0xeb, 0xa0, 0x2f, 0xc4, 0x14, 0x2b, 0x42, 0x97, 0xeb, 0xb5, 0x68, 0x3d, 0xb8,
-                0xd2, 0x43, 0x19, 0x70, 0x6a, 0xd2, 0x6a, 0xaf, 0xd8, 0x1c, 0x53, 0xb7, 0x40, 0xf3,
-                0x45, 0x43, 0xa6, 0xb3, 0xe9, 0xf5, 0xbb, 0x7d, 0x5c, 0x49, 0xe8, 0xc3, 0x7f, 0x61,
-                0x49, 0x21, 0x25, 0x4f, 0x32, 0x12, 0x39, 0x4c, 0x79, 0x7d, 0x1c, 0xee, 0x78, 0x99,
-                0xb7, 0xb4, 0xb6, 0x5b, 0x59, 0xb7, 0x34, 0x2f, 0x92, 0x53, 0x1c, 0x1d, 0x59, 0xe1,
-                0x79, 0x70, 0xb7, 0x31, 0x74, 0x14, 0x43, 0x8c, 0xd8, 0x0b, 0xd0, 0xf9, 0xa6, 0x7c,
-                0x9b, 0x9e, 0x55, 0x2f, 0x01, 0x3c, 0x11, 0x5a, 0x95, 0x4f, 0x35, 0xe0, 0x61, 0x6c,
-                0x68, 0xd4, 0x31, 0x63, 0xd3, 0x34, 0xda, 0xc3, 0x82, 0x70, 0x33, 0xe5, 0xad, 0x84,
-                0x88, 0xbf, 0xd9, 0xc4, 0xbb, 0xbe, 0x8f, 0x59, 0x35, 0xc6, 0xc5, 0xea, 0x04, 0xc3,
-                0xad, 0x49, 0xc7, 0x47, 0xa9, 0xe7, 0x23, 0x1b, 0xcd, 0x7d, 0x16, 0x21, 0x5e, 0x6e,
-                0x80, 0x73, 0x7d, 0x6b, 0x54, 0xfe, 0xc8, 0xb8, 0x84, 0x02, 0xf0, 0x47, 0x52, 0x45,
-                0xe1, 0x74, 0xa7, 0x45, 0xb8, 0x31, 0xf8, 0xfe, 0x03, 0xa7, 0x6f, 0xb9, 0xce, 0xca,
-                0x4d, 0x22, 0xb7, 0x83, 0xc3, 0x28, 0xc6, 0x91, 0x5c, 0x43, 0x40, 0x50, 0x64, 0xae,
-                0x56, 0xbc, 0x89, 0xe6, 0x4d, 0x15, 0x78, 0xe4, 0xd3, 0xa3, 0x4b, 0xb9, 0x55, 0x91,
-                0xea, 0xf1, 0xd3, 0xda, 0x02, 0xa4, 0x54, 0x9f, 0xa8, 0x0d, 0xb0, 0xff, 0x7c, 0xb0,
-                0x39, 0x93, 0xb6, 0x8a, 0xe1, 0x5a, 0x30, 0xe8, 0x79, 0x49, 0xaa, 0x08, 0x0e, 0x94,
-                0xab, 0xde, 0x68, 0x89, 0x8c, 0x33, 0x92, 0xa2, 0x17, 0xd6, 0x49, 0x61, 0x6b, 0xbe,
-                0x73, 0x9b, 0x13, 0xd1, 0x4d, 0xf0, 0x3f, 0xf2, 0x76, 0x71, 0x48, 0x9b, 0xe0, 0xb4,
-                0xbe, 0xba, 0xaf, 0xa7, 0xd1, 0xe6, 0x39, 0xd5, 0xb3, 0xe9, 0x94, 0xff, 0xb6, 0xb7,
-                0xa2, 0x09, 0xf6, 0xad, 0xfe, 0x8d, 0x1e, 0x5c, 0xcf, 0x01, 0x0c, 0x19, 0x16, 0x8a,
-                0xeb, 0x18, 0xaa, 0x9d, 0x68, 0x7e, 0x24, 0xad, 0xc0, 0xb1, 0x13, 0x5c, 0x70, 0xc9,
-                0x70, 0xe0, 0x90, 0x3a,
-            ],
-            c_enc: [
-                0xb1, 0x69, 0x64, 0x77, 0xe6, 0x58, 0xb6, 0xf8, 0xe2, 0x4e, 0x02, 0x55, 0x52, 0xb4,
-                0x8d, 0xd4, 0x84, 0x58, 0xf2, 0xcd, 0x75, 0x70, 0xc0, 0xe8, 0xce, 0xc4, 0xed, 0x4c,
-                0xf7, 0x9b, 0xd5, 0xb6, 0x9e, 0xa8, 0x54, 0x12, 0x3b, 0x4e, 0xaf, 0x97, 0x8b, 0x14,
-                0x2e, 0xb3, 0xef, 0x53, 0xaa, 0xfc, 0x78, 0x90, 0xdd, 0xa2, 0x8a, 0xfa, 0x25, 0xf1,
-                0x45, 0xc8, 0xb9, 0x7f, 0x7b, 0x94, 0x50, 0xc1, 0xd5, 0xe0, 0xc3, 0x7d, 0xaf, 0x5e,
-                0xd4, 0xec, 0xd9, 0xb6, 0x3d, 0xbc, 0xd2, 0x15, 0x11, 0x23, 0x13, 0x9b, 0xbc, 0x2b,
-                0x65, 0x1a, 0x8f, 0x69, 0xcf, 0xbf, 0xb7, 0xcb, 0x60, 0x44, 0x78, 0xf3, 0xf2, 0x64,
-                0xd9, 0xdd, 0x75, 0xcf, 0x31, 0x9e, 0x3e, 0xcd, 0xf5, 0xb3, 0x34, 0x26, 0x54, 0x85,
-                0x7c, 0x52, 0xa1, 0xfc, 0x61, 0x40, 0x55, 0xa2, 0x46, 0xf5, 0x26, 0x3e, 0x85, 0x36,
-                0x83, 0xef, 0x54, 0x41, 0x3b, 0xac, 0x99, 0x1a, 0xe6, 0x35, 0x01, 0x50, 0xe1, 0x34,
-                0x52, 0xa3, 0xa6, 0x20, 0xc5, 0x3f, 0x80, 0xda, 0xcc, 0x7a, 0xf0, 0x59, 0x26, 0xd9,
-                0xc5, 0x9a, 0x94, 0xe4, 0x78, 0x9a, 0xcc, 0x68, 0xd8, 0x51, 0x05, 0x6b, 0x75, 0xa7,
-                0x4e, 0x2e, 0x1b, 0x38, 0xbf, 0xcb, 0x6d, 0xba, 0xab, 0x37, 0xa3, 0x8a, 0xe0, 0x2c,
-                0x9c, 0x35, 0x25, 0x9e, 0x52, 0x84, 0xe4, 0xfe, 0x83, 0xdd, 0xb2, 0x29, 0x24, 0xa1,
-                0xc4, 0x0a, 0xa2, 0x5e, 0xd1, 0xf5, 0xc0, 0x6d, 0xa1, 0x58, 0x31, 0xf0, 0x41, 0x50,
-                0xa3, 0x7c, 0x1b, 0xa3, 0xd1, 0x17, 0x04, 0x93, 0xca, 0x29, 0xf3, 0x43, 0x4a, 0xfa,
-                0x06, 0x9b, 0x46, 0xaf, 0xdc, 0x87, 0x0a, 0x29, 0x6f, 0xdc, 0x0e, 0xb6, 0x1b, 0x55,
-                0x70, 0x77, 0xa1, 0xda, 0x1f, 0xe8, 0x22, 0xb6, 0xce, 0x24, 0x7c, 0x8e, 0x19, 0x9f,
-                0xc4, 0x85, 0x14, 0x6f, 0x38, 0x4a, 0xcf, 0x5c, 0x52, 0x69, 0x7e, 0xfa, 0xcc, 0x5b,
-                0xfe, 0x42, 0x02, 0xe8, 0x5f, 0x06, 0x4b, 0xc8, 0xe1, 0x2e, 0xee, 0x39, 0x79, 0x6d,
-                0xfd, 0x13, 0x99, 0xb1, 0xc1, 0xe8, 0xc7, 0x4b, 0x5e, 0xc3, 0xc3, 0x1d, 0x2c, 0xfa,
-                0x44, 0x87, 0x02, 0x5c, 0xeb, 0x5d, 0xb3, 0x55, 0x9d, 0x4b, 0x7b, 0xac, 0x02, 0x73,
-                0xf1, 0x33, 0x51, 0xd2, 0xd1, 0x3c, 0xec, 0x0a, 0x44, 0x8c, 0x00, 0x11, 0x09, 0x45,
-                0x2c, 0x40, 0x92, 0xc8, 0x11, 0x91, 0xa0, 0xda, 0xa9, 0x79, 0xe2, 0x6a, 0x96, 0x24,
-                0xe4, 0x0c, 0xa4, 0xac, 0xcb, 0x63, 0x46, 0xaa, 0xe1, 0x88, 0xca, 0x09, 0x39, 0xdd,
-                0x9f, 0x6b, 0x6e, 0x45, 0xe4, 0x1b, 0xca, 0xeb, 0xdc, 0x1d, 0xa8, 0x01, 0xcc, 0xd4,
-                0xdc, 0x93, 0x32, 0x26, 0x6f, 0xb3, 0xeb, 0x23, 0x7b, 0x07, 0x72, 0x45, 0xa7, 0x91,
-                0xec, 0xb4, 0x0e, 0x5c, 0x40, 0x56, 0xad, 0xd6, 0xb1, 0xb5, 0xf7, 0xf8, 0xfa, 0x10,
-                0x4f, 0xba, 0x61, 0x3e, 0xd9, 0x29, 0xe1, 0xfa, 0xd2, 0x26, 0x47, 0x50, 0x35, 0xb6,
-                0x1a, 0x9f, 0x85, 0xaf, 0xba, 0xfb, 0x16, 0x6b, 0x24, 0xc2, 0x4d, 0x2c, 0x28, 0x93,
-                0x7b, 0x17, 0x70, 0xba, 0x26, 0x9c, 0x15, 0xeb, 0x2d, 0x9b, 0xdc, 0x2b, 0x83, 0xea,
-                0xd8, 0xa0, 0x1d, 0xdb, 0x11, 0x08, 0x3b, 0x13, 0xd6, 0x2d, 0x57, 0x2c, 0xf7, 0x8d,
-                0x5c, 0xba, 0x6f, 0x36, 0x52, 0xca, 0xc4, 0xd2, 0x4c, 0x71, 0xc5, 0x47, 0x27, 0x26,
-                0x24, 0xc0, 0x78, 0xe0, 0xb9, 0x69, 0x68, 0xfe, 0x09, 0xd8, 0x3e, 0xf7, 0x30, 0x20,
-                0x62, 0xbb, 0x5d, 0x3a, 0x2c, 0xcf, 0x73, 0x4e, 0x0f, 0xd3, 0x51, 0x01, 0xfd, 0x58,
-                0x64, 0x73, 0x3f, 0x44, 0xd0, 0x75, 0xc3, 0x8b, 0x73, 0xf6, 0xbf, 0xb8, 0xc3, 0x9c,
-                0x7b, 0x6b, 0x3d, 0xbc, 0xd1, 0x9a, 0x05, 0x89, 0x91, 0x86, 0x37, 0xf7, 0x5b, 0xbe,
-                0x40, 0x15, 0x7b, 0x80, 0xe5, 0x9e, 0x55, 0x58, 0x50, 0x28, 0xa5, 0xec, 0x20, 0x1e,
-                0x00, 0x8f, 0xf6, 0xf5, 0x12, 0xe2, 0x53, 0xcc, 0x9a, 0xcf, 0x62, 0x7d, 0x94, 0x35,
-                0xdb, 0x6b, 0x14, 0xb9, 0x82, 0x48, 0x79, 0xf4, 0xe4, 0x0a, 0x36, 0xd5, 0xec, 0x94,
-                0x2b, 0xff, 0x04, 0xfd, 0x90, 0xa6, 0xaf, 0x8c, 0x58, 0x1d, 0xf6, 0x09, 0xc4, 0x11,
-                0xf4, 0x76, 0x11, 0x41, 0xd4, 0xa6,
-            ],
-            ock: [
-                0x95, 0x83, 0xf1, 0x0f, 0xed, 0x70, 0xa4, 0x1e, 0x45, 0x8c, 0x65, 0x5c, 0xc0, 0x14,
-                0xe2, 0x35, 0x5a, 0x7f, 0x99, 0xae, 0xbc, 0xfe, 0xf7, 0x4a, 0x55, 0x9a, 0xcd, 0x24,
-                0x25, 0xfa, 0x21, 0xcf,
-            ],
-            op: [
-                0x3e, 0x5e, 0x46, 0xeb, 0x0f, 0xe8, 0xe6, 0xf0, 0xcf, 0x6a, 0xab, 0x2b, 0x41, 0xfb,
-                0xcf, 0xfb, 0xb2, 0x98, 0xf8, 0xd5, 0x34, 0xc8, 0xd9, 0xd3, 0x11, 0xe4, 0xc6, 0x10,
-                0x3a, 0x56, 0x6a, 0xaa, 0xe4, 0x00, 0x13, 0x04, 0x47, 0xc1, 0xbd, 0x1a, 0x0c, 0x13,
-                0x02, 0xf5, 0x10, 0xe9, 0xeb, 0x09, 0xed, 0x76, 0xda, 0xbc, 0xfe, 0x2a, 0x69, 0x1c,
-                0xc4, 0x69, 0x2d, 0x0c, 0x1b, 0x30, 0x33, 0x01,
-            ],
-            c_out: [
-                0xb8, 0x3b, 0x74, 0x5c, 0x9c, 0x0b, 0x04, 0xdd, 0xc7, 0xf1, 0x38, 0x16, 0x94, 0x38,
-                0x99, 0x55, 0x3a, 0x30, 0x6a, 0x4a, 0xd0, 0xf2, 0xf5, 0x70, 0x92, 0x2a, 0x89, 0x9b,
-                0xab, 0xb9, 0xda, 0xca, 0xd2, 0xbb, 0xc9, 0x5c, 0xf6, 0x5b, 0x73, 0x08, 0x55, 0x0d,
-                0xce, 0xdb, 0x64, 0x9e, 0xf1, 0x5e, 0x0b, 0x1a, 0x09, 0x1f, 0xad, 0x5a, 0x93, 0x92,
-                0xd0, 0x71, 0xb7, 0x5a, 0xb5, 0x1a, 0x7e, 0x35, 0x06, 0xad, 0x58, 0xd1, 0x71, 0x95,
-                0xc9, 0x9f, 0x29, 0x8a, 0xc3, 0x14, 0xec, 0x05, 0xa6, 0x6a,
-            ],
-            asset: Some([
-                0x96, 0x86, 0xaa, 0x36, 0x36, 0xbd, 0x37, 0x5b, 0xd3, 0x13, 0x6b, 0xee, 0x0b, 0xda,
-                0xab, 0xcf, 0xac, 0x88, 0x1b, 0xc7, 0x01, 0x81, 0x27, 0x21, 0xe6, 0xfb, 0x75, 0xaa,
-                0x07, 0x2d, 0x2d, 0x18,
-            ]),
         },
     ]
 }
diff --git a/src/test_vectors/note_encryption_v3.rs b/src/test_vectors/note_encryption_v3.rs
new file mode 100644
index 000000000..0ea5da482
--- /dev/null
+++ b/src/test_vectors/note_encryption_v3.rs
@@ -0,0 +1,4389 @@
+// From https://github.com/zcash-hackworks/zcash-test-vectors/ (orchard_note_encryption)
+
+pub(crate) struct TestVector {
+    pub(crate) incoming_viewing_key: [u8; 64],
+    pub(crate) ovk: [u8; 32],
+    pub(crate) default_d: [u8; 11],
+    pub(crate) default_pk_d: [u8; 32],
+    pub(crate) v: u64,
+    pub(crate) rseed: [u8; 32],
+    pub(crate) asset: [u8; 32],
+    pub(crate) memo: [u8; 512],
+    pub(crate) cv_net: [u8; 32],
+    pub(crate) rho: [u8; 32],
+    pub(crate) cmx: [u8; 32],
+    pub(crate) esk: [u8; 32],
+    pub(crate) ephemeral_key: [u8; 32],
+    pub(crate) shared_secret: [u8; 32],
+    pub(crate) k_enc: [u8; 32],
+    pub(crate) p_enc: [u8; 596],
+    pub(crate) c_enc: [u8; 612],
+    pub(crate) ock: [u8; 32],
+    pub(crate) op: [u8; 64],
+    pub(crate) c_out: [u8; 80],
+}
+
+pub(crate) fn test_vectors() -> Vec<TestVector> {
+    vec![
+        TestVector {
+            incoming_viewing_key: [
+                0x10, 0x39, 0xd8, 0xe6, 0x4a, 0x80, 0x90, 0x2e, 0x10, 0x59, 0x47, 0x81, 0x7d, 0xf3,
+                0xbd, 0xfb, 0x7d, 0xf7, 0x03, 0x0e, 0x68, 0x73, 0x9f, 0x9c, 0x53, 0x3a, 0x36, 0xbf,
+                0x5a, 0x6a, 0x80, 0x72, 0x43, 0x10, 0x6d, 0xe9, 0xa7, 0xec, 0x54, 0xdd, 0x36, 0xdf,
+                0xa7, 0x0b, 0xdb, 0xd9, 0x07, 0x2d, 0xbd, 0xda, 0xb5, 0xe0, 0x66, 0xaa, 0xef, 0xfc,
+                0xf9, 0xbb, 0xa3, 0x20, 0xd4, 0xff, 0xf7, 0x12,
+            ],
+            ovk: [
+                0x5d, 0x7a, 0x8f, 0x73, 0x9a, 0x2d, 0x9e, 0x94, 0x5b, 0x0c, 0xe1, 0x52, 0xa8, 0x04,
+                0x9e, 0x29, 0x4c, 0x4d, 0x6e, 0x66, 0xb1, 0x64, 0x93, 0x9d, 0xaf, 0xfa, 0x2e, 0xf6,
+                0xee, 0x69, 0x21, 0x48,
+            ],
+            default_d: [
+                0x56, 0xe8, 0x4b, 0x1a, 0xdc, 0x94, 0x23, 0xc3, 0x67, 0x6c, 0x04,
+            ],
+            default_pk_d: [
+                0x63, 0xf7, 0x12, 0x5d, 0xf4, 0x83, 0x6f, 0xd2, 0x81, 0x6b, 0x02, 0x4e, 0xe7, 0x0e,
+                0xfe, 0x09, 0xfb, 0x9a, 0x7b, 0x38, 0x63, 0xc6, 0xea, 0xcd, 0xf9, 0x5e, 0x03, 0x89,
+                0x49, 0x50, 0x69, 0x2c,
+            ],
+            v: 8567075990963576717,
+            rseed: [
+                0xbf, 0x69, 0xb8, 0x25, 0x0c, 0x18, 0xef, 0x41, 0x29, 0x4c, 0xa9, 0x79, 0x93, 0xdb,
+                0x54, 0x6c, 0x1f, 0xe0, 0x1f, 0x7e, 0x9c, 0x8e, 0x36, 0xd6, 0xa5, 0xe2, 0x9d, 0x4e,
+                0x30, 0xa7, 0x35, 0x94,
+            ],
+            asset: [
+                0x67, 0x43, 0xf9, 0x3a, 0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3,
+                0x04, 0xfe, 0x32, 0xb2, 0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e,
+                0x7a, 0x59, 0x70, 0x2f,
+            ],
+            memo: [
+                0xff, 0xbf, 0x50, 0x98, 0x42, 0x1c, 0x69, 0x37, 0x8a, 0xf1, 0xe4, 0x0f, 0x64, 0xe1,
+                0x25, 0x94, 0x6f, 0x62, 0xc2, 0xfa, 0x7b, 0x2f, 0xec, 0xbc, 0xb6, 0x4b, 0x69, 0x68,
+                0x91, 0x2a, 0x63, 0x81, 0xce, 0x3d, 0xc1, 0x66, 0xd5, 0x6a, 0x1d, 0x62, 0xf5, 0xa8,
+                0xd7, 0x55, 0x1d, 0xb5, 0xfd, 0x93, 0x13, 0xe8, 0xc7, 0x20, 0x3d, 0x99, 0x6a, 0xf7,
+                0xd4, 0x77, 0x08, 0x37, 0x56, 0xd5, 0x9a, 0xf8, 0x0d, 0x06, 0xa7, 0x45, 0xf4, 0x4a,
+                0xb0, 0x23, 0x75, 0x2c, 0xb5, 0xb4, 0x06, 0xed, 0x89, 0x85, 0xe1, 0x81, 0x30, 0xab,
+                0x33, 0x36, 0x26, 0x97, 0xb0, 0xe4, 0xe4, 0xc7, 0x63, 0xcc, 0xb8, 0xf6, 0x76, 0x49,
+                0x5c, 0x22, 0x2f, 0x7f, 0xba, 0x1e, 0x31, 0xde, 0xfa, 0x3d, 0x5a, 0x57, 0xef, 0xc2,
+                0xe1, 0xe9, 0xb0, 0x1a, 0x03, 0x55, 0x87, 0xd5, 0xfb, 0x1a, 0x38, 0xe0, 0x1d, 0x94,
+                0x90, 0x3d, 0x3c, 0x3e, 0x0a, 0xd3, 0x36, 0x0c, 0x1d, 0x37, 0x10, 0xac, 0xd2, 0x0b,
+                0x18, 0x3e, 0x31, 0xd4, 0x9f, 0x25, 0xc9, 0xa1, 0x38, 0xf4, 0x9b, 0x1a, 0x53, 0x7e,
+                0xdc, 0xf0, 0x4b, 0xe3, 0x4a, 0x98, 0x51, 0xa7, 0xaf, 0x9d, 0xb6, 0x99, 0x0e, 0xd8,
+                0x3d, 0xd6, 0x4a, 0xf3, 0x59, 0x7c, 0x04, 0x32, 0x3e, 0xa5, 0x1b, 0x00, 0x52, 0xad,
+                0x80, 0x84, 0xa8, 0xb9, 0xda, 0x94, 0x8d, 0x32, 0x0d, 0xad, 0xd6, 0x4f, 0x54, 0x31,
+                0xe6, 0x1d, 0xdf, 0x65, 0x8d, 0x24, 0xae, 0x67, 0xc2, 0x2c, 0x8d, 0x13, 0x09, 0x13,
+                0x1f, 0xc0, 0x0f, 0xe7, 0xf2, 0x35, 0x73, 0x42, 0x76, 0xd3, 0x8d, 0x47, 0xf1, 0xe1,
+                0x91, 0xe0, 0x0c, 0x7a, 0x1d, 0x48, 0xaf, 0x04, 0x68, 0x27, 0x59, 0x1e, 0x97, 0x33,
+                0xa9, 0x7f, 0xa6, 0xb6, 0x79, 0xf3, 0xdc, 0x60, 0x1d, 0x00, 0x82, 0x85, 0xed, 0xcb,
+                0xda, 0xe6, 0x9c, 0xe8, 0xfc, 0x1b, 0xe4, 0xaa, 0xc0, 0x0f, 0xf2, 0x71, 0x1e, 0xbd,
+                0x93, 0x1d, 0xe5, 0x18, 0x85, 0x68, 0x78, 0xf7, 0x34, 0x76, 0xf2, 0x1a, 0x48, 0x2e,
+                0xc9, 0x37, 0x83, 0x65, 0xc8, 0xf7, 0x39, 0x3c, 0x94, 0xe2, 0x88, 0x53, 0x15, 0xeb,
+                0x46, 0x71, 0x09, 0x8b, 0x79, 0x53, 0x5e, 0x79, 0x0f, 0xe5, 0x3e, 0x29, 0xfe, 0xf2,
+                0xb3, 0x76, 0x66, 0x97, 0xac, 0x32, 0xb4, 0xf4, 0x73, 0xf4, 0x68, 0xa0, 0x08, 0xe7,
+                0x23, 0x89, 0xfc, 0x03, 0x88, 0x0d, 0x78, 0x0c, 0xb0, 0x7f, 0xcf, 0xaa, 0xbe, 0x3f,
+                0x1a, 0x84, 0xb2, 0x7d, 0xb5, 0x9a, 0x4a, 0x15, 0x3d, 0x88, 0x2d, 0x2b, 0x21, 0x03,
+                0x59, 0x65, 0x55, 0xed, 0x94, 0x94, 0xc6, 0xac, 0x89, 0x3c, 0x49, 0x72, 0x38, 0x33,
+                0xec, 0x89, 0x26, 0xc1, 0x03, 0x95, 0x86, 0xa7, 0xaf, 0xcf, 0x4a, 0x0d, 0x9c, 0x73,
+                0x1e, 0x98, 0x5d, 0x99, 0x58, 0x9c, 0x8b, 0xb8, 0x38, 0xe8, 0xaa, 0xf7, 0x45, 0x53,
+                0x3e, 0xd9, 0xe8, 0xae, 0x3a, 0x1c, 0xd0, 0x74, 0xa5, 0x1a, 0x20, 0xda, 0x8a, 0xba,
+                0x18, 0xd1, 0xdb, 0xeb, 0xbc, 0x86, 0x2d, 0xed, 0x42, 0x43, 0x5e, 0x92, 0x47, 0x69,
+                0x30, 0xd0, 0x69, 0x89, 0x6c, 0xff, 0x30, 0xeb, 0x41, 0x4f, 0x72, 0x7b, 0x89, 0xe0,
+                0x01, 0xaf, 0xa2, 0xfb, 0x8d, 0xc3, 0x43, 0x6d, 0x75, 0xa4, 0xa6, 0xf2, 0x65, 0x72,
+                0x50, 0x4b, 0x19, 0x22, 0x32, 0xec, 0xb9, 0xf0, 0xc0, 0x24, 0x11, 0xe5, 0x25, 0x96,
+                0xbc, 0x5e, 0x90, 0x45, 0x7e, 0x74, 0x59, 0x39, 0xff, 0xed, 0xbd, 0x12, 0x86, 0x3c,
+                0xe7, 0x1a, 0x02, 0xaf, 0x11, 0x7d, 0x41, 0x7a, 0xdb, 0x3d, 0x15, 0xcc, 0x54, 0xdc,
+                0xb1, 0xfc, 0xe4, 0x67, 0x50, 0x0c, 0x6b, 0x8f, 0xb8, 0x6b, 0x12, 0xb5, 0x6d, 0xa9,
+                0xc3, 0x82, 0x85, 0x7d, 0xee, 0xcc, 0x40, 0xa9,
+            ],
+            cv_net: [
+                0xdd, 0xba, 0x24, 0xf3, 0x9f, 0x70, 0x8e, 0xd7, 0xa7, 0x48, 0x57, 0x13, 0x71, 0x11,
+                0x42, 0xc2, 0x38, 0x51, 0x38, 0x15, 0x30, 0x2d, 0xf0, 0xf4, 0x83, 0x04, 0x21, 0xa6,
+                0xc1, 0x3e, 0x71, 0x01,
+            ],
+            rho: [
+                0xca, 0x1f, 0xeb, 0x30, 0xca, 0x11, 0x17, 0x76, 0xc0, 0x41, 0x74, 0x66, 0xbd, 0x69,
+                0xb3, 0xd2, 0x13, 0x88, 0x2e, 0xef, 0x55, 0xe6, 0x0b, 0x6d, 0x9e, 0x2a, 0x98, 0xe7,
+                0x05, 0xee, 0xf3, 0x27,
+            ],
+            cmx: [
+                0x23, 0x75, 0x7c, 0x51, 0x58, 0x21, 0xcb, 0xc1, 0x84, 0x3c, 0x9a, 0x45, 0x7b, 0x7e,
+                0x6a, 0xe6, 0x01, 0xad, 0xd2, 0xea, 0x10, 0xb9, 0xc8, 0x6d, 0x6b, 0x31, 0x7c, 0xe2,
+                0xf1, 0x7b, 0xd9, 0x21,
+            ],
+            esk: [
+                0x5b, 0xfe, 0x46, 0x9c, 0x33, 0xe4, 0x47, 0xba, 0x45, 0x6b, 0x8b, 0xfe, 0x9b, 0x38,
+                0x5b, 0x39, 0x31, 0xb4, 0xba, 0xeb, 0x8f, 0x70, 0x23, 0xfe, 0x8e, 0x33, 0x35, 0x4f,
+                0xff, 0xf1, 0xbd, 0x1a,
+            ],
+            ephemeral_key: [
+                0x8a, 0x5e, 0x13, 0x2c, 0x3a, 0x07, 0x04, 0xf2, 0x45, 0x6f, 0xbd, 0x77, 0x7a, 0x13,
+                0xd6, 0xec, 0x57, 0x65, 0x56, 0x71, 0xdb, 0x07, 0x2a, 0x7d, 0x27, 0x6a, 0xd9, 0x69,
+                0xf5, 0xec, 0x45, 0x17,
+            ],
+            shared_secret: [
+                0x36, 0xd5, 0x4c, 0xab, 0xc6, 0x7f, 0x6c, 0xc7, 0x26, 0xa7, 0x30, 0xf3, 0xa0, 0xce,
+                0xed, 0x58, 0x53, 0xf0, 0x8c, 0xd3, 0x81, 0x46, 0xc8, 0x34, 0x25, 0x98, 0x98, 0x7c,
+                0x21, 0x50, 0x48, 0xa5,
+            ],
+            k_enc: [
+                0x82, 0xc4, 0x32, 0x65, 0x33, 0x7f, 0x1a, 0xb3, 0x7b, 0x18, 0xdf, 0x27, 0x75, 0x48,
+                0x61, 0x82, 0x63, 0xb8, 0x02, 0x4d, 0x9b, 0x14, 0x5a, 0x05, 0xad, 0xe2, 0xeb, 0x54,
+                0x79, 0x18, 0x03, 0x20,
+            ],
+            p_enc: [
+                0x03, 0x56, 0xe8, 0x4b, 0x1a, 0xdc, 0x94, 0x23, 0xc3, 0x67, 0x6c, 0x04, 0x8d, 0x5f,
+                0x29, 0x35, 0x39, 0x5e, 0xe4, 0x76, 0xbf, 0x69, 0xb8, 0x25, 0x0c, 0x18, 0xef, 0x41,
+                0x29, 0x4c, 0xa9, 0x79, 0x93, 0xdb, 0x54, 0x6c, 0x1f, 0xe0, 0x1f, 0x7e, 0x9c, 0x8e,
+                0x36, 0xd6, 0xa5, 0xe2, 0x9d, 0x4e, 0x30, 0xa7, 0x35, 0x94, 0x67, 0x43, 0xf9, 0x3a,
+                0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3, 0x04, 0xfe, 0x32, 0xb2,
+                0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e, 0x7a, 0x59, 0x70, 0x2f,
+                0xff, 0xbf, 0x50, 0x98, 0x42, 0x1c, 0x69, 0x37, 0x8a, 0xf1, 0xe4, 0x0f, 0x64, 0xe1,
+                0x25, 0x94, 0x6f, 0x62, 0xc2, 0xfa, 0x7b, 0x2f, 0xec, 0xbc, 0xb6, 0x4b, 0x69, 0x68,
+                0x91, 0x2a, 0x63, 0x81, 0xce, 0x3d, 0xc1, 0x66, 0xd5, 0x6a, 0x1d, 0x62, 0xf5, 0xa8,
+                0xd7, 0x55, 0x1d, 0xb5, 0xfd, 0x93, 0x13, 0xe8, 0xc7, 0x20, 0x3d, 0x99, 0x6a, 0xf7,
+                0xd4, 0x77, 0x08, 0x37, 0x56, 0xd5, 0x9a, 0xf8, 0x0d, 0x06, 0xa7, 0x45, 0xf4, 0x4a,
+                0xb0, 0x23, 0x75, 0x2c, 0xb5, 0xb4, 0x06, 0xed, 0x89, 0x85, 0xe1, 0x81, 0x30, 0xab,
+                0x33, 0x36, 0x26, 0x97, 0xb0, 0xe4, 0xe4, 0xc7, 0x63, 0xcc, 0xb8, 0xf6, 0x76, 0x49,
+                0x5c, 0x22, 0x2f, 0x7f, 0xba, 0x1e, 0x31, 0xde, 0xfa, 0x3d, 0x5a, 0x57, 0xef, 0xc2,
+                0xe1, 0xe9, 0xb0, 0x1a, 0x03, 0x55, 0x87, 0xd5, 0xfb, 0x1a, 0x38, 0xe0, 0x1d, 0x94,
+                0x90, 0x3d, 0x3c, 0x3e, 0x0a, 0xd3, 0x36, 0x0c, 0x1d, 0x37, 0x10, 0xac, 0xd2, 0x0b,
+                0x18, 0x3e, 0x31, 0xd4, 0x9f, 0x25, 0xc9, 0xa1, 0x38, 0xf4, 0x9b, 0x1a, 0x53, 0x7e,
+                0xdc, 0xf0, 0x4b, 0xe3, 0x4a, 0x98, 0x51, 0xa7, 0xaf, 0x9d, 0xb6, 0x99, 0x0e, 0xd8,
+                0x3d, 0xd6, 0x4a, 0xf3, 0x59, 0x7c, 0x04, 0x32, 0x3e, 0xa5, 0x1b, 0x00, 0x52, 0xad,
+                0x80, 0x84, 0xa8, 0xb9, 0xda, 0x94, 0x8d, 0x32, 0x0d, 0xad, 0xd6, 0x4f, 0x54, 0x31,
+                0xe6, 0x1d, 0xdf, 0x65, 0x8d, 0x24, 0xae, 0x67, 0xc2, 0x2c, 0x8d, 0x13, 0x09, 0x13,
+                0x1f, 0xc0, 0x0f, 0xe7, 0xf2, 0x35, 0x73, 0x42, 0x76, 0xd3, 0x8d, 0x47, 0xf1, 0xe1,
+                0x91, 0xe0, 0x0c, 0x7a, 0x1d, 0x48, 0xaf, 0x04, 0x68, 0x27, 0x59, 0x1e, 0x97, 0x33,
+                0xa9, 0x7f, 0xa6, 0xb6, 0x79, 0xf3, 0xdc, 0x60, 0x1d, 0x00, 0x82, 0x85, 0xed, 0xcb,
+                0xda, 0xe6, 0x9c, 0xe8, 0xfc, 0x1b, 0xe4, 0xaa, 0xc0, 0x0f, 0xf2, 0x71, 0x1e, 0xbd,
+                0x93, 0x1d, 0xe5, 0x18, 0x85, 0x68, 0x78, 0xf7, 0x34, 0x76, 0xf2, 0x1a, 0x48, 0x2e,
+                0xc9, 0x37, 0x83, 0x65, 0xc8, 0xf7, 0x39, 0x3c, 0x94, 0xe2, 0x88, 0x53, 0x15, 0xeb,
+                0x46, 0x71, 0x09, 0x8b, 0x79, 0x53, 0x5e, 0x79, 0x0f, 0xe5, 0x3e, 0x29, 0xfe, 0xf2,
+                0xb3, 0x76, 0x66, 0x97, 0xac, 0x32, 0xb4, 0xf4, 0x73, 0xf4, 0x68, 0xa0, 0x08, 0xe7,
+                0x23, 0x89, 0xfc, 0x03, 0x88, 0x0d, 0x78, 0x0c, 0xb0, 0x7f, 0xcf, 0xaa, 0xbe, 0x3f,
+                0x1a, 0x84, 0xb2, 0x7d, 0xb5, 0x9a, 0x4a, 0x15, 0x3d, 0x88, 0x2d, 0x2b, 0x21, 0x03,
+                0x59, 0x65, 0x55, 0xed, 0x94, 0x94, 0xc6, 0xac, 0x89, 0x3c, 0x49, 0x72, 0x38, 0x33,
+                0xec, 0x89, 0x26, 0xc1, 0x03, 0x95, 0x86, 0xa7, 0xaf, 0xcf, 0x4a, 0x0d, 0x9c, 0x73,
+                0x1e, 0x98, 0x5d, 0x99, 0x58, 0x9c, 0x8b, 0xb8, 0x38, 0xe8, 0xaa, 0xf7, 0x45, 0x53,
+                0x3e, 0xd9, 0xe8, 0xae, 0x3a, 0x1c, 0xd0, 0x74, 0xa5, 0x1a, 0x20, 0xda, 0x8a, 0xba,
+                0x18, 0xd1, 0xdb, 0xeb, 0xbc, 0x86, 0x2d, 0xed, 0x42, 0x43, 0x5e, 0x92, 0x47, 0x69,
+                0x30, 0xd0, 0x69, 0x89, 0x6c, 0xff, 0x30, 0xeb, 0x41, 0x4f, 0x72, 0x7b, 0x89, 0xe0,
+                0x01, 0xaf, 0xa2, 0xfb, 0x8d, 0xc3, 0x43, 0x6d, 0x75, 0xa4, 0xa6, 0xf2, 0x65, 0x72,
+                0x50, 0x4b, 0x19, 0x22, 0x32, 0xec, 0xb9, 0xf0, 0xc0, 0x24, 0x11, 0xe5, 0x25, 0x96,
+                0xbc, 0x5e, 0x90, 0x45, 0x7e, 0x74, 0x59, 0x39, 0xff, 0xed, 0xbd, 0x12, 0x86, 0x3c,
+                0xe7, 0x1a, 0x02, 0xaf, 0x11, 0x7d, 0x41, 0x7a, 0xdb, 0x3d, 0x15, 0xcc, 0x54, 0xdc,
+                0xb1, 0xfc, 0xe4, 0x67, 0x50, 0x0c, 0x6b, 0x8f, 0xb8, 0x6b, 0x12, 0xb5, 0x6d, 0xa9,
+                0xc3, 0x82, 0x85, 0x7d, 0xee, 0xcc, 0x40, 0xa9,
+            ],
+            c_enc: [
+                0x92, 0xe0, 0x48, 0x74, 0xb5, 0x83, 0x7c, 0x26, 0x1d, 0xaf, 0x1a, 0x27, 0xb7, 0x83,
+                0xec, 0x48, 0x65, 0xd3, 0xbb, 0x72, 0x8e, 0xb1, 0x61, 0xda, 0xed, 0xb8, 0x44, 0x6a,
+                0xb3, 0x8f, 0x07, 0x8e, 0xa8, 0x66, 0x2e, 0x4d, 0x2e, 0x9d, 0x00, 0xa3, 0x95, 0x27,
+                0xdc, 0xde, 0x51, 0x7a, 0xc3, 0xdb, 0xf9, 0xd2, 0x7e, 0x3c, 0xe1, 0x06, 0x21, 0xb8,
+                0x97, 0xe9, 0x79, 0x10, 0xba, 0xa5, 0x63, 0xd0, 0xb4, 0xc3, 0x8f, 0x87, 0x77, 0xf9,
+                0xdf, 0xb5, 0x5a, 0x4d, 0x0c, 0xa6, 0x49, 0x80, 0x7a, 0x6e, 0x7e, 0x3b, 0x63, 0x7b,
+                0xe7, 0x83, 0x5c, 0x0c, 0x07, 0x6e, 0x6f, 0x06, 0xee, 0x5c, 0x8a, 0xac, 0x6a, 0xd2,
+                0x13, 0x00, 0xf8, 0xe1, 0xcd, 0x39, 0x5f, 0x69, 0x2d, 0xc5, 0x72, 0xab, 0x07, 0xfd,
+                0x4b, 0xe1, 0xf2, 0xc6, 0x52, 0x09, 0x64, 0xed, 0xec, 0x3b, 0xe5, 0x56, 0x22, 0xac,
+                0x4d, 0x23, 0x85, 0x8c, 0x39, 0x8d, 0xf6, 0x6d, 0x6a, 0x6e, 0x54, 0x60, 0x18, 0xf9,
+                0x81, 0x66, 0x89, 0x24, 0xbe, 0x96, 0x3b, 0x7c, 0xbb, 0x0c, 0x7f, 0x10, 0x4d, 0x16,
+                0x07, 0xfb, 0xcb, 0xc0, 0x18, 0x49, 0xd9, 0x93, 0x72, 0xcb, 0x8e, 0x64, 0xb2, 0xca,
+                0x15, 0xd7, 0xf8, 0xc5, 0x37, 0x20, 0x05, 0xa8, 0x89, 0xd6, 0xa9, 0x31, 0x23, 0x59,
+                0x42, 0x09, 0xe4, 0xd2, 0x59, 0x7b, 0x6e, 0x83, 0x78, 0x2e, 0x5d, 0x1a, 0xb0, 0xc5,
+                0xd6, 0x42, 0xbe, 0x32, 0xe7, 0xb4, 0x89, 0x85, 0xaa, 0x07, 0x7e, 0x9a, 0x76, 0xbd,
+                0xe2, 0x7d, 0xf4, 0x26, 0x74, 0x8b, 0xf3, 0x25, 0x52, 0x01, 0x56, 0x88, 0xb3, 0x6e,
+                0x34, 0xff, 0x9d, 0x22, 0x11, 0xd8, 0x72, 0xfb, 0x23, 0x6a, 0x18, 0x2f, 0xe4, 0xf2,
+                0x87, 0xa5, 0x5b, 0xfc, 0xee, 0xa3, 0xed, 0x99, 0xfd, 0xc2, 0x91, 0xf9, 0x1d, 0x6e,
+                0xf8, 0xd2, 0x9a, 0x27, 0x8f, 0xa6, 0x46, 0xe8, 0xe7, 0xdc, 0x66, 0xd4, 0x9b, 0x38,
+                0x62, 0x26, 0x7e, 0xd5, 0x8b, 0x31, 0x66, 0x09, 0x97, 0xa5, 0x8f, 0x29, 0x73, 0x5c,
+                0xc6, 0xe5, 0x98, 0x65, 0x54, 0x2f, 0x5d, 0x90, 0x8c, 0xe5, 0x2d, 0x9f, 0x5b, 0x29,
+                0xc9, 0x78, 0x24, 0xd1, 0x4d, 0x4d, 0x64, 0xcd, 0xbe, 0x56, 0x93, 0xb5, 0x1b, 0x7e,
+                0xc7, 0x31, 0xc9, 0x92, 0x4b, 0x4f, 0x47, 0x5a, 0x14, 0xd0, 0x58, 0x7b, 0xe6, 0x45,
+                0x44, 0x8a, 0x07, 0x55, 0x4f, 0x15, 0xbc, 0x9d, 0xaf, 0xa1, 0xf7, 0x38, 0x6a, 0xe8,
+                0x6f, 0x71, 0x48, 0x2b, 0x35, 0x6e, 0xa7, 0x9c, 0xdc, 0x44, 0x73, 0x2c, 0xfa, 0x41,
+                0x46, 0xe6, 0xca, 0x51, 0x04, 0xf0, 0xa4, 0x60, 0x7b, 0xd6, 0x4b, 0x58, 0x39, 0x6e,
+                0x44, 0x3f, 0xad, 0x2c, 0xfc, 0x36, 0xdd, 0xd3, 0xae, 0x9a, 0xa4, 0xbe, 0xa8, 0x7a,
+                0xde, 0xd5, 0xec, 0x35, 0x17, 0x42, 0xfc, 0x5a, 0x90, 0x6a, 0xd0, 0x54, 0xd3, 0x59,
+                0x43, 0x16, 0xcc, 0x54, 0xb8, 0x74, 0xbb, 0xce, 0xc2, 0xa8, 0x14, 0x31, 0x50, 0x18,
+                0xbc, 0x7e, 0x1d, 0x3c, 0x74, 0x84, 0x72, 0xbd, 0x96, 0x77, 0x76, 0x5d, 0xcf, 0x59,
+                0xb1, 0x6d, 0x55, 0xa3, 0xf1, 0x86, 0x4f, 0x75, 0x1a, 0x69, 0x3d, 0x76, 0x9c, 0xc7,
+                0x6b, 0x8e, 0x32, 0x8a, 0x9a, 0xc8, 0x3b, 0xe1, 0x78, 0x39, 0x1b, 0xeb, 0x5f, 0x28,
+                0xab, 0x69, 0x2b, 0x6f, 0x02, 0xa3, 0xf7, 0x49, 0x8a, 0x4b, 0xc5, 0x51, 0xf8, 0x48,
+                0x7d, 0xae, 0xba, 0x3b, 0xe0, 0x2e, 0xb0, 0x20, 0xc1, 0x60, 0xf8, 0x78, 0x53, 0x91,
+                0xaa, 0x03, 0xde, 0x44, 0x7b, 0x37, 0xf9, 0x5b, 0xec, 0xfe, 0x3e, 0xca, 0x95, 0xae,
+                0x62, 0xab, 0xa0, 0x82, 0x20, 0xee, 0x87, 0xd2, 0x48, 0x16, 0xb0, 0x99, 0x5f, 0x27,
+                0x30, 0xe8, 0xff, 0x9a, 0xca, 0x21, 0x8b, 0x88, 0xe3, 0x1b, 0x1f, 0xb7, 0x78, 0x3a,
+                0x29, 0x80, 0xf7, 0xb2, 0x98, 0x44, 0xc1, 0x06, 0x26, 0xa2, 0x13, 0xa9, 0x81, 0x41,
+                0x7d, 0x90, 0xdf, 0xf9, 0xfb, 0x2a, 0xba, 0xfe, 0xc8, 0x38, 0x23, 0x0e, 0x1a, 0x55,
+                0xcf, 0xc5, 0xf7, 0xf8, 0x19, 0xab, 0xf6, 0xe5, 0xb0, 0xa7, 0x48, 0x3b, 0xf1, 0xbc,
+                0xeb, 0x15, 0xe8, 0x5b, 0xfe, 0x12, 0xfd, 0x55, 0x02, 0x81, 0xe5, 0x28, 0x20, 0xd0,
+                0xbd, 0xb2, 0xa5, 0xba, 0x34, 0xe3, 0x74, 0xca, 0x2f, 0xfd, 0xac, 0x56, 0xce, 0x51,
+                0x3c, 0xf3, 0xdd, 0x23, 0xde, 0x9f, 0xb4, 0xa1, 0xd2, 0xff, 0x4f, 0xfe, 0x74, 0x9b,
+                0xd8, 0xcb, 0x30, 0x8f, 0x9a, 0xf7, 0xb6, 0xfe, 0xa2, 0x39,
+            ],
+            ock: [
+                0xb3, 0x25, 0xeb, 0xe5, 0x7a, 0x2c, 0x40, 0xa8, 0xb2, 0x11, 0xcf, 0xdf, 0x72, 0xa1,
+                0xa2, 0x44, 0xf1, 0x53, 0x42, 0x85, 0x98, 0x88, 0xa3, 0x64, 0x52, 0x3e, 0xfd, 0x2a,
+                0xc6, 0x6a, 0x1a, 0xd6,
+            ],
+            op: [
+                0x63, 0xf7, 0x12, 0x5d, 0xf4, 0x83, 0x6f, 0xd2, 0x81, 0x6b, 0x02, 0x4e, 0xe7, 0x0e,
+                0xfe, 0x09, 0xfb, 0x9a, 0x7b, 0x38, 0x63, 0xc6, 0xea, 0xcd, 0xf9, 0x5e, 0x03, 0x89,
+                0x49, 0x50, 0x69, 0x2c, 0x5b, 0xfe, 0x46, 0x9c, 0x33, 0xe4, 0x47, 0xba, 0x45, 0x6b,
+                0x8b, 0xfe, 0x9b, 0x38, 0x5b, 0x39, 0x31, 0xb4, 0xba, 0xeb, 0x8f, 0x70, 0x23, 0xfe,
+                0x8e, 0x33, 0x35, 0x4f, 0xff, 0xf1, 0xbd, 0x1a,
+            ],
+            c_out: [
+                0x55, 0xb8, 0x90, 0x7c, 0x6d, 0x45, 0x4b, 0x83, 0x63, 0x4f, 0x1b, 0x9a, 0x1a, 0xa3,
+                0xc3, 0xc9, 0x8a, 0xdc, 0x77, 0xd9, 0x6c, 0x2f, 0x62, 0x49, 0xec, 0x66, 0xdb, 0xae,
+                0x4d, 0x0c, 0xc9, 0x40, 0xd7, 0x26, 0xbc, 0xd1, 0xec, 0x91, 0x18, 0x9f, 0xd3, 0x04,
+                0x9a, 0x33, 0xf2, 0xea, 0x7d, 0x8b, 0x74, 0xaa, 0xc1, 0x7c, 0xda, 0x38, 0x83, 0x80,
+                0x2d, 0xb5, 0x96, 0x9d, 0x8d, 0x2f, 0x32, 0x25, 0x91, 0x9c, 0xe3, 0x88, 0x26, 0x41,
+                0x5c, 0xc6, 0xb3, 0x38, 0x94, 0x4b, 0x48, 0x99, 0x54, 0x8b,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xfd, 0x9e, 0x9a, 0x1f, 0x38, 0x1c, 0xbe, 0x75, 0xcd, 0x8d, 0x6a, 0xe1, 0x2f, 0xca,
+                0x87, 0x2e, 0x94, 0x00, 0xf0, 0x02, 0x72, 0xb0, 0x29, 0x65, 0x2e, 0x65, 0x6c, 0x8f,
+                0x3c, 0x4b, 0xf0, 0x37, 0xee, 0xef, 0x96, 0x42, 0x1b, 0x2f, 0xab, 0x2f, 0xb3, 0xad,
+                0x1e, 0x0a, 0xd8, 0x50, 0x2d, 0x74, 0xe6, 0xf0, 0x8f, 0x0d, 0xd5, 0x18, 0xf8, 0xfa,
+                0x82, 0x2a, 0x65, 0xbe, 0x27, 0x40, 0xc0, 0x21,
+            ],
+            ovk: [
+                0xe7, 0x30, 0x81, 0xef, 0x8d, 0x62, 0xcb, 0x78, 0x0a, 0xb6, 0x88, 0x3a, 0x50, 0xa0,
+                0xd4, 0x70, 0x19, 0x0d, 0xfb, 0xa1, 0x0a, 0x85, 0x7f, 0x82, 0x84, 0x2d, 0x38, 0x25,
+                0xb3, 0xd6, 0xda, 0x05,
+            ],
+            default_d: [
+                0x55, 0x6e, 0x5e, 0x1b, 0xf5, 0x1b, 0xc6, 0xa6, 0x11, 0x58, 0xf7,
+            ],
+            default_pk_d: [
+                0xb4, 0xca, 0xc5, 0x6f, 0x06, 0x2b, 0xfb, 0x2e, 0x27, 0x15, 0xea, 0xf9, 0xc8, 0xfc,
+                0xdb, 0xc2, 0x0c, 0x86, 0x79, 0x3f, 0x23, 0x57, 0xdd, 0xd0, 0x4a, 0xad, 0x39, 0xf9,
+                0x4a, 0xd7, 0xc7, 0x84,
+            ],
+            v: 9072946746592546880,
+            rseed: [
+                0xae, 0xab, 0x01, 0x6b, 0x6b, 0xc1, 0xec, 0x14, 0x4b, 0x4e, 0x55, 0x3a, 0xcf, 0xd6,
+                0x70, 0xf7, 0x7e, 0x75, 0x5f, 0xc8, 0x8e, 0x06, 0x77, 0xe3, 0x1b, 0xa4, 0x59, 0xb4,
+                0x4e, 0x30, 0x77, 0x68,
+            ],
+            asset: [
+                0x67, 0x43, 0xf9, 0x3a, 0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3,
+                0x04, 0xfe, 0x32, 0xb2, 0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e,
+                0x7a, 0x59, 0x70, 0x2f,
+            ],
+            memo: [
+                0xff, 0x95, 0x8f, 0xe3, 0x78, 0x9d, 0x41, 0xc2, 0xb1, 0xff, 0x43, 0x4c, 0xb3, 0x0e,
+                0x15, 0x91, 0x4f, 0x01, 0xbc, 0x6b, 0xc2, 0x30, 0x7b, 0x48, 0x8d, 0x25, 0x56, 0xd7,
+                0xb7, 0x38, 0x0e, 0xa4, 0xff, 0xd7, 0x12, 0xf6, 0xb0, 0x2f, 0xe8, 0x06, 0xb9, 0x45,
+                0x69, 0xcd, 0x40, 0x59, 0xf3, 0x96, 0xbf, 0x29, 0xb9, 0x9d, 0x0a, 0x40, 0xe5, 0xe1,
+                0x71, 0x1c, 0xa9, 0x44, 0xf7, 0x2d, 0x43, 0x6a, 0x10, 0x2f, 0xca, 0x4b, 0x97, 0x69,
+                0x3d, 0xa0, 0xb0, 0x86, 0xfe, 0x9d, 0x2e, 0x71, 0x62, 0x47, 0x0d, 0x02, 0xe0, 0xf0,
+                0x5d, 0x4b, 0xec, 0x95, 0x12, 0xbf, 0xb3, 0xf3, 0x83, 0x27, 0x29, 0x6e, 0xfa, 0xa7,
+                0x43, 0x28, 0xb1, 0x18, 0xc2, 0x74, 0x02, 0xc7, 0x0c, 0x3a, 0x90, 0xb4, 0x9a, 0xd4,
+                0xbb, 0xc6, 0x8e, 0x37, 0xc0, 0xaa, 0x7d, 0x9b, 0x3f, 0xe1, 0x77, 0x99, 0xd7, 0x3b,
+                0x84, 0x1e, 0x75, 0x17, 0x13, 0xa0, 0x29, 0x43, 0x90, 0x5a, 0xae, 0x08, 0x03, 0xfd,
+                0x69, 0x44, 0x2e, 0xb7, 0x68, 0x1e, 0xc2, 0xa0, 0x56, 0x00, 0x05, 0x4e, 0x92, 0xee,
+                0xd5, 0x55, 0x02, 0x8f, 0x21, 0xb6, 0xa1, 0x55, 0x26, 0x8a, 0x2d, 0xd6, 0x64, 0x0a,
+                0x69, 0x30, 0x1a, 0x52, 0xa3, 0x8d, 0x4d, 0x9f, 0x9f, 0x95, 0x7a, 0xe3, 0x5a, 0xf7,
+                0x16, 0x71, 0x18, 0x14, 0x1c, 0xe4, 0xc9, 0xbe, 0x0a, 0x6a, 0x49, 0x2f, 0xe7, 0x9f,
+                0x15, 0x81, 0xa1, 0x55, 0xfa, 0x3a, 0x2b, 0x9d, 0xaf, 0xd8, 0x2e, 0x65, 0x0b, 0x38,
+                0x6a, 0xd3, 0xa0, 0x8c, 0xb6, 0xb8, 0x31, 0x31, 0xac, 0x30, 0x0b, 0x08, 0x46, 0x35,
+                0x4a, 0x7e, 0xef, 0x9c, 0x41, 0x0e, 0x4b, 0x62, 0xc4, 0x7c, 0x54, 0x26, 0x90, 0x7d,
+                0xfc, 0x66, 0x85, 0xc5, 0xc9, 0x9b, 0x71, 0x41, 0xac, 0x62, 0x6a, 0xb4, 0x76, 0x1f,
+                0xd3, 0xf4, 0x1e, 0x72, 0x8e, 0x1a, 0x28, 0xf8, 0x9d, 0xb8, 0x9f, 0xfd, 0xec, 0xa3,
+                0x64, 0xdd, 0x2f, 0x0f, 0x07, 0x39, 0xf0, 0x53, 0x45, 0x56, 0x48, 0x31, 0x99, 0xc7,
+                0x1f, 0x18, 0x93, 0x41, 0xac, 0x9b, 0x78, 0xa2, 0x69, 0x16, 0x42, 0x06, 0xa0, 0xea,
+                0x1c, 0xe7, 0x3b, 0xfb, 0x2a, 0x94, 0x2e, 0x73, 0x70, 0xb2, 0x47, 0xc0, 0x46, 0xf8,
+                0xe7, 0x5e, 0xf8, 0xe3, 0xf8, 0xbd, 0x82, 0x1c, 0xf5, 0x77, 0x49, 0x18, 0x64, 0xe2,
+                0x0e, 0x6d, 0x08, 0xfd, 0x2e, 0x32, 0xb5, 0x55, 0xc9, 0x2c, 0x66, 0x1f, 0x19, 0x58,
+                0x8b, 0x72, 0xa8, 0x95, 0x99, 0x71, 0x0a, 0x88, 0x06, 0x12, 0x53, 0xca, 0x28, 0x5b,
+                0x63, 0x04, 0xb3, 0x7d, 0xa2, 0xb5, 0x29, 0x4f, 0x5c, 0xb3, 0x54, 0xa8, 0x94, 0x32,
+                0x28, 0x48, 0xcc, 0xbd, 0xc7, 0xc2, 0x54, 0x5b, 0x7d, 0xa5, 0x68, 0xaf, 0xac, 0x87,
+                0xff, 0xa0, 0x05, 0xc3, 0x12, 0x24, 0x1c, 0x2d, 0x57, 0xf4, 0xb4, 0x5d, 0x64, 0x19,
+                0xf0, 0xd2, 0xe2, 0xc5, 0xaf, 0x33, 0xae, 0x24, 0x37, 0x85, 0xb3, 0x25, 0xcd, 0xab,
+                0x95, 0x40, 0x4f, 0xc7, 0xae, 0xd7, 0x05, 0x25, 0xcd, 0xdb, 0x41, 0x87, 0x2c, 0xfc,
+                0xc2, 0x14, 0xb1, 0x32, 0x32, 0xed, 0xc7, 0x86, 0x09, 0x75, 0x3d, 0xbf, 0xf9, 0x30,
+                0xeb, 0x0d, 0xc1, 0x56, 0x61, 0x2b, 0x9c, 0xb4, 0x34, 0xbc, 0x4b, 0x69, 0x33, 0x92,
+                0xde, 0xb8, 0x7c, 0x53, 0x04, 0x35, 0x31, 0x2e, 0xdc, 0xed, 0xc6, 0xa9, 0x61, 0x13,
+                0x33, 0x38, 0xd7, 0x86, 0xc4, 0xa3, 0xe1, 0x03, 0xf6, 0x01, 0x10, 0xa1, 0x6b, 0x13,
+                0x37, 0x12, 0x97, 0x04, 0xbf, 0x47, 0x54, 0xff, 0x6b, 0xa9, 0xfb, 0xe6, 0x59, 0x51,
+                0xe6, 0x10, 0x62, 0x0f, 0x71, 0xcd, 0xa8, 0xfc, 0x87, 0x76, 0x25, 0xf2, 0xc5, 0xbb,
+                0x04, 0xcb, 0xe1, 0x22, 0x8b, 0x1e, 0x88, 0x6f,
+            ],
+            cv_net: [
+                0x15, 0x49, 0x70, 0x7e, 0x1e, 0xd2, 0xb2, 0xeb, 0x66, 0x15, 0x65, 0x0b, 0xec, 0x45,
+                0xa2, 0x17, 0x64, 0x10, 0x4a, 0x23, 0xea, 0xf6, 0xba, 0x49, 0x6c, 0xb9, 0xb8, 0xe8,
+                0x25, 0x7a, 0xd8, 0xb3,
+            ],
+            rho: [
+                0xc1, 0xe1, 0x59, 0x5b, 0x8d, 0xe7, 0x55, 0x97, 0x66, 0xe5, 0xa6, 0x72, 0x5f, 0x5b,
+                0xe5, 0x74, 0x2f, 0x43, 0xbf, 0x40, 0x62, 0x3b, 0x71, 0x49, 0xca, 0xe2, 0x67, 0x5c,
+                0x4d, 0xb2, 0xc7, 0x31,
+            ],
+            cmx: [
+                0x59, 0xb6, 0xf3, 0xd4, 0x03, 0x22, 0x3d, 0x6c, 0xe4, 0x3d, 0xed, 0xae, 0xe2, 0x35,
+                0xfc, 0xa9, 0x5c, 0xc8, 0xb2, 0x49, 0x94, 0x1c, 0xcd, 0xb6, 0x6f, 0x3f, 0x61, 0x1c,
+                0xc5, 0xe9, 0xf9, 0x0f,
+            ],
+            esk: [
+                0x10, 0x87, 0x4a, 0x74, 0x22, 0x7a, 0xc7, 0x99, 0x5e, 0xdd, 0xdd, 0x73, 0x4d, 0x0e,
+                0x00, 0xdc, 0xc9, 0xf4, 0x8a, 0x01, 0xdd, 0x5c, 0x4c, 0xb1, 0x22, 0xc0, 0x61, 0xe0,
+                0xbd, 0xc9, 0xce, 0x14,
+            ],
+            ephemeral_key: [
+                0xd2, 0x9e, 0x0d, 0x00, 0x1e, 0xe7, 0x1e, 0x05, 0x99, 0x08, 0x65, 0x04, 0xd8, 0x62,
+                0xc7, 0xf5, 0x2b, 0x08, 0x60, 0x77, 0x0d, 0x8a, 0x4b, 0x42, 0xa8, 0x68, 0x11, 0xac,
+                0x31, 0x69, 0x85, 0x8c,
+            ],
+            shared_secret: [
+                0x11, 0xa0, 0xac, 0x79, 0x9a, 0x29, 0xb0, 0xed, 0x19, 0x5e, 0xd8, 0x7b, 0x13, 0x83,
+                0x22, 0x26, 0x3b, 0xbb, 0x9c, 0x31, 0x00, 0x8c, 0x29, 0x59, 0xaf, 0x2f, 0xc6, 0x36,
+                0x68, 0x7e, 0xd9, 0xb0,
+            ],
+            k_enc: [
+                0x4b, 0xbf, 0x80, 0xe7, 0xa1, 0x70, 0x3a, 0xc1, 0x4a, 0xd7, 0xb5, 0x44, 0x8a, 0x2e,
+                0x8e, 0x79, 0x49, 0x30, 0x49, 0xd1, 0x9a, 0x6a, 0x51, 0x31, 0x67, 0xd5, 0x5b, 0xdd,
+                0x58, 0x6a, 0xc0, 0xd9,
+            ],
+            p_enc: [
+                0x03, 0x55, 0x6e, 0x5e, 0x1b, 0xf5, 0x1b, 0xc6, 0xa6, 0x11, 0x58, 0xf7, 0x40, 0x50,
+                0xaf, 0xd8, 0xfe, 0x94, 0xe9, 0x7d, 0xae, 0xab, 0x01, 0x6b, 0x6b, 0xc1, 0xec, 0x14,
+                0x4b, 0x4e, 0x55, 0x3a, 0xcf, 0xd6, 0x70, 0xf7, 0x7e, 0x75, 0x5f, 0xc8, 0x8e, 0x06,
+                0x77, 0xe3, 0x1b, 0xa4, 0x59, 0xb4, 0x4e, 0x30, 0x77, 0x68, 0x67, 0x43, 0xf9, 0x3a,
+                0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3, 0x04, 0xfe, 0x32, 0xb2,
+                0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e, 0x7a, 0x59, 0x70, 0x2f,
+                0xff, 0x95, 0x8f, 0xe3, 0x78, 0x9d, 0x41, 0xc2, 0xb1, 0xff, 0x43, 0x4c, 0xb3, 0x0e,
+                0x15, 0x91, 0x4f, 0x01, 0xbc, 0x6b, 0xc2, 0x30, 0x7b, 0x48, 0x8d, 0x25, 0x56, 0xd7,
+                0xb7, 0x38, 0x0e, 0xa4, 0xff, 0xd7, 0x12, 0xf6, 0xb0, 0x2f, 0xe8, 0x06, 0xb9, 0x45,
+                0x69, 0xcd, 0x40, 0x59, 0xf3, 0x96, 0xbf, 0x29, 0xb9, 0x9d, 0x0a, 0x40, 0xe5, 0xe1,
+                0x71, 0x1c, 0xa9, 0x44, 0xf7, 0x2d, 0x43, 0x6a, 0x10, 0x2f, 0xca, 0x4b, 0x97, 0x69,
+                0x3d, 0xa0, 0xb0, 0x86, 0xfe, 0x9d, 0x2e, 0x71, 0x62, 0x47, 0x0d, 0x02, 0xe0, 0xf0,
+                0x5d, 0x4b, 0xec, 0x95, 0x12, 0xbf, 0xb3, 0xf3, 0x83, 0x27, 0x29, 0x6e, 0xfa, 0xa7,
+                0x43, 0x28, 0xb1, 0x18, 0xc2, 0x74, 0x02, 0xc7, 0x0c, 0x3a, 0x90, 0xb4, 0x9a, 0xd4,
+                0xbb, 0xc6, 0x8e, 0x37, 0xc0, 0xaa, 0x7d, 0x9b, 0x3f, 0xe1, 0x77, 0x99, 0xd7, 0x3b,
+                0x84, 0x1e, 0x75, 0x17, 0x13, 0xa0, 0x29, 0x43, 0x90, 0x5a, 0xae, 0x08, 0x03, 0xfd,
+                0x69, 0x44, 0x2e, 0xb7, 0x68, 0x1e, 0xc2, 0xa0, 0x56, 0x00, 0x05, 0x4e, 0x92, 0xee,
+                0xd5, 0x55, 0x02, 0x8f, 0x21, 0xb6, 0xa1, 0x55, 0x26, 0x8a, 0x2d, 0xd6, 0x64, 0x0a,
+                0x69, 0x30, 0x1a, 0x52, 0xa3, 0x8d, 0x4d, 0x9f, 0x9f, 0x95, 0x7a, 0xe3, 0x5a, 0xf7,
+                0x16, 0x71, 0x18, 0x14, 0x1c, 0xe4, 0xc9, 0xbe, 0x0a, 0x6a, 0x49, 0x2f, 0xe7, 0x9f,
+                0x15, 0x81, 0xa1, 0x55, 0xfa, 0x3a, 0x2b, 0x9d, 0xaf, 0xd8, 0x2e, 0x65, 0x0b, 0x38,
+                0x6a, 0xd3, 0xa0, 0x8c, 0xb6, 0xb8, 0x31, 0x31, 0xac, 0x30, 0x0b, 0x08, 0x46, 0x35,
+                0x4a, 0x7e, 0xef, 0x9c, 0x41, 0x0e, 0x4b, 0x62, 0xc4, 0x7c, 0x54, 0x26, 0x90, 0x7d,
+                0xfc, 0x66, 0x85, 0xc5, 0xc9, 0x9b, 0x71, 0x41, 0xac, 0x62, 0x6a, 0xb4, 0x76, 0x1f,
+                0xd3, 0xf4, 0x1e, 0x72, 0x8e, 0x1a, 0x28, 0xf8, 0x9d, 0xb8, 0x9f, 0xfd, 0xec, 0xa3,
+                0x64, 0xdd, 0x2f, 0x0f, 0x07, 0x39, 0xf0, 0x53, 0x45, 0x56, 0x48, 0x31, 0x99, 0xc7,
+                0x1f, 0x18, 0x93, 0x41, 0xac, 0x9b, 0x78, 0xa2, 0x69, 0x16, 0x42, 0x06, 0xa0, 0xea,
+                0x1c, 0xe7, 0x3b, 0xfb, 0x2a, 0x94, 0x2e, 0x73, 0x70, 0xb2, 0x47, 0xc0, 0x46, 0xf8,
+                0xe7, 0x5e, 0xf8, 0xe3, 0xf8, 0xbd, 0x82, 0x1c, 0xf5, 0x77, 0x49, 0x18, 0x64, 0xe2,
+                0x0e, 0x6d, 0x08, 0xfd, 0x2e, 0x32, 0xb5, 0x55, 0xc9, 0x2c, 0x66, 0x1f, 0x19, 0x58,
+                0x8b, 0x72, 0xa8, 0x95, 0x99, 0x71, 0x0a, 0x88, 0x06, 0x12, 0x53, 0xca, 0x28, 0x5b,
+                0x63, 0x04, 0xb3, 0x7d, 0xa2, 0xb5, 0x29, 0x4f, 0x5c, 0xb3, 0x54, 0xa8, 0x94, 0x32,
+                0x28, 0x48, 0xcc, 0xbd, 0xc7, 0xc2, 0x54, 0x5b, 0x7d, 0xa5, 0x68, 0xaf, 0xac, 0x87,
+                0xff, 0xa0, 0x05, 0xc3, 0x12, 0x24, 0x1c, 0x2d, 0x57, 0xf4, 0xb4, 0x5d, 0x64, 0x19,
+                0xf0, 0xd2, 0xe2, 0xc5, 0xaf, 0x33, 0xae, 0x24, 0x37, 0x85, 0xb3, 0x25, 0xcd, 0xab,
+                0x95, 0x40, 0x4f, 0xc7, 0xae, 0xd7, 0x05, 0x25, 0xcd, 0xdb, 0x41, 0x87, 0x2c, 0xfc,
+                0xc2, 0x14, 0xb1, 0x32, 0x32, 0xed, 0xc7, 0x86, 0x09, 0x75, 0x3d, 0xbf, 0xf9, 0x30,
+                0xeb, 0x0d, 0xc1, 0x56, 0x61, 0x2b, 0x9c, 0xb4, 0x34, 0xbc, 0x4b, 0x69, 0x33, 0x92,
+                0xde, 0xb8, 0x7c, 0x53, 0x04, 0x35, 0x31, 0x2e, 0xdc, 0xed, 0xc6, 0xa9, 0x61, 0x13,
+                0x33, 0x38, 0xd7, 0x86, 0xc4, 0xa3, 0xe1, 0x03, 0xf6, 0x01, 0x10, 0xa1, 0x6b, 0x13,
+                0x37, 0x12, 0x97, 0x04, 0xbf, 0x47, 0x54, 0xff, 0x6b, 0xa9, 0xfb, 0xe6, 0x59, 0x51,
+                0xe6, 0x10, 0x62, 0x0f, 0x71, 0xcd, 0xa8, 0xfc, 0x87, 0x76, 0x25, 0xf2, 0xc5, 0xbb,
+                0x04, 0xcb, 0xe1, 0x22, 0x8b, 0x1e, 0x88, 0x6f,
+            ],
+            c_enc: [
+                0x1a, 0x42, 0x34, 0x80, 0xbf, 0x37, 0x67, 0xf5, 0xeb, 0xfc, 0x40, 0xb8, 0xc8, 0x9c,
+                0xc5, 0x34, 0xf1, 0x65, 0xc3, 0x5d, 0x19, 0xc8, 0xda, 0x6c, 0x32, 0x10, 0xe9, 0x52,
+                0xca, 0xd8, 0x23, 0xa7, 0x84, 0x60, 0x21, 0xc3, 0xde, 0x4a, 0x86, 0x93, 0xb7, 0x1e,
+                0x28, 0x7f, 0x46, 0x86, 0xac, 0x0a, 0xdd, 0xce, 0xd9, 0x4e, 0x22, 0x57, 0x7c, 0x40,
+                0x9d, 0xa2, 0xdc, 0xa2, 0xef, 0xc2, 0xb3, 0xf8, 0x86, 0x97, 0xf5, 0xed, 0x20, 0x5a,
+                0xb2, 0xf9, 0xea, 0x29, 0x85, 0xdd, 0x8b, 0x91, 0xb3, 0x2c, 0x1d, 0x7a, 0x8d, 0xa3,
+                0xe8, 0x60, 0x57, 0xe8, 0x70, 0x8c, 0x7e, 0xb1, 0x32, 0x32, 0xaf, 0x56, 0x5d, 0xa5,
+                0xa3, 0x5d, 0xe5, 0x06, 0x26, 0x29, 0x6a, 0xa6, 0x07, 0x1a, 0xa0, 0x0a, 0x2c, 0xf2,
+                0x47, 0x3f, 0xa8, 0x0b, 0xfd, 0xbb, 0x95, 0x89, 0x48, 0x2a, 0x83, 0x5d, 0x56, 0xd2,
+                0x27, 0xe6, 0x29, 0xe3, 0x5b, 0x2f, 0xb0, 0xf3, 0xdd, 0x38, 0xf1, 0x3b, 0xaa, 0x24,
+                0xe5, 0x88, 0x26, 0x66, 0x25, 0x31, 0x07, 0x6a, 0xab, 0x9f, 0x4e, 0x3d, 0xe2, 0xc0,
+                0xd0, 0x03, 0xe8, 0xd1, 0x0a, 0x8a, 0x70, 0x64, 0x3f, 0xe2, 0x4b, 0x1e, 0x4a, 0x2b,
+                0x6d, 0x42, 0x74, 0xbc, 0xc5, 0xfc, 0xe0, 0x49, 0x3a, 0xec, 0x37, 0xe3, 0x24, 0xe9,
+                0xb5, 0x13, 0x47, 0xe3, 0x20, 0xa8, 0xa0, 0x0d, 0xd6, 0xd6, 0xcd, 0x3a, 0x46, 0x70,
+                0x4b, 0x90, 0xaf, 0x0d, 0x30, 0xe1, 0xda, 0x33, 0x7a, 0x2a, 0x82, 0x98, 0x26, 0xce,
+                0x70, 0xf4, 0xf8, 0xa7, 0xcd, 0x31, 0x37, 0x59, 0x42, 0xda, 0x53, 0x4b, 0x68, 0x8b,
+                0xf0, 0xbe, 0x8b, 0x6b, 0x90, 0x52, 0x6b, 0x18, 0x1d, 0x9f, 0x07, 0x2f, 0x60, 0x83,
+                0x42, 0xb2, 0x4c, 0x89, 0xda, 0xd7, 0xf7, 0xf3, 0x07, 0x9f, 0xe9, 0x9b, 0x6c, 0xfc,
+                0x73, 0x38, 0xc2, 0x86, 0x94, 0x2c, 0xab, 0x60, 0x72, 0x95, 0x3f, 0x08, 0x6d, 0x59,
+                0xa1, 0xd6, 0x60, 0x00, 0xa4, 0xea, 0x6a, 0xe6, 0x3f, 0xbb, 0xfc, 0x5d, 0xc7, 0x6e,
+                0x23, 0x14, 0x29, 0x88, 0x72, 0x5d, 0xea, 0x47, 0x43, 0x52, 0x2b, 0x92, 0x2c, 0xeb,
+                0x89, 0xf1, 0x94, 0x8c, 0xe9, 0x43, 0xd5, 0x73, 0x66, 0x10, 0x30, 0xfe, 0x0c, 0xec,
+                0x60, 0x7b, 0xd2, 0x47, 0xc9, 0xb5, 0x91, 0x84, 0x3d, 0x3e, 0x38, 0xa9, 0x47, 0x29,
+                0x29, 0x8e, 0x60, 0x05, 0xdf, 0xd9, 0xf4, 0xf0, 0xf4, 0x86, 0xcb, 0xa7, 0xb6, 0x51,
+                0xd5, 0xb9, 0xd3, 0xd7, 0xae, 0x64, 0x48, 0xe3, 0x9d, 0x19, 0xd7, 0x77, 0x41, 0x79,
+                0x2d, 0x60, 0x9c, 0x2e, 0xb9, 0x7f, 0xa9, 0xba, 0x6e, 0x0b, 0x33, 0xdf, 0x17, 0xff,
+                0x0f, 0x3c, 0x61, 0x16, 0x38, 0x9f, 0x3d, 0xa3, 0xb0, 0xd6, 0x56, 0xb9, 0x15, 0x3e,
+                0xb3, 0x3f, 0x1b, 0xb5, 0x03, 0x94, 0xd7, 0x37, 0xb6, 0x78, 0x15, 0x35, 0xe9, 0x2b,
+                0xcc, 0x8a, 0x7e, 0x56, 0xe6, 0x08, 0x02, 0x33, 0x3f, 0xea, 0x10, 0xde, 0xb6, 0xc7,
+                0x9b, 0x66, 0x3d, 0xdd, 0x92, 0x82, 0x84, 0x91, 0x46, 0x23, 0x3f, 0x07, 0x8a, 0xbb,
+                0x6d, 0x38, 0xec, 0x80, 0x7c, 0x45, 0x79, 0x4d, 0xf4, 0xaa, 0xfe, 0xe8, 0xd7, 0x58,
+                0xb9, 0xda, 0xb4, 0xf3, 0x9a, 0xbd, 0x9a, 0xce, 0x42, 0xea, 0x39, 0x88, 0x9d, 0x5f,
+                0x40, 0x24, 0x12, 0x24, 0xa9, 0xe1, 0x17, 0x1b, 0xad, 0xcf, 0x4c, 0x5a, 0x75, 0x9e,
+                0x3b, 0xb9, 0xc7, 0x9e, 0x3d, 0x1c, 0x72, 0xb4, 0xaf, 0x65, 0x81, 0xe0, 0x7b, 0xde,
+                0xdf, 0xc1, 0x7f, 0xe6, 0x82, 0x70, 0x79, 0x9c, 0x3b, 0xb0, 0x8b, 0x11, 0xfe, 0xfe,
+                0xb1, 0xed, 0xb2, 0xbb, 0xa0, 0xf1, 0x14, 0x6b, 0x54, 0x01, 0x2a, 0xd3, 0x17, 0x57,
+                0x10, 0x2c, 0xaa, 0x5d, 0xee, 0x1f, 0xcf, 0x1f, 0x97, 0x13, 0x34, 0x0d, 0xa2, 0x52,
+                0xbd, 0x41, 0xed, 0x4a, 0xe2, 0x11, 0xf3, 0x5f, 0x88, 0x99, 0x1e, 0x1f, 0xe3, 0x47,
+                0xd7, 0x0f, 0x52, 0xcd, 0x12, 0xd7, 0x36, 0x13, 0xcd, 0x13, 0xcf, 0xb1, 0x2e, 0xb2,
+                0x5f, 0x83, 0x2b, 0x34, 0xc8, 0xb6, 0x69, 0x3a, 0x85, 0xb4, 0x00, 0xfc, 0xe3, 0x03,
+                0xdc, 0xcb, 0x3f, 0x8d, 0x90, 0xf5, 0xb7, 0x0c, 0x1e, 0x00, 0xd1, 0xb5, 0x41, 0xe0,
+                0xe1, 0x37, 0x3c, 0xc0, 0xc4, 0x05, 0x00, 0x72, 0x18, 0x76, 0x90, 0xf1, 0x38, 0xfd,
+                0x25, 0x03, 0x27, 0x2a, 0x3f, 0x9e, 0xc5, 0x72, 0x0d, 0xd3, 0xe5, 0xb1, 0xda, 0x59,
+                0x51, 0x4d, 0x4c, 0xb5, 0x0b, 0x1a, 0x44, 0x5a, 0x9d, 0x66,
+            ],
+            ock: [
+                0xab, 0xd0, 0xc2, 0x46, 0x97, 0xe4, 0x5b, 0x8b, 0xc4, 0x83, 0x0f, 0xb1, 0x46, 0x53,
+                0x2e, 0xa0, 0xac, 0x84, 0x55, 0x81, 0xca, 0x35, 0x39, 0xd3, 0x41, 0x24, 0x73, 0x54,
+                0x09, 0xd0, 0x15, 0xac,
+            ],
+            op: [
+                0xb4, 0xca, 0xc5, 0x6f, 0x06, 0x2b, 0xfb, 0x2e, 0x27, 0x15, 0xea, 0xf9, 0xc8, 0xfc,
+                0xdb, 0xc2, 0x0c, 0x86, 0x79, 0x3f, 0x23, 0x57, 0xdd, 0xd0, 0x4a, 0xad, 0x39, 0xf9,
+                0x4a, 0xd7, 0xc7, 0x84, 0x10, 0x87, 0x4a, 0x74, 0x22, 0x7a, 0xc7, 0x99, 0x5e, 0xdd,
+                0xdd, 0x73, 0x4d, 0x0e, 0x00, 0xdc, 0xc9, 0xf4, 0x8a, 0x01, 0xdd, 0x5c, 0x4c, 0xb1,
+                0x22, 0xc0, 0x61, 0xe0, 0xbd, 0xc9, 0xce, 0x14,
+            ],
+            c_out: [
+                0xea, 0xdf, 0x7e, 0xeb, 0x10, 0x2d, 0xb1, 0x88, 0x58, 0x54, 0xc2, 0x9e, 0xb7, 0xb0,
+                0x5c, 0x7c, 0x96, 0xbb, 0xb8, 0x90, 0x00, 0x2c, 0x4e, 0xd1, 0x14, 0xed, 0x62, 0xf5,
+                0xf9, 0xcc, 0xb4, 0x41, 0x6b, 0x5e, 0xdd, 0xd9, 0xad, 0xb5, 0x5c, 0xe9, 0xc7, 0xa0,
+                0xd8, 0x44, 0x2b, 0xbc, 0x8a, 0xfa, 0x5c, 0x77, 0xb9, 0x90, 0xad, 0x6d, 0x46, 0x12,
+                0x4d, 0xde, 0x70, 0x49, 0x48, 0x72, 0xb2, 0x20, 0x8a, 0x7c, 0x58, 0x02, 0xdf, 0xe9,
+                0xbd, 0x1c, 0xa1, 0x9b, 0xef, 0x4b, 0x37, 0xc6, 0x13, 0xb2,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x91, 0xee, 0x20, 0x54, 0x48, 0xc9, 0x8b, 0x69, 0xa3, 0x3e, 0xbf, 0x29, 0x35, 0x09,
+                0x5d, 0x79, 0xc2, 0x53, 0x02, 0x9e, 0x5e, 0x5d, 0xc0, 0x2d, 0xf5, 0x8a, 0x10, 0x03,
+                0xd1, 0xd8, 0x5c, 0x27, 0xf2, 0xde, 0xf5, 0xb1, 0x10, 0xfd, 0x43, 0xd7, 0x15, 0xe8,
+                0xd5, 0x9e, 0xc4, 0xad, 0x0f, 0x41, 0x02, 0x0e, 0xc6, 0x60, 0xcd, 0x97, 0x33, 0xe7,
+                0x79, 0xb5, 0x1a, 0x7a, 0xc2, 0xd5, 0xa6, 0x31,
+            ],
+            ovk: [
+                0x18, 0x2f, 0x20, 0x7b, 0x31, 0x75, 0x96, 0x1f, 0x64, 0x11, 0xa4, 0x93, 0xbf, 0xfd,
+                0x04, 0x8e, 0x7d, 0x0d, 0x87, 0xd8, 0x2f, 0xe6, 0xf9, 0x90, 0xa2, 0xb0, 0xa2, 0x5f,
+                0x5a, 0xa0, 0x11, 0x1a,
+            ],
+            default_d: [
+                0x08, 0xab, 0x2e, 0xe9, 0x9d, 0x4d, 0x9b, 0x98, 0x3d, 0xdd, 0x22,
+            ],
+            default_pk_d: [
+                0x82, 0xfe, 0xf6, 0x43, 0xdb, 0xf4, 0x2d, 0xca, 0x51, 0x56, 0xfb, 0x51, 0xd4, 0xc4,
+                0xee, 0x00, 0x8a, 0x72, 0xf0, 0xdb, 0xc3, 0xf3, 0x1e, 0xfa, 0xb0, 0x75, 0xf2, 0x75,
+                0x15, 0x37, 0x14, 0x0d,
+            ],
+            v: 14400879385556610631,
+            rseed: [
+                0xd5, 0x07, 0xcd, 0xfe, 0x6f, 0xbd, 0xaa, 0x86, 0x16, 0x3e, 0x9c, 0xf5, 0xde, 0x31,
+                0x00, 0xfb, 0xca, 0x7e, 0x8d, 0xa0, 0x47, 0xb0, 0x90, 0xdb, 0x9f, 0x37, 0x95, 0x2f,
+                0xbf, 0xee, 0x76, 0xaf,
+            ],
+            asset: [
+                0x67, 0x43, 0xf9, 0x3a, 0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3,
+                0x04, 0xfe, 0x32, 0xb2, 0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e,
+                0x7a, 0x59, 0x70, 0x2f,
+            ],
+            memo: [
+                0xff, 0x61, 0x66, 0x81, 0x90, 0xbd, 0x52, 0xed, 0x49, 0x0e, 0x67, 0x7b, 0x51, 0x5d,
+                0x01, 0x43, 0x84, 0xaf, 0x07, 0x21, 0x9c, 0x7c, 0x0e, 0xe7, 0xfc, 0x7b, 0xfc, 0x79,
+                0xf3, 0x25, 0x64, 0x4e, 0x4d, 0xf4, 0xc0, 0xd7, 0xdb, 0x08, 0xe9, 0xf0, 0xbd, 0x02,
+                0x49, 0x43, 0xc7, 0x05, 0xab, 0xff, 0x89, 0x94, 0xbf, 0xa6, 0x05, 0xcf, 0xbc, 0x7e,
+                0xd7, 0x46, 0xa7, 0xd3, 0xf7, 0xc3, 0x7d, 0x9e, 0x8b, 0xdc, 0x43, 0x3b, 0x7d, 0x79,
+                0xe0, 0x8a, 0x12, 0xf7, 0x38, 0xa8, 0xf0, 0xdb, 0xdd, 0xfe, 0xf2, 0xf2, 0x65, 0x7e,
+                0xf3, 0xe4, 0x7d, 0x1b, 0x0f, 0xd1, 0x1e, 0x6a, 0x13, 0x31, 0x1f, 0xb7, 0x99, 0xc7,
+                0x9c, 0x64, 0x1d, 0x9d, 0xa4, 0x3b, 0x33, 0xe7, 0xad, 0x01, 0x2e, 0x28, 0x25, 0x53,
+                0x98, 0x78, 0x92, 0x62, 0x27, 0x5f, 0x11, 0x75, 0xbe, 0x84, 0x62, 0xc0, 0x14, 0x91,
+                0xc4, 0xd8, 0x42, 0x40, 0x6d, 0x0e, 0xc4, 0x28, 0x2c, 0x95, 0x26, 0x17, 0x4a, 0x09,
+                0x87, 0x8f, 0xe8, 0xfd, 0xde, 0x33, 0xa2, 0x96, 0x04, 0xe5, 0xe5, 0xe7, 0xb2, 0xa0,
+                0x25, 0xd6, 0x65, 0x0b, 0x97, 0xdb, 0xb5, 0x2b, 0xef, 0xb5, 0x9b, 0x1d, 0x30, 0xa5,
+                0x74, 0x33, 0xb0, 0xa3, 0x51, 0x47, 0x44, 0x44, 0x09, 0x9d, 0xaa, 0x37, 0x10, 0x46,
+                0x61, 0x32, 0x60, 0xcf, 0x33, 0x54, 0xcf, 0xcd, 0xad, 0xa6, 0x63, 0xec, 0xe8, 0x24,
+                0xff, 0xd7, 0xe4, 0x43, 0x93, 0x88, 0x6a, 0x86, 0x16, 0x5d, 0xdd, 0xdf, 0x2b, 0x4c,
+                0x41, 0x77, 0x35, 0x54, 0xc8, 0x69, 0x95, 0x26, 0x94, 0x08, 0xb1, 0x1e, 0x67, 0x37,
+                0xa4, 0xc4, 0x47, 0x58, 0x6f, 0x69, 0x17, 0x34, 0x46, 0xd8, 0xe4, 0x8b, 0xf8, 0x4c,
+                0xbc, 0x00, 0x0a, 0x80, 0x78, 0x99, 0x97, 0x3e, 0xb9, 0x3c, 0x5e, 0x81, 0x9a, 0xad,
+                0x66, 0x94, 0x13, 0xf8, 0x38, 0x79, 0x33, 0xad, 0x15, 0x84, 0xaa, 0x35, 0xe4, 0x3f,
+                0x4e, 0xcd, 0x1e, 0x2d, 0x04, 0x07, 0xc0, 0xb1, 0xb8, 0x99, 0x20, 0xff, 0xdf, 0xdb,
+                0x9b, 0xea, 0x51, 0xac, 0x95, 0xb5, 0x57, 0xaf, 0x71, 0xb8, 0x9f, 0x90, 0x3f, 0x5d,
+                0x98, 0x48, 0xf1, 0x4f, 0xcb, 0xeb, 0x18, 0x37, 0x57, 0x0f, 0x54, 0x4d, 0x63, 0x59,
+                0xeb, 0x23, 0xfa, 0xf3, 0x8a, 0x08, 0x22, 0xda, 0x36, 0xce, 0x42, 0x6c, 0x4a, 0x2f,
+                0xbe, 0xff, 0xeb, 0x0a, 0x8a, 0x2e, 0x29, 0x7a, 0x9d, 0x19, 0xba, 0x15, 0x02, 0x45,
+                0x90, 0xe3, 0x32, 0x9d, 0x9f, 0xa9, 0x26, 0x1f, 0x99, 0x38, 0xa4, 0x03, 0x2d, 0xd3,
+                0x46, 0x06, 0xc9, 0xcf, 0x9f, 0x3d, 0xd3, 0x3e, 0x57, 0x6f, 0x05, 0xcd, 0x1d, 0xd6,
+                0x81, 0x1c, 0x62, 0x98, 0x75, 0x7d, 0x77, 0xd9, 0xe8, 0x10, 0xab, 0xdb, 0x22, 0x6a,
+                0xfc, 0xaa, 0x43, 0x46, 0xa6, 0x56, 0x0f, 0x89, 0x32, 0xb3, 0x18, 0x1f, 0xd3, 0x55,
+                0xd5, 0xd3, 0x91, 0x97, 0x61, 0x83, 0xf8, 0xd9, 0x93, 0x88, 0x83, 0x96, 0x32, 0xd6,
+                0x35, 0x4f, 0x66, 0x6d, 0x09, 0xd3, 0xe5, 0x62, 0x9e, 0xa1, 0x97, 0x37, 0x38, 0x86,
+                0x13, 0xd3, 0x8a, 0x34, 0xfd, 0x0f, 0x6e, 0x50, 0xee, 0x5a, 0x0c, 0xc9, 0x67, 0x71,
+                0x77, 0xf5, 0x00, 0x28, 0xc1, 0x41, 0x37, 0x81, 0x87, 0xbd, 0x28, 0x19, 0x40, 0x3f,
+                0xc5, 0x34, 0xf8, 0x00, 0x76, 0xe9, 0x38, 0x0c, 0xb4, 0x96, 0x4d, 0x3b, 0x6b, 0x45,
+                0x81, 0x9d, 0x3b, 0x8e, 0x9c, 0xaf, 0x54, 0xf0, 0x51, 0x85, 0x2d, 0x67, 0x1b, 0xf8,
+                0xc1, 0xff, 0xde, 0x2d, 0x15, 0x10, 0x75, 0x64, 0x18, 0xcb, 0x48, 0x10, 0x93, 0x6a,
+                0xa5, 0x7e, 0x69, 0x65, 0xd6, 0xfb, 0x65, 0x6a, 0x76, 0x0b, 0x7f, 0x19, 0xad, 0xf9,
+                0x6c, 0x17, 0x34, 0x88, 0x55, 0x21, 0x93, 0xb1,
+            ],
+            cv_net: [
+                0xc3, 0x94, 0x68, 0x5d, 0x92, 0x95, 0x59, 0x7e, 0x21, 0x55, 0x7f, 0x21, 0x9f, 0x3c,
+                0x9d, 0x5e, 0x64, 0x07, 0x19, 0xbc, 0xa5, 0xc8, 0xed, 0x49, 0x99, 0x97, 0x34, 0xe6,
+                0xc5, 0xb3, 0x73, 0x3e,
+            ],
+            rho: [
+                0xc8, 0x8d, 0x00, 0x84, 0x84, 0xc5, 0xd7, 0x98, 0x20, 0xab, 0x68, 0xc6, 0x7d, 0x08,
+                0x36, 0x72, 0xb0, 0x7f, 0x72, 0x7d, 0x44, 0xd0, 0xcd, 0x14, 0x73, 0x88, 0x00, 0xf8,
+                0x25, 0xb9, 0xff, 0x16,
+            ],
+            cmx: [
+                0x0b, 0x74, 0x59, 0x61, 0x6f, 0xc6, 0x93, 0x95, 0xe6, 0x44, 0x36, 0xcf, 0x4a, 0xe9,
+                0x44, 0x1d, 0x37, 0x4b, 0x29, 0x04, 0x9e, 0x4c, 0x86, 0x22, 0x3a, 0x03, 0x83, 0xf4,
+                0xe0, 0x24, 0x69, 0x05,
+            ],
+            esk: [
+                0xc4, 0x92, 0x42, 0xce, 0xe7, 0xe0, 0x86, 0x8f, 0x2a, 0x75, 0xa1, 0xc4, 0x12, 0xbc,
+                0x44, 0xd5, 0x4c, 0x97, 0x09, 0xf6, 0x59, 0xde, 0xd3, 0x26, 0x95, 0x72, 0x92, 0x93,
+                0x59, 0xe0, 0x4c, 0x3a,
+            ],
+            ephemeral_key: [
+                0x0e, 0x04, 0xd8, 0x52, 0x5d, 0xd6, 0x8f, 0x7a, 0xe8, 0x68, 0xca, 0x81, 0x1e, 0x88,
+                0x33, 0xa7, 0xf4, 0x7d, 0x7a, 0xad, 0xd3, 0x76, 0x03, 0xac, 0xe6, 0x07, 0xee, 0x6c,
+                0x86, 0x6b, 0xce, 0x23,
+            ],
+            shared_secret: [
+                0x4a, 0x7a, 0x54, 0xac, 0x00, 0x41, 0x95, 0x98, 0xb0, 0x76, 0x01, 0x53, 0xe2, 0x6a,
+                0xcc, 0xd2, 0x15, 0x05, 0x24, 0x16, 0x65, 0x17, 0x13, 0xee, 0xa1, 0x89, 0x19, 0xf3,
+                0xe2, 0x62, 0xd3, 0xb6,
+            ],
+            k_enc: [
+                0x30, 0x62, 0x6d, 0x92, 0xeb, 0x62, 0x0f, 0xd4, 0xa9, 0x28, 0xb4, 0x3f, 0xd5, 0x50,
+                0x69, 0x74, 0x71, 0x76, 0x7d, 0xe4, 0x49, 0x6c, 0xfd, 0xad, 0xb1, 0xda, 0x18, 0xfc,
+                0x0c, 0xdd, 0x5a, 0xa6,
+            ],
+            p_enc: [
+                0x03, 0x08, 0xab, 0x2e, 0xe9, 0x9d, 0x4d, 0x9b, 0x98, 0x3d, 0xdd, 0x22, 0x47, 0xee,
+                0x58, 0x85, 0x80, 0x33, 0xda, 0xc7, 0xd5, 0x07, 0xcd, 0xfe, 0x6f, 0xbd, 0xaa, 0x86,
+                0x16, 0x3e, 0x9c, 0xf5, 0xde, 0x31, 0x00, 0xfb, 0xca, 0x7e, 0x8d, 0xa0, 0x47, 0xb0,
+                0x90, 0xdb, 0x9f, 0x37, 0x95, 0x2f, 0xbf, 0xee, 0x76, 0xaf, 0x67, 0x43, 0xf9, 0x3a,
+                0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3, 0x04, 0xfe, 0x32, 0xb2,
+                0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e, 0x7a, 0x59, 0x70, 0x2f,
+                0xff, 0x61, 0x66, 0x81, 0x90, 0xbd, 0x52, 0xed, 0x49, 0x0e, 0x67, 0x7b, 0x51, 0x5d,
+                0x01, 0x43, 0x84, 0xaf, 0x07, 0x21, 0x9c, 0x7c, 0x0e, 0xe7, 0xfc, 0x7b, 0xfc, 0x79,
+                0xf3, 0x25, 0x64, 0x4e, 0x4d, 0xf4, 0xc0, 0xd7, 0xdb, 0x08, 0xe9, 0xf0, 0xbd, 0x02,
+                0x49, 0x43, 0xc7, 0x05, 0xab, 0xff, 0x89, 0x94, 0xbf, 0xa6, 0x05, 0xcf, 0xbc, 0x7e,
+                0xd7, 0x46, 0xa7, 0xd3, 0xf7, 0xc3, 0x7d, 0x9e, 0x8b, 0xdc, 0x43, 0x3b, 0x7d, 0x79,
+                0xe0, 0x8a, 0x12, 0xf7, 0x38, 0xa8, 0xf0, 0xdb, 0xdd, 0xfe, 0xf2, 0xf2, 0x65, 0x7e,
+                0xf3, 0xe4, 0x7d, 0x1b, 0x0f, 0xd1, 0x1e, 0x6a, 0x13, 0x31, 0x1f, 0xb7, 0x99, 0xc7,
+                0x9c, 0x64, 0x1d, 0x9d, 0xa4, 0x3b, 0x33, 0xe7, 0xad, 0x01, 0x2e, 0x28, 0x25, 0x53,
+                0x98, 0x78, 0x92, 0x62, 0x27, 0x5f, 0x11, 0x75, 0xbe, 0x84, 0x62, 0xc0, 0x14, 0x91,
+                0xc4, 0xd8, 0x42, 0x40, 0x6d, 0x0e, 0xc4, 0x28, 0x2c, 0x95, 0x26, 0x17, 0x4a, 0x09,
+                0x87, 0x8f, 0xe8, 0xfd, 0xde, 0x33, 0xa2, 0x96, 0x04, 0xe5, 0xe5, 0xe7, 0xb2, 0xa0,
+                0x25, 0xd6, 0x65, 0x0b, 0x97, 0xdb, 0xb5, 0x2b, 0xef, 0xb5, 0x9b, 0x1d, 0x30, 0xa5,
+                0x74, 0x33, 0xb0, 0xa3, 0x51, 0x47, 0x44, 0x44, 0x09, 0x9d, 0xaa, 0x37, 0x10, 0x46,
+                0x61, 0x32, 0x60, 0xcf, 0x33, 0x54, 0xcf, 0xcd, 0xad, 0xa6, 0x63, 0xec, 0xe8, 0x24,
+                0xff, 0xd7, 0xe4, 0x43, 0x93, 0x88, 0x6a, 0x86, 0x16, 0x5d, 0xdd, 0xdf, 0x2b, 0x4c,
+                0x41, 0x77, 0x35, 0x54, 0xc8, 0x69, 0x95, 0x26, 0x94, 0x08, 0xb1, 0x1e, 0x67, 0x37,
+                0xa4, 0xc4, 0x47, 0x58, 0x6f, 0x69, 0x17, 0x34, 0x46, 0xd8, 0xe4, 0x8b, 0xf8, 0x4c,
+                0xbc, 0x00, 0x0a, 0x80, 0x78, 0x99, 0x97, 0x3e, 0xb9, 0x3c, 0x5e, 0x81, 0x9a, 0xad,
+                0x66, 0x94, 0x13, 0xf8, 0x38, 0x79, 0x33, 0xad, 0x15, 0x84, 0xaa, 0x35, 0xe4, 0x3f,
+                0x4e, 0xcd, 0x1e, 0x2d, 0x04, 0x07, 0xc0, 0xb1, 0xb8, 0x99, 0x20, 0xff, 0xdf, 0xdb,
+                0x9b, 0xea, 0x51, 0xac, 0x95, 0xb5, 0x57, 0xaf, 0x71, 0xb8, 0x9f, 0x90, 0x3f, 0x5d,
+                0x98, 0x48, 0xf1, 0x4f, 0xcb, 0xeb, 0x18, 0x37, 0x57, 0x0f, 0x54, 0x4d, 0x63, 0x59,
+                0xeb, 0x23, 0xfa, 0xf3, 0x8a, 0x08, 0x22, 0xda, 0x36, 0xce, 0x42, 0x6c, 0x4a, 0x2f,
+                0xbe, 0xff, 0xeb, 0x0a, 0x8a, 0x2e, 0x29, 0x7a, 0x9d, 0x19, 0xba, 0x15, 0x02, 0x45,
+                0x90, 0xe3, 0x32, 0x9d, 0x9f, 0xa9, 0x26, 0x1f, 0x99, 0x38, 0xa4, 0x03, 0x2d, 0xd3,
+                0x46, 0x06, 0xc9, 0xcf, 0x9f, 0x3d, 0xd3, 0x3e, 0x57, 0x6f, 0x05, 0xcd, 0x1d, 0xd6,
+                0x81, 0x1c, 0x62, 0x98, 0x75, 0x7d, 0x77, 0xd9, 0xe8, 0x10, 0xab, 0xdb, 0x22, 0x6a,
+                0xfc, 0xaa, 0x43, 0x46, 0xa6, 0x56, 0x0f, 0x89, 0x32, 0xb3, 0x18, 0x1f, 0xd3, 0x55,
+                0xd5, 0xd3, 0x91, 0x97, 0x61, 0x83, 0xf8, 0xd9, 0x93, 0x88, 0x83, 0x96, 0x32, 0xd6,
+                0x35, 0x4f, 0x66, 0x6d, 0x09, 0xd3, 0xe5, 0x62, 0x9e, 0xa1, 0x97, 0x37, 0x38, 0x86,
+                0x13, 0xd3, 0x8a, 0x34, 0xfd, 0x0f, 0x6e, 0x50, 0xee, 0x5a, 0x0c, 0xc9, 0x67, 0x71,
+                0x77, 0xf5, 0x00, 0x28, 0xc1, 0x41, 0x37, 0x81, 0x87, 0xbd, 0x28, 0x19, 0x40, 0x3f,
+                0xc5, 0x34, 0xf8, 0x00, 0x76, 0xe9, 0x38, 0x0c, 0xb4, 0x96, 0x4d, 0x3b, 0x6b, 0x45,
+                0x81, 0x9d, 0x3b, 0x8e, 0x9c, 0xaf, 0x54, 0xf0, 0x51, 0x85, 0x2d, 0x67, 0x1b, 0xf8,
+                0xc1, 0xff, 0xde, 0x2d, 0x15, 0x10, 0x75, 0x64, 0x18, 0xcb, 0x48, 0x10, 0x93, 0x6a,
+                0xa5, 0x7e, 0x69, 0x65, 0xd6, 0xfb, 0x65, 0x6a, 0x76, 0x0b, 0x7f, 0x19, 0xad, 0xf9,
+                0x6c, 0x17, 0x34, 0x88, 0x55, 0x21, 0x93, 0xb1,
+            ],
+            c_enc: [
+                0x80, 0x56, 0x2d, 0xbe, 0xf7, 0xbb, 0x35, 0x3a, 0x62, 0xe7, 0xc8, 0x1e, 0xbe, 0x68,
+                0x15, 0x6c, 0xb7, 0x5c, 0x5c, 0x7e, 0x3d, 0x96, 0xbb, 0xcd, 0x7d, 0xaf, 0xf5, 0x0c,
+                0xb0, 0x95, 0x7d, 0x33, 0xdd, 0x99, 0x77, 0x9f, 0x7d, 0x3d, 0x72, 0xb1, 0x8d, 0xeb,
+                0x7a, 0x69, 0x75, 0x10, 0xe0, 0x13, 0x5b, 0x8d, 0xf4, 0x83, 0x3c, 0xf5, 0x82, 0xa1,
+                0x4f, 0x08, 0xfc, 0xa9, 0xb3, 0x7a, 0xac, 0x85, 0x1f, 0xf9, 0xf5, 0x80, 0x5c, 0x57,
+                0x74, 0x8a, 0x3f, 0xe8, 0x1b, 0x88, 0xc9, 0x8c, 0x96, 0xfd, 0x2a, 0x75, 0xc4, 0xf6,
+                0x66, 0xb6, 0x1d, 0x20, 0x74, 0x06, 0x5c, 0xf4, 0x4a, 0x30, 0xa1, 0x98, 0xa2, 0x98,
+                0xb7, 0xda, 0x42, 0x7c, 0x18, 0x60, 0x8a, 0x8f, 0x13, 0x83, 0x63, 0xf0, 0x55, 0x40,
+                0x42, 0xd3, 0xe3, 0xa7, 0xe3, 0x22, 0x94, 0x51, 0x51, 0xc6, 0x3b, 0xb2, 0x37, 0xb3,
+                0x20, 0xbc, 0x78, 0x0a, 0x8f, 0x9e, 0x01, 0xc6, 0x01, 0xf0, 0x34, 0xbc, 0xf0, 0x37,
+                0x67, 0xd5, 0xd7, 0x50, 0x40, 0x2a, 0x23, 0x80, 0x0f, 0x46, 0xec, 0x08, 0x78, 0x0a,
+                0x8f, 0x78, 0xe9, 0xa2, 0x37, 0xa9, 0xcb, 0x83, 0x06, 0x26, 0x1d, 0x1b, 0xb4, 0xc3,
+                0xf6, 0x2e, 0xf4, 0xcb, 0x0f, 0x70, 0x34, 0x65, 0x32, 0x24, 0xfe, 0x77, 0x17, 0x9a,
+                0x4d, 0x12, 0x15, 0x9a, 0x87, 0x66, 0xff, 0xc5, 0x9b, 0xee, 0x68, 0xd9, 0x74, 0xd2,
+                0x27, 0x73, 0xe5, 0xca, 0x4f, 0x34, 0xf4, 0x62, 0x73, 0xa4, 0x46, 0x33, 0x69, 0xb1,
+                0x76, 0xa6, 0x1f, 0x1e, 0x47, 0x8c, 0x2d, 0x3c, 0x4e, 0x42, 0x70, 0x13, 0xe5, 0xd8,
+                0x69, 0x75, 0xea, 0x91, 0x93, 0x05, 0x0e, 0x52, 0xa7, 0x02, 0x6f, 0x76, 0x96, 0x4c,
+                0xa0, 0x18, 0x15, 0x9b, 0xdc, 0x19, 0x6c, 0x44, 0xca, 0xd2, 0xd2, 0x62, 0x3d, 0x33,
+                0x50, 0x7e, 0xf0, 0xfe, 0xc1, 0x0f, 0x9d, 0x80, 0xb2, 0x08, 0xe3, 0xc3, 0x3f, 0x7d,
+                0x50, 0x76, 0x41, 0x63, 0xb3, 0xf0, 0x33, 0x29, 0xad, 0x41, 0xeb, 0x5a, 0x4f, 0xb4,
+                0xf3, 0xab, 0x8e, 0xef, 0x2d, 0xa5, 0xcb, 0x3a, 0x7c, 0x86, 0x22, 0x16, 0x48, 0x70,
+                0xa8, 0x2c, 0x63, 0x5d, 0x23, 0x51, 0x53, 0x9b, 0x97, 0x3c, 0x40, 0xd5, 0x8e, 0x91,
+                0x79, 0x43, 0x6b, 0x9c, 0x0b, 0x74, 0xfd, 0x5e, 0xab, 0x81, 0x49, 0x59, 0xd2, 0x80,
+                0xea, 0x3f, 0x8e, 0x09, 0xd8, 0x44, 0x2f, 0xea, 0x4a, 0xdc, 0x8c, 0xc9, 0xc2, 0xfe,
+                0x50, 0xef, 0xad, 0x2e, 0xe1, 0x9a, 0xb5, 0x85, 0x7a, 0x2d, 0x2f, 0xb1, 0xd1, 0x13,
+                0x67, 0x08, 0x22, 0xb9, 0x57, 0x95, 0xa3, 0x4d, 0x20, 0xf7, 0xc6, 0x37, 0xf8, 0xdc,
+                0xcf, 0xe7, 0x35, 0x52, 0xfd, 0x34, 0x17, 0x6a, 0xbf, 0x0f, 0x8e, 0x3c, 0xfa, 0x70,
+                0xbe, 0xc8, 0x84, 0x4b, 0x87, 0xb1, 0x44, 0xcb, 0x99, 0xb0, 0xb0, 0x9b, 0x47, 0xc6,
+                0x62, 0xdd, 0x70, 0x5e, 0x4d, 0x74, 0xc1, 0x5d, 0x47, 0x42, 0x98, 0x33, 0xe7, 0x80,
+                0x5d, 0x88, 0x40, 0x46, 0xc0, 0xd9, 0x36, 0xc8, 0x72, 0x32, 0xcd, 0xc9, 0x53, 0xbf,
+                0x6e, 0x61, 0x93, 0xb4, 0xcf, 0x67, 0x81, 0x12, 0x8e, 0xbe, 0x7a, 0x51, 0xdb, 0x9b,
+                0x36, 0x67, 0x38, 0x08, 0xad, 0x77, 0x18, 0xe2, 0x50, 0xcb, 0x51, 0x15, 0x85, 0xf6,
+                0xbc, 0x09, 0x78, 0xbd, 0x17, 0xe4, 0x71, 0x7e, 0xa4, 0x19, 0x3d, 0x09, 0x5d, 0x22,
+                0x2b, 0xa1, 0xb2, 0xf9, 0xd8, 0x18, 0x98, 0x1d, 0xf1, 0x72, 0xa4, 0x91, 0xd8, 0x41,
+                0xbc, 0x73, 0xec, 0x17, 0x93, 0x41, 0xa2, 0x8f, 0x03, 0x8a, 0xa3, 0xe4, 0xc8, 0x65,
+                0x24, 0x11, 0xf1, 0x85, 0xa6, 0x49, 0x92, 0xa6, 0xce, 0xa6, 0xc4, 0x5c, 0x70, 0xe9,
+                0xd6, 0x64, 0x69, 0x4b, 0xc9, 0x44, 0x1f, 0x29, 0xc4, 0x81, 0x81, 0x5a, 0x82, 0xb3,
+                0xa3, 0x30, 0xc9, 0x6c, 0x05, 0xfc, 0x9c, 0x48, 0x5a, 0xe8, 0xd9, 0x96, 0xb6, 0xf9,
+                0xf6, 0x87, 0xf3, 0x90, 0x1f, 0x74, 0x0a, 0xc8, 0x9a, 0xb2, 0x42, 0xf2, 0xaa, 0x0c,
+                0xe7, 0xb0, 0xeb, 0x14, 0xb4, 0x2d, 0x65, 0xba, 0xd9, 0xfe, 0x5c, 0xe2, 0x91, 0xa2,
+                0x2c, 0xb1, 0xff, 0xdf, 0xdf, 0x27, 0x30, 0xd6, 0x8f, 0x68, 0x2d, 0xe0, 0xf9, 0xf3,
+                0xa3, 0x04, 0xf5, 0x0c, 0x4f, 0xfd, 0xf9, 0x58, 0x30, 0x6c, 0x11, 0xa2, 0x91, 0x70,
+                0xdd, 0xae, 0x90, 0x65, 0xcc, 0xc9, 0xd4, 0xd2, 0x77, 0x62, 0x6e, 0x78, 0x81, 0x72,
+                0x3a, 0xe1, 0x72, 0xff, 0x09, 0xdb, 0x09, 0x38, 0x6f, 0x9e,
+            ],
+            ock: [
+                0xb6, 0x36, 0xc3, 0x9a, 0x6b, 0xad, 0x22, 0x63, 0xb2, 0x44, 0x1e, 0xd5, 0xbb, 0xdb,
+                0x01, 0x35, 0x88, 0xfb, 0x46, 0x27, 0x01, 0xe6, 0xf8, 0x76, 0x64, 0x6c, 0x8c, 0x17,
+                0xfa, 0x2e, 0xfd, 0xe8,
+            ],
+            op: [
+                0x82, 0xfe, 0xf6, 0x43, 0xdb, 0xf4, 0x2d, 0xca, 0x51, 0x56, 0xfb, 0x51, 0xd4, 0xc4,
+                0xee, 0x00, 0x8a, 0x72, 0xf0, 0xdb, 0xc3, 0xf3, 0x1e, 0xfa, 0xb0, 0x75, 0xf2, 0x75,
+                0x15, 0x37, 0x14, 0x0d, 0xc4, 0x92, 0x42, 0xce, 0xe7, 0xe0, 0x86, 0x8f, 0x2a, 0x75,
+                0xa1, 0xc4, 0x12, 0xbc, 0x44, 0xd5, 0x4c, 0x97, 0x09, 0xf6, 0x59, 0xde, 0xd3, 0x26,
+                0x95, 0x72, 0x92, 0x93, 0x59, 0xe0, 0x4c, 0x3a,
+            ],
+            c_out: [
+                0x46, 0xba, 0x14, 0xf8, 0x3f, 0xf5, 0xab, 0x76, 0x0f, 0x14, 0x20, 0xeb, 0xde, 0xd9,
+                0x86, 0xfd, 0x93, 0x78, 0x27, 0xbc, 0x05, 0x69, 0x2e, 0xca, 0xdb, 0x65, 0x2e, 0xbb,
+                0xc8, 0xf6, 0xd9, 0xb5, 0x2e, 0xc3, 0x97, 0x87, 0xd8, 0xeb, 0xdd, 0x50, 0x6c, 0xa1,
+                0xa8, 0x5d, 0xc3, 0xd5, 0xba, 0x4c, 0x5b, 0x41, 0x52, 0x61, 0xb0, 0x75, 0x3a, 0xc1,
+                0x0e, 0x01, 0x86, 0x45, 0x32, 0xa3, 0x57, 0x2c, 0x68, 0xaf, 0xe4, 0x0a, 0xc3, 0xc0,
+                0x95, 0x7b, 0x7a, 0xfc, 0x23, 0xfd, 0x5e, 0x05, 0x17, 0xaa,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xf1, 0x90, 0x42, 0xb9, 0xd1, 0x0c, 0xc4, 0x80, 0xa0, 0x8c, 0x04, 0x32, 0x2d, 0xb6,
+                0xec, 0x4e, 0x41, 0x2e, 0xaa, 0x84, 0xc9, 0x71, 0x82, 0x8c, 0xcc, 0xd7, 0x33, 0xa1,
+                0x1f, 0x25, 0x3e, 0xda, 0x8a, 0xc3, 0x0b, 0xa3, 0x1f, 0xbc, 0x89, 0x5d, 0x60, 0xb9,
+                0x83, 0x06, 0x2a, 0x5f, 0x45, 0x33, 0x90, 0x79, 0x32, 0x26, 0xff, 0xd9, 0x21, 0xbd,
+                0x64, 0xac, 0x39, 0x07, 0x03, 0x85, 0x6a, 0x0b,
+            ],
+            ovk: [
+                0xda, 0xdc, 0x96, 0x6c, 0x8a, 0x54, 0x66, 0xb6, 0x1f, 0xc9, 0x98, 0xc3, 0x1f, 0x10,
+                0x70, 0xd9, 0xa5, 0xc9, 0xa6, 0xd2, 0x68, 0xd3, 0x04, 0xfe, 0x6b, 0x8f, 0xd3, 0xb4,
+                0x01, 0x03, 0x48, 0x61,
+            ],
+            default_d: [
+                0xaa, 0x14, 0x92, 0x9c, 0x57, 0x89, 0x85, 0x85, 0xce, 0x66, 0x5a,
+            ],
+            default_pk_d: [
+                0x78, 0xa4, 0xe3, 0x39, 0x88, 0xd7, 0x1d, 0x71, 0x8e, 0x59, 0x55, 0x55, 0x28, 0x4c,
+                0x24, 0x9a, 0x62, 0xb7, 0x12, 0x88, 0x06, 0xa5, 0x4c, 0x3b, 0x36, 0xa3, 0xaa, 0x57,
+                0x14, 0x93, 0x16, 0x36,
+            ],
+            v: 17936016275122962426,
+            rseed: [
+                0x49, 0x95, 0x0a, 0xfc, 0xb0, 0xef, 0x46, 0x2a, 0x2a, 0xe0, 0x24, 0xb0, 0xf0, 0x22,
+                0x4d, 0xfd, 0x73, 0x68, 0x4b, 0x88, 0xc7, 0xfb, 0xe9, 0x2d, 0x02, 0xb6, 0x8f, 0x75,
+                0x9c, 0x47, 0x52, 0x66,
+            ],
+            asset: [
+                0x67, 0x43, 0xf9, 0x3a, 0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3,
+                0x04, 0xfe, 0x32, 0xb2, 0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e,
+                0x7a, 0x59, 0x70, 0x2f,
+            ],
+            memo: [
+                0xff, 0x3c, 0xd7, 0xb9, 0x7a, 0x14, 0x94, 0x36, 0x49, 0x30, 0x55, 0x21, 0x32, 0x6b,
+                0xde, 0x08, 0x56, 0x30, 0x86, 0x46, 0x29, 0x29, 0x1b, 0xae, 0x25, 0xff, 0x88, 0x22,
+                0xa1, 0x4c, 0x4b, 0x66, 0x6a, 0x92, 0x59, 0xad, 0x0d, 0xc4, 0x2a, 0x82, 0x90, 0xac,
+                0x7b, 0xc7, 0xf5, 0x3a, 0x16, 0xf3, 0x79, 0xf7, 0x58, 0xe5, 0xde, 0x75, 0x0f, 0x04,
+                0xfd, 0x7c, 0xad, 0x47, 0x70, 0x1c, 0x85, 0x97, 0xf9, 0x78, 0x88, 0xbe, 0xa6, 0xfa,
+                0x0b, 0xf2, 0x99, 0x99, 0x56, 0xfb, 0xfd, 0x0e, 0xe6, 0x8e, 0xc3, 0x6e, 0x46, 0x88,
+                0x80, 0x9a, 0xe2, 0x31, 0xeb, 0x8b, 0xc4, 0x36, 0x9f, 0x5f, 0xe1, 0x57, 0x3f, 0x57,
+                0xe0, 0x99, 0xd9, 0xc0, 0x99, 0x01, 0xbf, 0x39, 0xca, 0xac, 0x48, 0xdc, 0x11, 0x95,
+                0x6a, 0x8a, 0xe9, 0x05, 0xea, 0xd8, 0x69, 0x54, 0x54, 0x7c, 0x44, 0x8a, 0xe4, 0x3d,
+                0x31, 0x5e, 0x66, 0x9c, 0x42, 0x42, 0xda, 0x56, 0x59, 0x38, 0xf4, 0x17, 0xbf, 0x43,
+                0xce, 0x7b, 0x2b, 0x30, 0xb1, 0xcd, 0x40, 0x18, 0x38, 0x8e, 0x1a, 0x91, 0x0f, 0x0f,
+                0xc4, 0x1f, 0xb0, 0x87, 0x7a, 0x59, 0x25, 0xe4, 0x66, 0x81, 0x9d, 0x37, 0x5b, 0x0a,
+                0x91, 0x2d, 0x4f, 0xe8, 0x43, 0xb7, 0x6e, 0xf6, 0xf2, 0x23, 0xf0, 0xf7, 0xc8, 0x94,
+                0xf3, 0x8f, 0x7a, 0xb7, 0x80, 0xdf, 0xd7, 0x5f, 0x66, 0x9c, 0x8c, 0x06, 0xcf, 0xfa,
+                0x43, 0xeb, 0x47, 0x56, 0x5a, 0x50, 0xe3, 0xb1, 0xfa, 0x45, 0xad, 0x61, 0xce, 0x9a,
+                0x1c, 0x47, 0x27, 0xb7, 0xaa, 0xa5, 0x35, 0x62, 0xf5, 0x23, 0xe7, 0x39, 0x52, 0xbb,
+                0xf3, 0x3d, 0x8a, 0x41, 0x04, 0x07, 0x8a, 0xde, 0x3e, 0xaa, 0xa4, 0x96, 0x99, 0xa6,
+                0x9f, 0xdf, 0x1c, 0x5a, 0xc7, 0x73, 0x21, 0x46, 0xee, 0x5e, 0x1d, 0x6b, 0x6c, 0xa9,
+                0xb9, 0x18, 0x0f, 0x96, 0x4c, 0xc9, 0xd0, 0x87, 0x8a, 0xe1, 0x37, 0x35, 0x24, 0xd7,
+                0xd5, 0x10, 0xe5, 0x82, 0x27, 0xdf, 0x6d, 0xe9, 0xd3, 0x0d, 0x27, 0x18, 0x67, 0x64,
+                0x01, 0x77, 0xb0, 0xf1, 0x85, 0x6e, 0x28, 0xd5, 0xc8, 0xaf, 0xb0, 0x95, 0xef, 0x61,
+                0x84, 0xfe, 0xd6, 0x51, 0x58, 0x90, 0x22, 0xee, 0xae, 0xa4, 0xc0, 0xce, 0x1f, 0xa6,
+                0xf0, 0x85, 0x09, 0x2b, 0x04, 0x97, 0x94, 0x89, 0x17, 0x2b, 0x3e, 0xf8, 0x19, 0x4a,
+                0x79, 0x8d, 0xf5, 0x72, 0x4d, 0x6b, 0x05, 0xf1, 0xae, 0x00, 0x00, 0x13, 0xa0, 0x8d,
+                0x61, 0x2b, 0xca, 0x8a, 0x8c, 0x31, 0x44, 0x3c, 0x10, 0x34, 0x6d, 0xbf, 0x61, 0xde,
+                0x84, 0x75, 0xc0, 0xbb, 0xec, 0x51, 0x04, 0xb4, 0x75, 0x56, 0xaf, 0x3d, 0x51, 0x44,
+                0x58, 0xe2, 0x32, 0x1d, 0x14, 0x60, 0x71, 0x78, 0x9d, 0x23, 0x35, 0x93, 0x4a, 0x68,
+                0x06, 0x14, 0xe8, 0x35, 0x62, 0xf8, 0x2d, 0xfd, 0x40, 0x5b, 0x54, 0xa4, 0x5e, 0xb3,
+                0x2c, 0x16, 0x54, 0x48, 0xd4, 0xd5, 0xd6, 0x1c, 0xa2, 0x85, 0x95, 0x85, 0x36, 0x9f,
+                0x53, 0xf1, 0xa1, 0x37, 0xe9, 0xe8, 0x2b, 0x67, 0xb8, 0xfd, 0xaf, 0x01, 0xbd, 0xa5,
+                0x4a, 0x31, 0x73, 0x11, 0x89, 0x6a, 0xe1, 0x02, 0x80, 0xa0, 0x32, 0x44, 0x0c, 0x42,
+                0x0a, 0x42, 0x1e, 0x94, 0x4d, 0x1e, 0x95, 0x2b, 0x70, 0xd5, 0x82, 0x6c, 0xd3, 0xb0,
+                0x8b, 0x7d, 0xb9, 0x63, 0x0f, 0xe4, 0xfd, 0x5f, 0x22, 0x12, 0x5d, 0xe8, 0x40, 0xfc,
+                0xc4, 0x0b, 0x98, 0x03, 0x8a, 0xf1, 0x1d, 0x55, 0xbe, 0x25, 0x43, 0x25, 0x97, 0xb4,
+                0xb6, 0x5b, 0x9e, 0xc1, 0xc7, 0xa8, 0xbb, 0xfd, 0x05, 0x2c, 0xbf, 0x7e, 0x1c, 0x17,
+                0x85, 0x31, 0x49, 0x34, 0xb2, 0x62, 0xd5, 0x85, 0x37, 0x54, 0xf1, 0xf1, 0x77, 0x71,
+                0xcf, 0xb7, 0x50, 0x30, 0x72, 0x65, 0x57, 0x53,
+            ],
+            cv_net: [
+                0xd4, 0x51, 0xb4, 0x62, 0x89, 0xba, 0x99, 0x8c, 0x0c, 0xce, 0xd1, 0xcc, 0x15, 0xb3,
+                0xfa, 0xde, 0x94, 0xfa, 0x0b, 0x46, 0xe3, 0xb1, 0xa5, 0x73, 0x34, 0x99, 0x34, 0xe2,
+                0x32, 0xb5, 0x0e, 0x96,
+            ],
+            rho: [
+                0xa9, 0x0a, 0x9b, 0x8a, 0xb1, 0x35, 0x9d, 0xc9, 0x6b, 0xda, 0xe9, 0x0e, 0x52, 0x74,
+                0x78, 0x8c, 0xb0, 0xc4, 0x26, 0xef, 0xf2, 0x60, 0x43, 0x61, 0x85, 0x39, 0x8b, 0xff,
+                0xf5, 0x0e, 0x92, 0x37,
+            ],
+            cmx: [
+                0x05, 0xb5, 0xe3, 0x20, 0x76, 0xda, 0xe0, 0x94, 0x83, 0x35, 0xac, 0x3d, 0x65, 0x1c,
+                0x6d, 0xbe, 0xa6, 0x4c, 0xe9, 0x11, 0x42, 0x3e, 0x2f, 0x2c, 0x7c, 0x1b, 0xdf, 0xa6,
+                0xb1, 0x41, 0x41, 0x30,
+            ],
+            esk: [
+                0x8b, 0x14, 0x62, 0x2d, 0x2f, 0x91, 0xf1, 0x69, 0x8d, 0x53, 0xfe, 0x47, 0x9a, 0x1e,
+                0x5c, 0x00, 0x64, 0x98, 0xb9, 0x8b, 0x85, 0xb4, 0x50, 0xbd, 0x92, 0x3a, 0x5d, 0x00,
+                0xcb, 0x52, 0xa6, 0x13,
+            ],
+            ephemeral_key: [
+                0x86, 0xee, 0x66, 0xa6, 0xc7, 0xd9, 0xb5, 0xc4, 0xf0, 0xe2, 0xd2, 0xa0, 0xe1, 0x56,
+                0x1e, 0x2a, 0xfa, 0x55, 0x41, 0xa7, 0x24, 0xee, 0x02, 0x7f, 0xc7, 0x0b, 0xb7, 0xe8,
+                0x0a, 0x2c, 0x60, 0x98,
+            ],
+            shared_secret: [
+                0x88, 0xd1, 0x38, 0x2c, 0x14, 0x42, 0x02, 0xd0, 0xd7, 0x55, 0x75, 0x87, 0xb0, 0xd5,
+                0xd0, 0x21, 0x69, 0x29, 0x2a, 0x25, 0x05, 0x43, 0xcb, 0x0a, 0x06, 0xc3, 0x4f, 0x45,
+                0x2f, 0x7b, 0x3b, 0x36,
+            ],
+            k_enc: [
+                0xe3, 0x73, 0xd8, 0x6e, 0xc9, 0xdd, 0xdd, 0x64, 0x5d, 0x9a, 0x6d, 0x06, 0xef, 0xce,
+                0x22, 0xb8, 0x96, 0x42, 0x1d, 0x57, 0xa4, 0x4d, 0x37, 0xa6, 0x50, 0x4a, 0x5d, 0x19,
+                0xdf, 0x21, 0x73, 0x73,
+            ],
+            p_enc: [
+                0x03, 0xaa, 0x14, 0x92, 0x9c, 0x57, 0x89, 0x85, 0x85, 0xce, 0x66, 0x5a, 0xfa, 0x3f,
+                0x54, 0xec, 0xc5, 0x87, 0xe9, 0xf8, 0x49, 0x95, 0x0a, 0xfc, 0xb0, 0xef, 0x46, 0x2a,
+                0x2a, 0xe0, 0x24, 0xb0, 0xf0, 0x22, 0x4d, 0xfd, 0x73, 0x68, 0x4b, 0x88, 0xc7, 0xfb,
+                0xe9, 0x2d, 0x02, 0xb6, 0x8f, 0x75, 0x9c, 0x47, 0x52, 0x66, 0x67, 0x43, 0xf9, 0x3a,
+                0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3, 0x04, 0xfe, 0x32, 0xb2,
+                0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e, 0x7a, 0x59, 0x70, 0x2f,
+                0xff, 0x3c, 0xd7, 0xb9, 0x7a, 0x14, 0x94, 0x36, 0x49, 0x30, 0x55, 0x21, 0x32, 0x6b,
+                0xde, 0x08, 0x56, 0x30, 0x86, 0x46, 0x29, 0x29, 0x1b, 0xae, 0x25, 0xff, 0x88, 0x22,
+                0xa1, 0x4c, 0x4b, 0x66, 0x6a, 0x92, 0x59, 0xad, 0x0d, 0xc4, 0x2a, 0x82, 0x90, 0xac,
+                0x7b, 0xc7, 0xf5, 0x3a, 0x16, 0xf3, 0x79, 0xf7, 0x58, 0xe5, 0xde, 0x75, 0x0f, 0x04,
+                0xfd, 0x7c, 0xad, 0x47, 0x70, 0x1c, 0x85, 0x97, 0xf9, 0x78, 0x88, 0xbe, 0xa6, 0xfa,
+                0x0b, 0xf2, 0x99, 0x99, 0x56, 0xfb, 0xfd, 0x0e, 0xe6, 0x8e, 0xc3, 0x6e, 0x46, 0x88,
+                0x80, 0x9a, 0xe2, 0x31, 0xeb, 0x8b, 0xc4, 0x36, 0x9f, 0x5f, 0xe1, 0x57, 0x3f, 0x57,
+                0xe0, 0x99, 0xd9, 0xc0, 0x99, 0x01, 0xbf, 0x39, 0xca, 0xac, 0x48, 0xdc, 0x11, 0x95,
+                0x6a, 0x8a, 0xe9, 0x05, 0xea, 0xd8, 0x69, 0x54, 0x54, 0x7c, 0x44, 0x8a, 0xe4, 0x3d,
+                0x31, 0x5e, 0x66, 0x9c, 0x42, 0x42, 0xda, 0x56, 0x59, 0x38, 0xf4, 0x17, 0xbf, 0x43,
+                0xce, 0x7b, 0x2b, 0x30, 0xb1, 0xcd, 0x40, 0x18, 0x38, 0x8e, 0x1a, 0x91, 0x0f, 0x0f,
+                0xc4, 0x1f, 0xb0, 0x87, 0x7a, 0x59, 0x25, 0xe4, 0x66, 0x81, 0x9d, 0x37, 0x5b, 0x0a,
+                0x91, 0x2d, 0x4f, 0xe8, 0x43, 0xb7, 0x6e, 0xf6, 0xf2, 0x23, 0xf0, 0xf7, 0xc8, 0x94,
+                0xf3, 0x8f, 0x7a, 0xb7, 0x80, 0xdf, 0xd7, 0x5f, 0x66, 0x9c, 0x8c, 0x06, 0xcf, 0xfa,
+                0x43, 0xeb, 0x47, 0x56, 0x5a, 0x50, 0xe3, 0xb1, 0xfa, 0x45, 0xad, 0x61, 0xce, 0x9a,
+                0x1c, 0x47, 0x27, 0xb7, 0xaa, 0xa5, 0x35, 0x62, 0xf5, 0x23, 0xe7, 0x39, 0x52, 0xbb,
+                0xf3, 0x3d, 0x8a, 0x41, 0x04, 0x07, 0x8a, 0xde, 0x3e, 0xaa, 0xa4, 0x96, 0x99, 0xa6,
+                0x9f, 0xdf, 0x1c, 0x5a, 0xc7, 0x73, 0x21, 0x46, 0xee, 0x5e, 0x1d, 0x6b, 0x6c, 0xa9,
+                0xb9, 0x18, 0x0f, 0x96, 0x4c, 0xc9, 0xd0, 0x87, 0x8a, 0xe1, 0x37, 0x35, 0x24, 0xd7,
+                0xd5, 0x10, 0xe5, 0x82, 0x27, 0xdf, 0x6d, 0xe9, 0xd3, 0x0d, 0x27, 0x18, 0x67, 0x64,
+                0x01, 0x77, 0xb0, 0xf1, 0x85, 0x6e, 0x28, 0xd5, 0xc8, 0xaf, 0xb0, 0x95, 0xef, 0x61,
+                0x84, 0xfe, 0xd6, 0x51, 0x58, 0x90, 0x22, 0xee, 0xae, 0xa4, 0xc0, 0xce, 0x1f, 0xa6,
+                0xf0, 0x85, 0x09, 0x2b, 0x04, 0x97, 0x94, 0x89, 0x17, 0x2b, 0x3e, 0xf8, 0x19, 0x4a,
+                0x79, 0x8d, 0xf5, 0x72, 0x4d, 0x6b, 0x05, 0xf1, 0xae, 0x00, 0x00, 0x13, 0xa0, 0x8d,
+                0x61, 0x2b, 0xca, 0x8a, 0x8c, 0x31, 0x44, 0x3c, 0x10, 0x34, 0x6d, 0xbf, 0x61, 0xde,
+                0x84, 0x75, 0xc0, 0xbb, 0xec, 0x51, 0x04, 0xb4, 0x75, 0x56, 0xaf, 0x3d, 0x51, 0x44,
+                0x58, 0xe2, 0x32, 0x1d, 0x14, 0x60, 0x71, 0x78, 0x9d, 0x23, 0x35, 0x93, 0x4a, 0x68,
+                0x06, 0x14, 0xe8, 0x35, 0x62, 0xf8, 0x2d, 0xfd, 0x40, 0x5b, 0x54, 0xa4, 0x5e, 0xb3,
+                0x2c, 0x16, 0x54, 0x48, 0xd4, 0xd5, 0xd6, 0x1c, 0xa2, 0x85, 0x95, 0x85, 0x36, 0x9f,
+                0x53, 0xf1, 0xa1, 0x37, 0xe9, 0xe8, 0x2b, 0x67, 0xb8, 0xfd, 0xaf, 0x01, 0xbd, 0xa5,
+                0x4a, 0x31, 0x73, 0x11, 0x89, 0x6a, 0xe1, 0x02, 0x80, 0xa0, 0x32, 0x44, 0x0c, 0x42,
+                0x0a, 0x42, 0x1e, 0x94, 0x4d, 0x1e, 0x95, 0x2b, 0x70, 0xd5, 0x82, 0x6c, 0xd3, 0xb0,
+                0x8b, 0x7d, 0xb9, 0x63, 0x0f, 0xe4, 0xfd, 0x5f, 0x22, 0x12, 0x5d, 0xe8, 0x40, 0xfc,
+                0xc4, 0x0b, 0x98, 0x03, 0x8a, 0xf1, 0x1d, 0x55, 0xbe, 0x25, 0x43, 0x25, 0x97, 0xb4,
+                0xb6, 0x5b, 0x9e, 0xc1, 0xc7, 0xa8, 0xbb, 0xfd, 0x05, 0x2c, 0xbf, 0x7e, 0x1c, 0x17,
+                0x85, 0x31, 0x49, 0x34, 0xb2, 0x62, 0xd5, 0x85, 0x37, 0x54, 0xf1, 0xf1, 0x77, 0x71,
+                0xcf, 0xb7, 0x50, 0x30, 0x72, 0x65, 0x57, 0x53,
+            ],
+            c_enc: [
+                0xe6, 0x67, 0x81, 0xae, 0x63, 0x84, 0x1f, 0xff, 0xea, 0x30, 0x21, 0x96, 0x15, 0x94,
+                0xc2, 0x2a, 0x87, 0x20, 0xc7, 0xd8, 0xaa, 0x80, 0x8b, 0xc8, 0x6e, 0x71, 0xa3, 0x6a,
+                0xd7, 0xf8, 0x6f, 0xf8, 0x7c, 0x07, 0xd3, 0xc6, 0x50, 0xa0, 0x8e, 0x23, 0xe9, 0xb5,
+                0x4f, 0x00, 0xb4, 0x0b, 0xa0, 0x15, 0x91, 0x69, 0xdf, 0xca, 0xac, 0xbe, 0x6e, 0x4d,
+                0x87, 0xe9, 0x2a, 0xae, 0x2f, 0xe4, 0xe5, 0x8e, 0x78, 0x48, 0x69, 0xa9, 0x70, 0x68,
+                0x4c, 0x9b, 0x87, 0xc9, 0xa1, 0xa0, 0xcc, 0x39, 0xb3, 0xbc, 0xce, 0xf4, 0x7c, 0xd7,
+                0x6c, 0x23, 0x97, 0xb1, 0x43, 0x39, 0x5a, 0xd5, 0xbd, 0x5f, 0xe4, 0x22, 0x2c, 0x05,
+                0xee, 0xb7, 0xc2, 0x0a, 0x5d, 0x0c, 0x35, 0xf0, 0x3a, 0xa2, 0xa6, 0xba, 0xfa, 0xdf,
+                0x36, 0x3b, 0x1b, 0xa1, 0x5f, 0x8e, 0x75, 0x17, 0x79, 0x32, 0x03, 0xba, 0x09, 0x0e,
+                0xda, 0x67, 0x1a, 0xcf, 0x48, 0xba, 0xaf, 0x8a, 0x6c, 0x1d, 0x55, 0xac, 0x76, 0x0b,
+                0x10, 0xa0, 0x85, 0xb2, 0xe8, 0x33, 0xeb, 0x03, 0xb2, 0xbb, 0xd5, 0x21, 0x46, 0xd2,
+                0x73, 0x19, 0xcc, 0x97, 0x13, 0x70, 0x14, 0xe7, 0x83, 0xac, 0xb6, 0x40, 0x27, 0xb6,
+                0xea, 0x33, 0xa7, 0x1e, 0x54, 0xab, 0xb0, 0xe3, 0xf6, 0x05, 0x39, 0x10, 0xce, 0x33,
+                0xa1, 0xc2, 0xde, 0x27, 0xd5, 0x80, 0x1a, 0x0d, 0xfc, 0x95, 0x28, 0xf8, 0x17, 0xb1,
+                0x24, 0x88, 0x05, 0x62, 0xb7, 0x1f, 0xb9, 0x91, 0xd4, 0x1d, 0x2b, 0x4a, 0x20, 0x3b,
+                0x3b, 0x20, 0x97, 0x55, 0xb6, 0x16, 0x8a, 0x99, 0x8c, 0xea, 0xb0, 0x2b, 0x21, 0x1e,
+                0x49, 0xfe, 0x6a, 0xb1, 0x3a, 0x9a, 0x38, 0x83, 0xfe, 0xca, 0xfa, 0x87, 0x6d, 0xb2,
+                0xbe, 0x99, 0x1a, 0x0a, 0xab, 0xb9, 0xf1, 0x50, 0xd5, 0xf1, 0xbf, 0xfc, 0x75, 0xbf,
+                0x4d, 0xd0, 0xcf, 0x15, 0x09, 0xe5, 0x6b, 0x7e, 0xc8, 0x37, 0xdb, 0x74, 0xd1, 0xcb,
+                0x2a, 0x10, 0x45, 0x1e, 0x1c, 0x04, 0xdd, 0xf9, 0x5b, 0x17, 0x20, 0x00, 0x94, 0x52,
+                0xc5, 0x55, 0x86, 0x96, 0x35, 0x0e, 0xfd, 0xbf, 0x38, 0xc3, 0xde, 0x29, 0x98, 0x09,
+                0x7c, 0xa7, 0xac, 0xd7, 0x09, 0x9a, 0x73, 0x94, 0x73, 0xc2, 0x07, 0x85, 0x89, 0xe7,
+                0x18, 0xf9, 0x20, 0xad, 0xeb, 0xd6, 0xcb, 0x6e, 0xb1, 0x2e, 0x3f, 0xd2, 0x29, 0x47,
+                0xa7, 0x6d, 0x19, 0x17, 0x45, 0xa6, 0xa9, 0x73, 0xc8, 0xb8, 0x4e, 0x9c, 0xd3, 0x30,
+                0x7e, 0x47, 0x88, 0x81, 0xe9, 0x79, 0x8f, 0xd6, 0x66, 0x57, 0xec, 0xe5, 0xe0, 0x89,
+                0xd6, 0x62, 0x71, 0x18, 0xc1, 0x1b, 0xa4, 0x01, 0xb0, 0x17, 0xdb, 0x2d, 0x6f, 0xf4,
+                0x42, 0x10, 0xdb, 0x3e, 0x05, 0xaf, 0xe3, 0x10, 0x18, 0x79, 0xd9, 0x6f, 0x20, 0x2b,
+                0x04, 0x93, 0x67, 0x2b, 0x55, 0x01, 0x3b, 0x26, 0x47, 0xad, 0x71, 0x7f, 0x8e, 0xf2,
+                0x6f, 0x3d, 0x43, 0xb7, 0x75, 0x9e, 0xf5, 0xd6, 0x72, 0xcb, 0x14, 0x17, 0xf9, 0x78,
+                0x81, 0xc3, 0x28, 0x80, 0x61, 0x2e, 0x6b, 0x00, 0xcc, 0x63, 0xfd, 0xa8, 0xd0, 0x29,
+                0x88, 0xc4, 0x03, 0xee, 0x95, 0x6f, 0xfe, 0x72, 0xa2, 0xe1, 0xd1, 0x64, 0x29, 0x10,
+                0xe3, 0xdf, 0x2c, 0xb8, 0xe0, 0xce, 0x90, 0x6f, 0x66, 0x2a, 0x96, 0x37, 0x5b, 0x78,
+                0x64, 0xe1, 0x7f, 0x2a, 0x3d, 0x12, 0x19, 0x68, 0x47, 0x57, 0x03, 0x3c, 0xeb, 0x0c,
+                0xb7, 0xea, 0x10, 0xd9, 0x90, 0x2d, 0x56, 0x55, 0x53, 0x15, 0xa8, 0x0f, 0x99, 0x7f,
+                0xb7, 0xc3, 0xa6, 0xb7, 0x0e, 0x30, 0x7f, 0x33, 0x18, 0x44, 0x60, 0x1e, 0xf5, 0x70,
+                0x13, 0xe3, 0xd3, 0x35, 0xfe, 0x48, 0x29, 0x81, 0xef, 0x72, 0x1f, 0xf0, 0xc3, 0x4f,
+                0xb8, 0x8a, 0xcd, 0xae, 0x2f, 0xa0, 0xc1, 0x80, 0x1a, 0xd1, 0xe9, 0x67, 0x56, 0x25,
+                0x66, 0xf7, 0xea, 0x6c, 0x65, 0x67, 0xfe, 0x06, 0x6d, 0x33, 0xd0, 0x84, 0x1b, 0x33,
+                0xb5, 0x60, 0xe2, 0xf8, 0x43, 0x58, 0xd4, 0x1a, 0xfc, 0x3e, 0x43, 0x6d, 0x86, 0x8e,
+                0x02, 0x1a, 0x1e, 0xde, 0xb3, 0x69, 0xa9, 0x84, 0x06, 0xa5, 0x76, 0xed, 0x48, 0x38,
+                0xc7, 0x30, 0xad, 0xef, 0xd6, 0x94, 0x24, 0xc2, 0x35, 0xdb, 0x4f, 0xb1, 0xf6, 0xf6,
+                0x2e, 0x9b, 0x51, 0x80, 0x5c, 0xdb, 0x43, 0xea, 0xf2, 0xa6, 0xb4, 0x5f, 0x81, 0x4d,
+                0xaf, 0x53, 0x0a, 0xfb, 0xd0, 0xb3, 0x0b, 0xbb, 0xbb, 0xa9, 0x66, 0x05, 0x9a, 0x08,
+                0xd3, 0x1d, 0x13, 0x7b, 0xbf, 0x5e, 0xc5, 0x80, 0x58, 0xd3,
+            ],
+            ock: [
+                0x85, 0x6e, 0x1a, 0x97, 0x09, 0xb0, 0xc4, 0x16, 0x93, 0x3f, 0x59, 0x70, 0x71, 0x5c,
+                0x56, 0xe2, 0xe0, 0x5c, 0x2e, 0xa9, 0x7d, 0x81, 0x51, 0x25, 0x70, 0x14, 0x79, 0xc3,
+                0x3a, 0x5d, 0x91, 0xcb,
+            ],
+            op: [
+                0x78, 0xa4, 0xe3, 0x39, 0x88, 0xd7, 0x1d, 0x71, 0x8e, 0x59, 0x55, 0x55, 0x28, 0x4c,
+                0x24, 0x9a, 0x62, 0xb7, 0x12, 0x88, 0x06, 0xa5, 0x4c, 0x3b, 0x36, 0xa3, 0xaa, 0x57,
+                0x14, 0x93, 0x16, 0x36, 0x8b, 0x14, 0x62, 0x2d, 0x2f, 0x91, 0xf1, 0x69, 0x8d, 0x53,
+                0xfe, 0x47, 0x9a, 0x1e, 0x5c, 0x00, 0x64, 0x98, 0xb9, 0x8b, 0x85, 0xb4, 0x50, 0xbd,
+                0x92, 0x3a, 0x5d, 0x00, 0xcb, 0x52, 0xa6, 0x13,
+            ],
+            c_out: [
+                0x72, 0x36, 0xea, 0xb9, 0xf0, 0x12, 0x98, 0xc8, 0x4f, 0x38, 0x28, 0xf6, 0xac, 0x15,
+                0x42, 0x76, 0xb5, 0xb7, 0x64, 0x62, 0xf5, 0x74, 0x2d, 0x69, 0xdc, 0x47, 0x7a, 0x10,
+                0x5d, 0xc2, 0x71, 0x1b, 0x12, 0xe9, 0xb5, 0x82, 0x8c, 0x01, 0x76, 0xfe, 0xf4, 0x4a,
+                0x54, 0x0f, 0x60, 0x95, 0x8e, 0x5a, 0x3e, 0xd6, 0xa2, 0xcc, 0x5e, 0xdd, 0xe9, 0x13,
+                0xd1, 0x4c, 0xf8, 0xe8, 0xe2, 0x8e, 0xa2, 0x5c, 0x18, 0x62, 0x7a, 0x84, 0xa2, 0xbe,
+                0x96, 0x1f, 0x44, 0x72, 0x67, 0x67, 0xe9, 0xf8, 0x43, 0x1b,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x0b, 0xb5, 0x6c, 0x49, 0xc0, 0x63, 0x2d, 0x4c, 0xc7, 0xe4, 0x85, 0x51, 0xdb, 0x46,
+                0x42, 0x8f, 0x1b, 0x1a, 0x52, 0x66, 0x1e, 0x07, 0xe0, 0xc3, 0xbc, 0xc2, 0x31, 0x74,
+                0xcc, 0xbb, 0xbd, 0xa1, 0xfa, 0x19, 0x24, 0xf4, 0x16, 0xcd, 0x48, 0x39, 0x0e, 0x2b,
+                0x11, 0xc6, 0xe7, 0x82, 0x56, 0xd4, 0xc4, 0xc5, 0x64, 0x1a, 0xca, 0xd9, 0xa2, 0x0c,
+                0x24, 0xfb, 0xe6, 0xcb, 0x4e, 0xe7, 0x81, 0x25,
+            ],
+            ovk: [
+                0x21, 0xe9, 0x1a, 0x3c, 0x4a, 0xa3, 0xf2, 0x7f, 0xa1, 0xb6, 0x33, 0x96, 0xe2, 0xb4,
+                0x1d, 0xb9, 0x08, 0xfd, 0xab, 0x8b, 0x18, 0xcc, 0x73, 0x04, 0xe9, 0x4e, 0x97, 0x05,
+                0x68, 0xf9, 0x42, 0x1c,
+            ],
+            default_d: [
+                0xe0, 0x66, 0xb5, 0xe7, 0x96, 0x86, 0xe9, 0xf3, 0x6e, 0xce, 0xc7,
+            ],
+            default_pk_d: [
+                0x3b, 0x3e, 0x88, 0x3e, 0x95, 0x8c, 0xd6, 0xe0, 0x75, 0x4d, 0x74, 0xca, 0xae, 0x1e,
+                0x5a, 0x43, 0x98, 0xab, 0xeb, 0x7d, 0x10, 0xee, 0x5f, 0x75, 0xa4, 0xab, 0x8e, 0xf7,
+                0x03, 0x8e, 0x3d, 0xb3,
+            ],
+            v: 12119135386131850622,
+            rseed: [
+                0xc3, 0x6d, 0xcf, 0xd3, 0x4a, 0x0c, 0xb6, 0x63, 0x78, 0x76, 0x10, 0x5e, 0x79, 0xbf,
+                0x3b, 0xd5, 0x8e, 0xc1, 0x48, 0xcb, 0x64, 0x97, 0x0e, 0x32, 0x23, 0xa9, 0x1f, 0x71,
+                0xdf, 0xcf, 0xd5, 0xa0,
+            ],
+            asset: [
+                0x67, 0x43, 0xf9, 0x3a, 0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3,
+                0x04, 0xfe, 0x32, 0xb2, 0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e,
+                0x7a, 0x59, 0x70, 0x2f,
+            ],
+            memo: [
+                0xff, 0x4b, 0x66, 0x7f, 0xba, 0xf3, 0xd4, 0xb3, 0xb9, 0x08, 0xb9, 0x82, 0x88, 0x20,
+                0xdf, 0xec, 0xdd, 0x75, 0x37, 0x50, 0xb5, 0xf9, 0xd2, 0x21, 0x6e, 0x56, 0xc6, 0x15,
+                0x27, 0x2f, 0x85, 0x44, 0x64, 0xc0, 0xca, 0x4b, 0x1e, 0x85, 0xae, 0xdd, 0x03, 0x82,
+                0x92, 0xc4, 0xe1, 0xa5, 0x77, 0x44, 0xeb, 0xba, 0x01, 0x0b, 0x9e, 0xbf, 0xbb, 0x01,
+                0x1b, 0xd6, 0xf0, 0xb7, 0x88, 0x05, 0x02, 0x5d, 0x27, 0xf3, 0xc1, 0x77, 0x46, 0xba,
+                0xe1, 0x16, 0xc1, 0x5d, 0x9f, 0x47, 0x1f, 0x0f, 0x62, 0x88, 0xa1, 0x50, 0x64, 0x7b,
+                0x2a, 0xfe, 0x9d, 0xf7, 0xcc, 0xcf, 0x01, 0xf5, 0xcd, 0xe5, 0xf0, 0x46, 0x80, 0xbb,
+                0xfe, 0xd8, 0x7f, 0x6c, 0xf4, 0x29, 0xfb, 0x27, 0xad, 0x6b, 0xab, 0xe7, 0x91, 0x76,
+                0x66, 0x11, 0xcf, 0x5b, 0xc2, 0x0e, 0x48, 0xbe, 0xf1, 0x19, 0x25, 0x9b, 0x9b, 0x8a,
+                0x0e, 0x39, 0xc3, 0xdf, 0x28, 0xcb, 0x95, 0x82, 0xea, 0x33, 0x86, 0x01, 0xcd, 0xc4,
+                0x81, 0xb3, 0x2f, 0xb8, 0x2a, 0xde, 0xeb, 0xb3, 0xda, 0xde, 0x25, 0xd1, 0xa3, 0xdf,
+                0x20, 0xc3, 0x7e, 0x71, 0x25, 0x06, 0xb5, 0xd9, 0x96, 0xc4, 0x9a, 0x9f, 0x0f, 0x30,
+                0xdd, 0xcb, 0x91, 0xfe, 0x90, 0x04, 0xe1, 0xe8, 0x32, 0x94, 0xa6, 0xc9, 0x20, 0x3d,
+                0x94, 0xe8, 0xdc, 0x2c, 0xbb, 0x44, 0x9d, 0xe4, 0x15, 0x50, 0x32, 0x60, 0x4e, 0x47,
+                0x99, 0x70, 0x16, 0xb3, 0x04, 0xfd, 0x43, 0x7d, 0x82, 0x35, 0x04, 0x5e, 0x25, 0x5a,
+                0x19, 0xb7, 0x43, 0xa0, 0xa9, 0xf2, 0xe3, 0x36, 0xb4, 0x4c, 0xae, 0x30, 0x7b, 0xb3,
+                0x98, 0x7b, 0xd3, 0xe4, 0xe7, 0x77, 0xfb, 0xb3, 0x4c, 0x0a, 0xb8, 0xcc, 0x3d, 0x67,
+                0x46, 0x6c, 0x0a, 0x88, 0xdd, 0x4c, 0xca, 0xd1, 0x8a, 0x07, 0xa8, 0xd1, 0x06, 0x8d,
+                0xf5, 0xb6, 0x29, 0xe5, 0x71, 0x8d, 0x0f, 0x6d, 0xf5, 0xc9, 0x57, 0xcf, 0x71, 0xbb,
+                0x00, 0xa5, 0x17, 0x8f, 0x17, 0x5c, 0xac, 0xa9, 0x44, 0xe6, 0x35, 0xc5, 0x15, 0x9f,
+                0x73, 0x8e, 0x24, 0x02, 0xa2, 0xd2, 0x1a, 0xa0, 0x81, 0xe1, 0x0e, 0x45, 0x6a, 0xfb,
+                0x00, 0xb9, 0xf6, 0x24, 0x16, 0xc8, 0xb9, 0xc0, 0xf7, 0x22, 0x8f, 0x51, 0x07, 0x29,
+                0xe0, 0xbe, 0x3f, 0x30, 0x53, 0x13, 0xd7, 0x7f, 0x73, 0x79, 0xdc, 0x2a, 0xf2, 0x48,
+                0x69, 0xc6, 0xc7, 0x4e, 0xe4, 0x47, 0x14, 0x98, 0x86, 0x1d, 0x19, 0x2f, 0x0f, 0xf0,
+                0xf5, 0x08, 0x28, 0x5d, 0xab, 0x6b, 0x6a, 0x36, 0xcc, 0xf7, 0xd1, 0x22, 0x56, 0xcc,
+                0x76, 0xb9, 0x55, 0x03, 0x72, 0x0a, 0xc6, 0x72, 0xd0, 0x82, 0x68, 0xd2, 0xcf, 0x77,
+                0x73, 0xb6, 0xba, 0x2a, 0x5f, 0x66, 0x48, 0x47, 0xbf, 0x70, 0x7f, 0x2f, 0xc1, 0x0c,
+                0x98, 0xf2, 0xf0, 0x06, 0xec, 0x22, 0xcc, 0xb5, 0xa8, 0xc8, 0xb7, 0xc4, 0x0c, 0x7c,
+                0x2d, 0x49, 0xa6, 0x63, 0x9b, 0x9f, 0x2c, 0xe3, 0x3c, 0x25, 0xc0, 0x4b, 0xc4, 0x61,
+                0xe7, 0x44, 0xdf, 0xa5, 0x36, 0xb0, 0x0d, 0x94, 0xba, 0xdd, 0xf4, 0xf4, 0xd1, 0x40,
+                0x44, 0xc6, 0x95, 0xa3, 0x38, 0x81, 0x47, 0x7d, 0xf1, 0x24, 0xf0, 0xfc, 0xf2, 0x06,
+                0xa9, 0xfb, 0x2e, 0x65, 0xe3, 0x04, 0xcd, 0xbf, 0x0c, 0x4d, 0x23, 0x90, 0x17, 0x0c,
+                0x13, 0x0a, 0xb8, 0x49, 0xc2, 0xf2, 0x2b, 0x5c, 0xdd, 0x39, 0x21, 0x64, 0x0c, 0x8c,
+                0xf1, 0x97, 0x6a, 0xe1, 0x01, 0x0b, 0x0d, 0xfd, 0x9c, 0xb2, 0x54, 0x3e, 0x45, 0xf9,
+                0x97, 0x49, 0xcc, 0x4d, 0x61, 0xf2, 0xe8, 0xaa, 0xbf, 0xe9, 0x8b, 0xd9, 0x05, 0xfa,
+                0x39, 0x95, 0x1b, 0x33, 0xea, 0x76, 0x9c, 0x45, 0xab, 0x95, 0x31, 0xc5, 0x72, 0x09,
+                0x86, 0x2a, 0xd1, 0x2f, 0xd7, 0x6b, 0xa4, 0x80,
+            ],
+            cv_net: [
+                0xca, 0xf6, 0x40, 0x8d, 0xef, 0x1f, 0x0f, 0x2b, 0xaa, 0x17, 0xb1, 0x30, 0xc3, 0xae,
+                0x72, 0x95, 0x89, 0xbe, 0x69, 0xd8, 0x28, 0xbe, 0x54, 0x30, 0x69, 0x16, 0x41, 0x3c,
+                0xd2, 0x50, 0x21, 0x17,
+            ],
+            rho: [
+                0x8d, 0x67, 0xe3, 0xba, 0x4d, 0xbc, 0x9d, 0xa5, 0xe8, 0x38, 0x23, 0xa1, 0x23, 0x11,
+                0x63, 0x96, 0x51, 0xa4, 0xff, 0xa9, 0x5f, 0x27, 0xc1, 0x83, 0x0d, 0x91, 0xd8, 0xb7,
+                0x3c, 0xfb, 0xf1, 0x31,
+            ],
+            cmx: [
+                0xea, 0x7c, 0x13, 0xf7, 0xe1, 0x20, 0x5e, 0x78, 0xc8, 0xce, 0x4e, 0xe4, 0xfd, 0xcd,
+                0xb7, 0xee, 0x76, 0x92, 0x8d, 0xdf, 0x6d, 0xbe, 0x1b, 0x2d, 0x6f, 0x69, 0x81, 0xb7,
+                0xc9, 0x65, 0x79, 0x10,
+            ],
+            esk: [
+                0x85, 0x7b, 0xa2, 0x47, 0xd4, 0x68, 0xe1, 0x8d, 0xfe, 0x96, 0x73, 0xe9, 0x05, 0x99,
+                0x23, 0xc2, 0x2e, 0x9b, 0x70, 0x0d, 0x56, 0x3d, 0xf8, 0xa9, 0x89, 0xcc, 0x63, 0x00,
+                0x06, 0x15, 0xb2, 0x0d,
+            ],
+            ephemeral_key: [
+                0x89, 0xfd, 0x2c, 0xf3, 0x79, 0x56, 0xba, 0xaf, 0x11, 0x27, 0xbb, 0x0e, 0x33, 0x40,
+                0x01, 0x09, 0xdb, 0x03, 0x50, 0xf4, 0xab, 0xb7, 0xd6, 0xd8, 0x1f, 0xa5, 0x84, 0x8e,
+                0x1b, 0xb1, 0x69, 0x26,
+            ],
+            shared_secret: [
+                0xdb, 0xa6, 0x37, 0x94, 0xb6, 0x7c, 0x49, 0x6d, 0x01, 0x1c, 0xfb, 0x6b, 0xba, 0x29,
+                0x7c, 0xa5, 0x7d, 0x18, 0xc7, 0xa9, 0xad, 0xdf, 0xfb, 0xc8, 0x37, 0x17, 0x6a, 0xcf,
+                0x3a, 0x30, 0x1e, 0x23,
+            ],
+            k_enc: [
+                0x80, 0xe7, 0x52, 0x2c, 0xb0, 0x32, 0x51, 0xc8, 0x55, 0x34, 0x1f, 0x06, 0xf9, 0x41,
+                0x33, 0x41, 0xe1, 0x6e, 0x83, 0xb4, 0x89, 0xe1, 0x5a, 0x0a, 0x00, 0x65, 0xc3, 0x3b,
+                0xf3, 0x81, 0x58, 0xc4,
+            ],
+            p_enc: [
+                0x03, 0xe0, 0x66, 0xb5, 0xe7, 0x96, 0x86, 0xe9, 0xf3, 0x6e, 0xce, 0xc7, 0x7e, 0x65,
+                0x41, 0x7b, 0x6c, 0xd1, 0x2f, 0xa8, 0xc3, 0x6d, 0xcf, 0xd3, 0x4a, 0x0c, 0xb6, 0x63,
+                0x78, 0x76, 0x10, 0x5e, 0x79, 0xbf, 0x3b, 0xd5, 0x8e, 0xc1, 0x48, 0xcb, 0x64, 0x97,
+                0x0e, 0x32, 0x23, 0xa9, 0x1f, 0x71, 0xdf, 0xcf, 0xd5, 0xa0, 0x67, 0x43, 0xf9, 0x3a,
+                0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3, 0x04, 0xfe, 0x32, 0xb2,
+                0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e, 0x7a, 0x59, 0x70, 0x2f,
+                0xff, 0x4b, 0x66, 0x7f, 0xba, 0xf3, 0xd4, 0xb3, 0xb9, 0x08, 0xb9, 0x82, 0x88, 0x20,
+                0xdf, 0xec, 0xdd, 0x75, 0x37, 0x50, 0xb5, 0xf9, 0xd2, 0x21, 0x6e, 0x56, 0xc6, 0x15,
+                0x27, 0x2f, 0x85, 0x44, 0x64, 0xc0, 0xca, 0x4b, 0x1e, 0x85, 0xae, 0xdd, 0x03, 0x82,
+                0x92, 0xc4, 0xe1, 0xa5, 0x77, 0x44, 0xeb, 0xba, 0x01, 0x0b, 0x9e, 0xbf, 0xbb, 0x01,
+                0x1b, 0xd6, 0xf0, 0xb7, 0x88, 0x05, 0x02, 0x5d, 0x27, 0xf3, 0xc1, 0x77, 0x46, 0xba,
+                0xe1, 0x16, 0xc1, 0x5d, 0x9f, 0x47, 0x1f, 0x0f, 0x62, 0x88, 0xa1, 0x50, 0x64, 0x7b,
+                0x2a, 0xfe, 0x9d, 0xf7, 0xcc, 0xcf, 0x01, 0xf5, 0xcd, 0xe5, 0xf0, 0x46, 0x80, 0xbb,
+                0xfe, 0xd8, 0x7f, 0x6c, 0xf4, 0x29, 0xfb, 0x27, 0xad, 0x6b, 0xab, 0xe7, 0x91, 0x76,
+                0x66, 0x11, 0xcf, 0x5b, 0xc2, 0x0e, 0x48, 0xbe, 0xf1, 0x19, 0x25, 0x9b, 0x9b, 0x8a,
+                0x0e, 0x39, 0xc3, 0xdf, 0x28, 0xcb, 0x95, 0x82, 0xea, 0x33, 0x86, 0x01, 0xcd, 0xc4,
+                0x81, 0xb3, 0x2f, 0xb8, 0x2a, 0xde, 0xeb, 0xb3, 0xda, 0xde, 0x25, 0xd1, 0xa3, 0xdf,
+                0x20, 0xc3, 0x7e, 0x71, 0x25, 0x06, 0xb5, 0xd9, 0x96, 0xc4, 0x9a, 0x9f, 0x0f, 0x30,
+                0xdd, 0xcb, 0x91, 0xfe, 0x90, 0x04, 0xe1, 0xe8, 0x32, 0x94, 0xa6, 0xc9, 0x20, 0x3d,
+                0x94, 0xe8, 0xdc, 0x2c, 0xbb, 0x44, 0x9d, 0xe4, 0x15, 0x50, 0x32, 0x60, 0x4e, 0x47,
+                0x99, 0x70, 0x16, 0xb3, 0x04, 0xfd, 0x43, 0x7d, 0x82, 0x35, 0x04, 0x5e, 0x25, 0x5a,
+                0x19, 0xb7, 0x43, 0xa0, 0xa9, 0xf2, 0xe3, 0x36, 0xb4, 0x4c, 0xae, 0x30, 0x7b, 0xb3,
+                0x98, 0x7b, 0xd3, 0xe4, 0xe7, 0x77, 0xfb, 0xb3, 0x4c, 0x0a, 0xb8, 0xcc, 0x3d, 0x67,
+                0x46, 0x6c, 0x0a, 0x88, 0xdd, 0x4c, 0xca, 0xd1, 0x8a, 0x07, 0xa8, 0xd1, 0x06, 0x8d,
+                0xf5, 0xb6, 0x29, 0xe5, 0x71, 0x8d, 0x0f, 0x6d, 0xf5, 0xc9, 0x57, 0xcf, 0x71, 0xbb,
+                0x00, 0xa5, 0x17, 0x8f, 0x17, 0x5c, 0xac, 0xa9, 0x44, 0xe6, 0x35, 0xc5, 0x15, 0x9f,
+                0x73, 0x8e, 0x24, 0x02, 0xa2, 0xd2, 0x1a, 0xa0, 0x81, 0xe1, 0x0e, 0x45, 0x6a, 0xfb,
+                0x00, 0xb9, 0xf6, 0x24, 0x16, 0xc8, 0xb9, 0xc0, 0xf7, 0x22, 0x8f, 0x51, 0x07, 0x29,
+                0xe0, 0xbe, 0x3f, 0x30, 0x53, 0x13, 0xd7, 0x7f, 0x73, 0x79, 0xdc, 0x2a, 0xf2, 0x48,
+                0x69, 0xc6, 0xc7, 0x4e, 0xe4, 0x47, 0x14, 0x98, 0x86, 0x1d, 0x19, 0x2f, 0x0f, 0xf0,
+                0xf5, 0x08, 0x28, 0x5d, 0xab, 0x6b, 0x6a, 0x36, 0xcc, 0xf7, 0xd1, 0x22, 0x56, 0xcc,
+                0x76, 0xb9, 0x55, 0x03, 0x72, 0x0a, 0xc6, 0x72, 0xd0, 0x82, 0x68, 0xd2, 0xcf, 0x77,
+                0x73, 0xb6, 0xba, 0x2a, 0x5f, 0x66, 0x48, 0x47, 0xbf, 0x70, 0x7f, 0x2f, 0xc1, 0x0c,
+                0x98, 0xf2, 0xf0, 0x06, 0xec, 0x22, 0xcc, 0xb5, 0xa8, 0xc8, 0xb7, 0xc4, 0x0c, 0x7c,
+                0x2d, 0x49, 0xa6, 0x63, 0x9b, 0x9f, 0x2c, 0xe3, 0x3c, 0x25, 0xc0, 0x4b, 0xc4, 0x61,
+                0xe7, 0x44, 0xdf, 0xa5, 0x36, 0xb0, 0x0d, 0x94, 0xba, 0xdd, 0xf4, 0xf4, 0xd1, 0x40,
+                0x44, 0xc6, 0x95, 0xa3, 0x38, 0x81, 0x47, 0x7d, 0xf1, 0x24, 0xf0, 0xfc, 0xf2, 0x06,
+                0xa9, 0xfb, 0x2e, 0x65, 0xe3, 0x04, 0xcd, 0xbf, 0x0c, 0x4d, 0x23, 0x90, 0x17, 0x0c,
+                0x13, 0x0a, 0xb8, 0x49, 0xc2, 0xf2, 0x2b, 0x5c, 0xdd, 0x39, 0x21, 0x64, 0x0c, 0x8c,
+                0xf1, 0x97, 0x6a, 0xe1, 0x01, 0x0b, 0x0d, 0xfd, 0x9c, 0xb2, 0x54, 0x3e, 0x45, 0xf9,
+                0x97, 0x49, 0xcc, 0x4d, 0x61, 0xf2, 0xe8, 0xaa, 0xbf, 0xe9, 0x8b, 0xd9, 0x05, 0xfa,
+                0x39, 0x95, 0x1b, 0x33, 0xea, 0x76, 0x9c, 0x45, 0xab, 0x95, 0x31, 0xc5, 0x72, 0x09,
+                0x86, 0x2a, 0xd1, 0x2f, 0xd7, 0x6b, 0xa4, 0x80,
+            ],
+            c_enc: [
+                0x3e, 0x4e, 0x9b, 0x18, 0x56, 0xe7, 0xbf, 0xba, 0x7a, 0xbb, 0xc9, 0x4a, 0x72, 0xb4,
+                0xab, 0xb1, 0xd8, 0x46, 0x26, 0x79, 0x30, 0x77, 0xe8, 0x37, 0xda, 0xf3, 0x3f, 0xff,
+                0xa2, 0x7c, 0x7a, 0x33, 0x97, 0x8a, 0x54, 0x32, 0x51, 0x0d, 0x99, 0x3c, 0x7d, 0x92,
+                0x24, 0xc0, 0x97, 0xac, 0xc5, 0x25, 0x88, 0x1c, 0x76, 0x08, 0xa4, 0x13, 0xfa, 0x5f,
+                0x49, 0xaf, 0xc6, 0x58, 0x93, 0x94, 0xab, 0x86, 0x59, 0x0c, 0x43, 0x78, 0x5a, 0x58,
+                0x0b, 0xd2, 0x86, 0x0b, 0xe3, 0xb8, 0x07, 0x99, 0xc1, 0x47, 0xf4, 0xe6, 0xc7, 0x50,
+                0x31, 0x36, 0x76, 0x9a, 0xe4, 0xc6, 0x2c, 0xd9, 0x16, 0x9d, 0xd3, 0x66, 0xb8, 0x99,
+                0xa5, 0x44, 0x8c, 0xdb, 0xc4, 0x0c, 0x8d, 0x89, 0x60, 0x38, 0x6c, 0x0f, 0x0e, 0x3e,
+                0x74, 0x03, 0xd2, 0x6e, 0x66, 0xa5, 0x99, 0x40, 0xe7, 0x6a, 0xc7, 0x9d, 0xd1, 0xea,
+                0xea, 0x55, 0xd0, 0xc0, 0x9f, 0x3b, 0xf6, 0xd9, 0xdc, 0xea, 0xe1, 0xee, 0x87, 0x41,
+                0x38, 0x39, 0x1a, 0x0c, 0x93, 0x3e, 0x7b, 0x72, 0x75, 0xd7, 0x3b, 0x8e, 0xf4, 0x9b,
+                0x8c, 0x39, 0x5c, 0x87, 0xfd, 0x32, 0x09, 0xe1, 0xf5, 0xa9, 0xc5, 0x52, 0xe6, 0x11,
+                0x2b, 0xd9, 0xf3, 0xea, 0xb6, 0xbd, 0x4f, 0x26, 0xab, 0xa6, 0x4d, 0xb8, 0x27, 0xa7,
+                0x1b, 0x86, 0x53, 0x9c, 0xf9, 0x72, 0x96, 0xfe, 0xca, 0x46, 0x27, 0x3e, 0xf4, 0x56,
+                0xfe, 0x16, 0x0b, 0x31, 0xc7, 0x72, 0xcf, 0xf6, 0x82, 0xa6, 0xed, 0x06, 0x10, 0x93,
+                0x14, 0x6e, 0xa6, 0x57, 0xf4, 0x61, 0xb5, 0x6f, 0xb2, 0x3c, 0x20, 0x64, 0xd8, 0x98,
+                0xec, 0x25, 0x70, 0x34, 0x3c, 0x56, 0x6a, 0xdc, 0x1f, 0x2d, 0x1d, 0x86, 0x48, 0x41,
+                0x42, 0x2e, 0x96, 0x4a, 0x4a, 0xb8, 0x3c, 0x18, 0x95, 0x0f, 0x82, 0xfa, 0x97, 0x4c,
+                0x83, 0x3c, 0xf7, 0x62, 0x3d, 0xa9, 0xb8, 0xbe, 0xec, 0x7a, 0x1e, 0xbf, 0x5c, 0xeb,
+                0x22, 0x25, 0xc1, 0xf2, 0xda, 0x30, 0xd0, 0x47, 0x9d, 0xbb, 0xa1, 0x68, 0x1f, 0x6e,
+                0x75, 0xf2, 0xfa, 0xce, 0x30, 0x70, 0xe7, 0xa8, 0x13, 0xaa, 0x88, 0x34, 0x72, 0xae,
+                0x47, 0x7c, 0x47, 0xbc, 0x2e, 0xc2, 0xe5, 0xc6, 0xcd, 0x85, 0x5d, 0x12, 0x25, 0x7c,
+                0x54, 0xbd, 0xea, 0xdc, 0x44, 0x3b, 0xe7, 0xd6, 0xb6, 0x7d, 0x11, 0xad, 0xd4, 0x1f,
+                0x49, 0xa9, 0xb4, 0xd8, 0x13, 0x8f, 0xd8, 0x7c, 0x0d, 0xee, 0x7f, 0x5f, 0xae, 0x0c,
+                0xd8, 0x83, 0x7c, 0x39, 0xdb, 0x19, 0x9e, 0xea, 0x34, 0x48, 0xa9, 0x41, 0x05, 0x1f,
+                0x78, 0x5c, 0x1f, 0x8a, 0xd0, 0xb2, 0x65, 0xd8, 0x78, 0x7c, 0x70, 0x1d, 0xe0, 0x5b,
+                0xf1, 0xc6, 0x6a, 0x3d, 0x65, 0x94, 0xf5, 0x22, 0x19, 0xcc, 0xb3, 0x1e, 0x05, 0x03,
+                0x9c, 0x83, 0x02, 0x2a, 0xa8, 0x61, 0x21, 0x1c, 0x50, 0xc2, 0xf0, 0xcf, 0xb1, 0xbe,
+                0x94, 0x45, 0xcd, 0xb9, 0x6d, 0xf0, 0x0a, 0x16, 0x67, 0x57, 0x1a, 0x68, 0xb7, 0xf2,
+                0x19, 0x45, 0xb1, 0xfa, 0xef, 0x4e, 0xbc, 0xcf, 0xa1, 0xc5, 0x83, 0xc4, 0x66, 0xb0,
+                0xef, 0x58, 0x8a, 0xcd, 0xfd, 0x47, 0x8c, 0x7f, 0x21, 0x22, 0x61, 0x12, 0x8a, 0xf4,
+                0x25, 0xa2, 0xe0, 0xa3, 0xa2, 0x7e, 0x17, 0x48, 0x7f, 0xff, 0x08, 0xb9, 0xfb, 0x80,
+                0xd8, 0xaa, 0x71, 0x8f, 0xe2, 0x67, 0xda, 0xbc, 0x70, 0xd3, 0x6b, 0x8f, 0x62, 0xe0,
+                0xe9, 0x04, 0x33, 0x47, 0x01, 0x4e, 0x02, 0xa2, 0x7a, 0x85, 0x79, 0x97, 0xe1, 0xcf,
+                0x3e, 0x72, 0x33, 0xe2, 0x51, 0x3f, 0x83, 0x2e, 0x60, 0x35, 0x91, 0x68, 0xe1, 0x73,
+                0xfc, 0x03, 0x07, 0x9e, 0x99, 0x83, 0xa1, 0x34, 0x1d, 0x68, 0xbb, 0x3a, 0x3c, 0x53,
+                0x3a, 0x31, 0x84, 0xf4, 0xaa, 0x41, 0x75, 0xa9, 0xfe, 0xc1, 0xf0, 0x1f, 0xe3, 0xf8,
+                0xb4, 0xfa, 0xeb, 0xed, 0x30, 0xb7, 0xe7, 0x18, 0x0e, 0x7e, 0xd7, 0xfc, 0x80, 0x7d,
+                0x51, 0x0c, 0x06, 0x01, 0x42, 0x8d, 0xd6, 0x96, 0x41, 0xa3, 0x07, 0x29, 0xcd, 0x64,
+                0x45, 0xde, 0x66, 0x0f, 0xb1, 0xbe, 0x2f, 0xb9, 0x6e, 0x56, 0xbb, 0x67, 0xb6, 0xef,
+                0x88, 0xe0, 0x7d, 0x14, 0xae, 0xda, 0xa0, 0xbd, 0x23, 0x27, 0xe9, 0xd5, 0x27, 0xb7,
+                0xe3, 0x30, 0x07, 0xf8, 0xca, 0xb5, 0x10, 0xad, 0xc2, 0x53, 0xca, 0xe6, 0x68, 0x7f,
+                0xfd, 0xc9, 0x60, 0x40, 0x30, 0x40, 0x15, 0x9a, 0x7e, 0x98, 0xda, 0xa8, 0xa7, 0x7b,
+                0x2a, 0x3f, 0xdf, 0x4f, 0x79, 0xd5, 0xbd, 0xbe, 0x9e, 0x2b,
+            ],
+            ock: [
+                0xe6, 0xb7, 0x05, 0x50, 0xe1, 0xd7, 0xa2, 0xbe, 0x73, 0x04, 0x39, 0x64, 0x41, 0xec,
+                0x6a, 0xc0, 0x47, 0x45, 0x99, 0xf9, 0xea, 0xd7, 0x55, 0xc2, 0xcf, 0x27, 0x6b, 0x87,
+                0x50, 0xc5, 0xcf, 0x2d,
+            ],
+            op: [
+                0x3b, 0x3e, 0x88, 0x3e, 0x95, 0x8c, 0xd6, 0xe0, 0x75, 0x4d, 0x74, 0xca, 0xae, 0x1e,
+                0x5a, 0x43, 0x98, 0xab, 0xeb, 0x7d, 0x10, 0xee, 0x5f, 0x75, 0xa4, 0xab, 0x8e, 0xf7,
+                0x03, 0x8e, 0x3d, 0xb3, 0x85, 0x7b, 0xa2, 0x47, 0xd4, 0x68, 0xe1, 0x8d, 0xfe, 0x96,
+                0x73, 0xe9, 0x05, 0x99, 0x23, 0xc2, 0x2e, 0x9b, 0x70, 0x0d, 0x56, 0x3d, 0xf8, 0xa9,
+                0x89, 0xcc, 0x63, 0x00, 0x06, 0x15, 0xb2, 0x0d,
+            ],
+            c_out: [
+                0x02, 0xb1, 0x37, 0x3e, 0xb1, 0x89, 0x56, 0x32, 0x2b, 0x47, 0xa1, 0x70, 0x0d, 0xb7,
+                0x43, 0x31, 0x6e, 0xde, 0x46, 0x44, 0xd6, 0x59, 0x3c, 0xd7, 0x94, 0x22, 0xd7, 0x51,
+                0x3d, 0x1b, 0x80, 0xe6, 0x85, 0x05, 0xdf, 0xe9, 0xd6, 0x86, 0x2e, 0x79, 0x4e, 0x30,
+                0x28, 0x8b, 0xae, 0xa8, 0xb0, 0xbc, 0xb3, 0x8b, 0x35, 0x49, 0x77, 0xaa, 0xee, 0x57,
+                0x2e, 0xe8, 0x86, 0x8b, 0x2d, 0xa0, 0x7d, 0xa2, 0x99, 0x2c, 0x6d, 0x9f, 0xb8, 0xbd,
+                0x59, 0x0b, 0x8d, 0xa0, 0x28, 0x11, 0xb5, 0x09, 0xe8, 0xc6,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xeb, 0xd4, 0x80, 0x6d, 0x81, 0x25, 0x49, 0x89, 0xfa, 0xdb, 0xa8, 0xcd, 0x58, 0x96,
+                0x7d, 0x6f, 0xd8, 0x73, 0x83, 0xbc, 0x09, 0x38, 0x63, 0xd5, 0xab, 0xfc, 0xdd, 0xd3,
+                0x8f, 0x15, 0x39, 0xfa, 0xb7, 0xe5, 0xd4, 0xf0, 0x61, 0x91, 0x67, 0xb8, 0xd4, 0x82,
+                0xcb, 0x54, 0x8c, 0xb5, 0x59, 0x83, 0x49, 0x6f, 0x77, 0xd3, 0xdc, 0xaf, 0xf5, 0x6e,
+                0x32, 0x41, 0x0b, 0xfe, 0xc1, 0xf2, 0x68, 0x11,
+            ],
+            ovk: [
+                0xb2, 0x5f, 0x30, 0x3f, 0x58, 0x15, 0xc4, 0x53, 0x31, 0x24, 0xac, 0xf9, 0xd1, 0x89,
+                0x40, 0xe7, 0x75, 0x22, 0xac, 0x5d, 0xc4, 0xb9, 0x57, 0x0a, 0xae, 0x8f, 0x47, 0xb7,
+                0xf5, 0x7f, 0xd8, 0x76,
+            ],
+            default_d: [
+                0x1c, 0xa7, 0xb6, 0x49, 0x39, 0x9e, 0x13, 0xe4, 0x39, 0x44, 0x62,
+            ],
+            default_pk_d: [
+                0x3f, 0xeb, 0x34, 0x5a, 0xec, 0xd3, 0x42, 0x9a, 0x16, 0xe1, 0x0f, 0x3d, 0x13, 0x20,
+                0xbc, 0x99, 0x71, 0xb5, 0x9e, 0x63, 0x9d, 0x62, 0xb6, 0x96, 0x1a, 0xea, 0x78, 0x15,
+                0x67, 0xa8, 0x60, 0x9e,
+            ],
+            v: 9624581763228770449,
+            rseed: [
+                0x4a, 0x95, 0xb2, 0x05, 0x52, 0x6c, 0xfc, 0xb4, 0xc4, 0xe1, 0xcc, 0x95, 0x51, 0x75,
+                0xb3, 0xe8, 0xde, 0x1f, 0x5d, 0x81, 0xb1, 0x86, 0x69, 0x69, 0x23, 0x50, 0xaa, 0xa1,
+                0xa1, 0xd7, 0x97, 0x61,
+            ],
+            asset: [
+                0x67, 0x43, 0xf9, 0x3a, 0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3,
+                0x04, 0xfe, 0x32, 0xb2, 0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e,
+                0x7a, 0x59, 0x70, 0x2f,
+            ],
+            memo: [
+                0xff, 0x75, 0x82, 0xe5, 0x4d, 0x7a, 0x5b, 0x57, 0xa6, 0x83, 0xb3, 0x2f, 0xb1, 0x09,
+                0x80, 0x62, 0xda, 0xd7, 0xb0, 0xc2, 0xeb, 0x51, 0x8f, 0x68, 0x62, 0xe8, 0x3d, 0xb2,
+                0x5e, 0x3d, 0xba, 0xf7, 0xae, 0xd5, 0x04, 0xde, 0x93, 0x2a, 0xcb, 0x99, 0xd7, 0x35,
+                0x99, 0x2c, 0xe6, 0x2b, 0xae, 0x9e, 0xf8, 0x93, 0xff, 0x6a, 0xcc, 0x0f, 0xfc, 0xf8,
+                0xe3, 0x48, 0x3e, 0x14, 0x6b, 0x9d, 0x49, 0xdd, 0x8c, 0x78, 0x35, 0xf4, 0x3a, 0x37,
+                0xdc, 0xa0, 0x78, 0x7e, 0x3e, 0xc9, 0xf6, 0x60, 0x52, 0x23, 0xd5, 0xba, 0x7a, 0xe0,
+                0xab, 0x90, 0x25, 0xb7, 0x3b, 0xc0, 0x3f, 0x7f, 0xac, 0x36, 0xc0, 0x09, 0xa5, 0x6d,
+                0x4d, 0x95, 0xd1, 0xe8, 0x1d, 0x3b, 0x3e, 0xbc, 0xa7, 0xe5, 0x4c, 0xc1, 0xa1, 0x2d,
+                0x12, 0x7b, 0x57, 0xc8, 0x13, 0x89, 0x76, 0xe7, 0x91, 0x01, 0x3b, 0x01, 0x5f, 0x06,
+                0xa6, 0x24, 0xf5, 0x21, 0xb6, 0xee, 0x04, 0xec, 0x98, 0x08, 0x93, 0xc7, 0xe5, 0xe0,
+                0x1a, 0x33, 0x62, 0x03, 0x59, 0x40, 0x94, 0xf8, 0x28, 0x33, 0xd7, 0x44, 0x5f, 0xe2,
+                0xd0, 0x91, 0x30, 0xf6, 0x35, 0x11, 0xda, 0x54, 0x83, 0x2d, 0xe9, 0x13, 0x6b, 0x39,
+                0xf4, 0x59, 0x9f, 0x5a, 0xa5, 0xdf, 0xbb, 0x45, 0xda, 0x60, 0xcd, 0xce, 0xab, 0x7e,
+                0xef, 0xde, 0x89, 0xbe, 0x63, 0xf3, 0xf7, 0xc0, 0xd2, 0x32, 0x48, 0x47, 0xcc, 0xe1,
+                0x40, 0x5d, 0xef, 0x7c, 0x46, 0x9b, 0x0e, 0x27, 0x24, 0x94, 0xe5, 0xdf, 0x54, 0xf5,
+                0x68, 0x65, 0x6c, 0xb9, 0xc8, 0x81, 0x8d, 0x92, 0xb7, 0x2b, 0x8b, 0xc3, 0x4d, 0xb7,
+                0xbb, 0x31, 0x12, 0x48, 0x7e, 0x74, 0x6e, 0xef, 0xe4, 0xe8, 0x08, 0xbb, 0xb2, 0x87,
+                0xd9, 0x9b, 0xf0, 0x7d, 0x00, 0xda, 0xbe, 0xde, 0xdc, 0x5e, 0x5f, 0x07, 0x4f, 0xfe,
+                0xae, 0x0c, 0xba, 0x7d, 0xa3, 0xa5, 0x16, 0xc1, 0x73, 0xbe, 0x1c, 0x51, 0x33, 0x23,
+                0xe1, 0x19, 0xf6, 0x35, 0xe8, 0x20, 0x9a, 0x07, 0x4b, 0x21, 0x6b, 0x70, 0x23, 0xfa,
+                0xdc, 0x2d, 0x25, 0x94, 0x9c, 0x90, 0x03, 0x7e, 0x71, 0xe3, 0xe5, 0x50, 0x72, 0x6d,
+                0x21, 0x0a, 0x2c, 0x68, 0x83, 0x42, 0xe5, 0x24, 0x40, 0x63, 0x5e, 0x9c, 0xc1, 0x4a,
+                0xfe, 0x10, 0x10, 0x26, 0x21, 0xa9, 0xc9, 0xac, 0xcb, 0x78, 0x2e, 0x9e, 0x4a, 0x5f,
+                0xa8, 0x7f, 0x0a, 0x95, 0x6f, 0x5b, 0x85, 0x50, 0x99, 0x60, 0x28, 0x5c, 0x22, 0x62,
+                0x7c, 0x59, 0x48, 0x3a, 0x5a, 0x4c, 0x28, 0xcc, 0xe4, 0xb1, 0x56, 0xe5, 0x51, 0x40,
+                0x6a, 0x7e, 0xe8, 0x35, 0x56, 0x56, 0xa2, 0x1e, 0x43, 0xe3, 0x8c, 0xe1, 0x29, 0xfd,
+                0xad, 0xb7, 0x59, 0xed, 0xdf, 0xa0, 0x8f, 0x00, 0xfc, 0x8e, 0x56, 0x7c, 0xef, 0x93,
+                0xc6, 0x79, 0x2d, 0x01, 0xdf, 0x05, 0xe6, 0xd5, 0x80, 0xf4, 0xd5, 0xd4, 0x8d, 0xf0,
+                0x42, 0x45, 0x1a, 0x33, 0x59, 0x0d, 0x3e, 0x8c, 0xf4, 0x9b, 0x26, 0x27, 0x21, 0x8f,
+                0x0c, 0x29, 0x2f, 0xa6, 0x6a, 0xda, 0x94, 0x5f, 0xa5, 0x5b, 0xb2, 0x35, 0x48, 0xe3,
+                0x3a, 0x83, 0xa5, 0x62, 0x95, 0x7a, 0x31, 0x49, 0xa9, 0x93, 0xcc, 0x47, 0x23, 0x62,
+                0x29, 0x87, 0x36, 0xa8, 0xb7, 0x78, 0xd9, 0x7c, 0xe4, 0x23, 0x01, 0x3d, 0x64, 0xb3,
+                0x2c, 0xd1, 0x72, 0xef, 0xa5, 0x51, 0xbf, 0x7f, 0x36, 0x8f, 0x04, 0xbd, 0xae, 0xc6,
+                0x09, 0x1a, 0x30, 0x04, 0xa7, 0x57, 0x59, 0x8b, 0x80, 0x1d, 0xcf, 0x67, 0x5c, 0xb8,
+                0x3e, 0x43, 0xa5, 0x3a, 0xe8, 0xb2, 0x54, 0xd3, 0x33, 0xbc, 0xda, 0x20, 0xd4, 0x81,
+                0x7d, 0x34, 0x77, 0xab, 0xfb, 0xa2, 0x5b, 0xb8, 0x3d, 0xf5, 0x94, 0x9c, 0x12, 0x6f,
+                0x14, 0x9b, 0x1d, 0x99, 0x34, 0x1e, 0x4e, 0x6f,
+            ],
+            cv_net: [
+                0xd2, 0xf9, 0xad, 0xff, 0x53, 0x1b, 0x65, 0x43, 0x2b, 0xa2, 0xd7, 0xda, 0xa6, 0xd8,
+                0x6e, 0x62, 0xe4, 0xed, 0xc7, 0x86, 0xd9, 0xe0, 0xb2, 0x7d, 0x26, 0x62, 0x8b, 0x79,
+                0xda, 0x6b, 0x15, 0x14,
+            ],
+            rho: [
+                0x9a, 0x09, 0xe4, 0x72, 0xe8, 0xe9, 0x96, 0xfc, 0xc3, 0x0e, 0xd5, 0x23, 0x72, 0x08,
+                0xdb, 0xb0, 0x01, 0x71, 0x32, 0x0e, 0x6b, 0xea, 0x43, 0x91, 0x86, 0x00, 0x9d, 0xad,
+                0x21, 0x38, 0xab, 0x29,
+            ],
+            cmx: [
+                0x18, 0xfc, 0xbd, 0x40, 0xac, 0xf1, 0xa7, 0xf4, 0xd6, 0x09, 0x87, 0x9a, 0x5f, 0x5e,
+                0x3b, 0x39, 0x70, 0x09, 0x4f, 0xf8, 0xbe, 0x84, 0x18, 0x60, 0x70, 0x16, 0xc6, 0xa6,
+                0x97, 0xf8, 0x9c, 0x20,
+            ],
+            esk: [
+                0x3b, 0xc1, 0x7a, 0x58, 0x0d, 0x53, 0x0f, 0x89, 0x30, 0xa3, 0x6b, 0x8d, 0x6f, 0xea,
+                0x67, 0x85, 0x7f, 0x7b, 0x85, 0x20, 0xfd, 0x2e, 0x0a, 0xb5, 0xd5, 0xcb, 0xab, 0x1a,
+                0xcc, 0xd5, 0x4e, 0x3a,
+            ],
+            ephemeral_key: [
+                0xcf, 0xe0, 0x3e, 0xb2, 0xd3, 0x36, 0x76, 0xb7, 0x73, 0x83, 0x7d, 0xa8, 0x39, 0x17,
+                0x2d, 0x33, 0x33, 0x31, 0x88, 0xc9, 0xdf, 0xef, 0x05, 0xc8, 0x32, 0xa2, 0x5c, 0x86,
+                0xd3, 0xbf, 0x0e, 0x8f,
+            ],
+            shared_secret: [
+                0xd2, 0xc2, 0x88, 0x9e, 0x03, 0x7e, 0xac, 0x60, 0x60, 0x58, 0x68, 0x2b, 0xaa, 0x38,
+                0x86, 0xa4, 0xc2, 0xdd, 0x44, 0xea, 0xdf, 0x8b, 0x2c, 0xe4, 0x39, 0x95, 0xde, 0xd7,
+                0x61, 0xfd, 0xaf, 0xb5,
+            ],
+            k_enc: [
+                0xfe, 0xe3, 0xe3, 0xb5, 0xfd, 0x6c, 0xd8, 0x54, 0x44, 0x2b, 0x2a, 0xc2, 0x97, 0x70,
+                0xfb, 0x0e, 0x39, 0x32, 0xf4, 0x71, 0x52, 0x43, 0x26, 0xda, 0x4a, 0x57, 0xc2, 0x56,
+                0x18, 0x06, 0x9e, 0x99,
+            ],
+            p_enc: [
+                0x03, 0x1c, 0xa7, 0xb6, 0x49, 0x39, 0x9e, 0x13, 0xe4, 0x39, 0x44, 0x62, 0x91, 0x20,
+                0xf4, 0xd4, 0x1e, 0x62, 0x91, 0x85, 0x4a, 0x95, 0xb2, 0x05, 0x52, 0x6c, 0xfc, 0xb4,
+                0xc4, 0xe1, 0xcc, 0x95, 0x51, 0x75, 0xb3, 0xe8, 0xde, 0x1f, 0x5d, 0x81, 0xb1, 0x86,
+                0x69, 0x69, 0x23, 0x50, 0xaa, 0xa1, 0xa1, 0xd7, 0x97, 0x61, 0x67, 0x43, 0xf9, 0x3a,
+                0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3, 0x04, 0xfe, 0x32, 0xb2,
+                0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e, 0x7a, 0x59, 0x70, 0x2f,
+                0xff, 0x75, 0x82, 0xe5, 0x4d, 0x7a, 0x5b, 0x57, 0xa6, 0x83, 0xb3, 0x2f, 0xb1, 0x09,
+                0x80, 0x62, 0xda, 0xd7, 0xb0, 0xc2, 0xeb, 0x51, 0x8f, 0x68, 0x62, 0xe8, 0x3d, 0xb2,
+                0x5e, 0x3d, 0xba, 0xf7, 0xae, 0xd5, 0x04, 0xde, 0x93, 0x2a, 0xcb, 0x99, 0xd7, 0x35,
+                0x99, 0x2c, 0xe6, 0x2b, 0xae, 0x9e, 0xf8, 0x93, 0xff, 0x6a, 0xcc, 0x0f, 0xfc, 0xf8,
+                0xe3, 0x48, 0x3e, 0x14, 0x6b, 0x9d, 0x49, 0xdd, 0x8c, 0x78, 0x35, 0xf4, 0x3a, 0x37,
+                0xdc, 0xa0, 0x78, 0x7e, 0x3e, 0xc9, 0xf6, 0x60, 0x52, 0x23, 0xd5, 0xba, 0x7a, 0xe0,
+                0xab, 0x90, 0x25, 0xb7, 0x3b, 0xc0, 0x3f, 0x7f, 0xac, 0x36, 0xc0, 0x09, 0xa5, 0x6d,
+                0x4d, 0x95, 0xd1, 0xe8, 0x1d, 0x3b, 0x3e, 0xbc, 0xa7, 0xe5, 0x4c, 0xc1, 0xa1, 0x2d,
+                0x12, 0x7b, 0x57, 0xc8, 0x13, 0x89, 0x76, 0xe7, 0x91, 0x01, 0x3b, 0x01, 0x5f, 0x06,
+                0xa6, 0x24, 0xf5, 0x21, 0xb6, 0xee, 0x04, 0xec, 0x98, 0x08, 0x93, 0xc7, 0xe5, 0xe0,
+                0x1a, 0x33, 0x62, 0x03, 0x59, 0x40, 0x94, 0xf8, 0x28, 0x33, 0xd7, 0x44, 0x5f, 0xe2,
+                0xd0, 0x91, 0x30, 0xf6, 0x35, 0x11, 0xda, 0x54, 0x83, 0x2d, 0xe9, 0x13, 0x6b, 0x39,
+                0xf4, 0x59, 0x9f, 0x5a, 0xa5, 0xdf, 0xbb, 0x45, 0xda, 0x60, 0xcd, 0xce, 0xab, 0x7e,
+                0xef, 0xde, 0x89, 0xbe, 0x63, 0xf3, 0xf7, 0xc0, 0xd2, 0x32, 0x48, 0x47, 0xcc, 0xe1,
+                0x40, 0x5d, 0xef, 0x7c, 0x46, 0x9b, 0x0e, 0x27, 0x24, 0x94, 0xe5, 0xdf, 0x54, 0xf5,
+                0x68, 0x65, 0x6c, 0xb9, 0xc8, 0x81, 0x8d, 0x92, 0xb7, 0x2b, 0x8b, 0xc3, 0x4d, 0xb7,
+                0xbb, 0x31, 0x12, 0x48, 0x7e, 0x74, 0x6e, 0xef, 0xe4, 0xe8, 0x08, 0xbb, 0xb2, 0x87,
+                0xd9, 0x9b, 0xf0, 0x7d, 0x00, 0xda, 0xbe, 0xde, 0xdc, 0x5e, 0x5f, 0x07, 0x4f, 0xfe,
+                0xae, 0x0c, 0xba, 0x7d, 0xa3, 0xa5, 0x16, 0xc1, 0x73, 0xbe, 0x1c, 0x51, 0x33, 0x23,
+                0xe1, 0x19, 0xf6, 0x35, 0xe8, 0x20, 0x9a, 0x07, 0x4b, 0x21, 0x6b, 0x70, 0x23, 0xfa,
+                0xdc, 0x2d, 0x25, 0x94, 0x9c, 0x90, 0x03, 0x7e, 0x71, 0xe3, 0xe5, 0x50, 0x72, 0x6d,
+                0x21, 0x0a, 0x2c, 0x68, 0x83, 0x42, 0xe5, 0x24, 0x40, 0x63, 0x5e, 0x9c, 0xc1, 0x4a,
+                0xfe, 0x10, 0x10, 0x26, 0x21, 0xa9, 0xc9, 0xac, 0xcb, 0x78, 0x2e, 0x9e, 0x4a, 0x5f,
+                0xa8, 0x7f, 0x0a, 0x95, 0x6f, 0x5b, 0x85, 0x50, 0x99, 0x60, 0x28, 0x5c, 0x22, 0x62,
+                0x7c, 0x59, 0x48, 0x3a, 0x5a, 0x4c, 0x28, 0xcc, 0xe4, 0xb1, 0x56, 0xe5, 0x51, 0x40,
+                0x6a, 0x7e, 0xe8, 0x35, 0x56, 0x56, 0xa2, 0x1e, 0x43, 0xe3, 0x8c, 0xe1, 0x29, 0xfd,
+                0xad, 0xb7, 0x59, 0xed, 0xdf, 0xa0, 0x8f, 0x00, 0xfc, 0x8e, 0x56, 0x7c, 0xef, 0x93,
+                0xc6, 0x79, 0x2d, 0x01, 0xdf, 0x05, 0xe6, 0xd5, 0x80, 0xf4, 0xd5, 0xd4, 0x8d, 0xf0,
+                0x42, 0x45, 0x1a, 0x33, 0x59, 0x0d, 0x3e, 0x8c, 0xf4, 0x9b, 0x26, 0x27, 0x21, 0x8f,
+                0x0c, 0x29, 0x2f, 0xa6, 0x6a, 0xda, 0x94, 0x5f, 0xa5, 0x5b, 0xb2, 0x35, 0x48, 0xe3,
+                0x3a, 0x83, 0xa5, 0x62, 0x95, 0x7a, 0x31, 0x49, 0xa9, 0x93, 0xcc, 0x47, 0x23, 0x62,
+                0x29, 0x87, 0x36, 0xa8, 0xb7, 0x78, 0xd9, 0x7c, 0xe4, 0x23, 0x01, 0x3d, 0x64, 0xb3,
+                0x2c, 0xd1, 0x72, 0xef, 0xa5, 0x51, 0xbf, 0x7f, 0x36, 0x8f, 0x04, 0xbd, 0xae, 0xc6,
+                0x09, 0x1a, 0x30, 0x04, 0xa7, 0x57, 0x59, 0x8b, 0x80, 0x1d, 0xcf, 0x67, 0x5c, 0xb8,
+                0x3e, 0x43, 0xa5, 0x3a, 0xe8, 0xb2, 0x54, 0xd3, 0x33, 0xbc, 0xda, 0x20, 0xd4, 0x81,
+                0x7d, 0x34, 0x77, 0xab, 0xfb, 0xa2, 0x5b, 0xb8, 0x3d, 0xf5, 0x94, 0x9c, 0x12, 0x6f,
+                0x14, 0x9b, 0x1d, 0x99, 0x34, 0x1e, 0x4e, 0x6f,
+            ],
+            c_enc: [
+                0xbf, 0x1d, 0xff, 0xd3, 0x37, 0x0c, 0x67, 0x56, 0x69, 0xcc, 0x9a, 0xe1, 0xd0, 0x30,
+                0x2d, 0x7f, 0x90, 0x6d, 0x25, 0x23, 0x09, 0x3c, 0x24, 0xf4, 0x25, 0x7a, 0x83, 0xbc,
+                0x4f, 0x36, 0x62, 0x3a, 0x08, 0x2c, 0xe6, 0xeb, 0x45, 0x21, 0x95, 0x71, 0x91, 0xd5,
+                0x7e, 0x14, 0x11, 0xed, 0xe7, 0x1d, 0x44, 0xb5, 0x6c, 0x57, 0x53, 0x14, 0xfa, 0x95,
+                0x27, 0xae, 0xc5, 0xaf, 0xd5, 0x06, 0xc2, 0x42, 0xac, 0xdc, 0xa9, 0xd3, 0xc9, 0xa5,
+                0x53, 0xcf, 0xef, 0x49, 0x9e, 0x87, 0x30, 0xf7, 0x55, 0x6a, 0xd0, 0xba, 0xc0, 0xff,
+                0xb6, 0xd0, 0x8e, 0x7c, 0xac, 0x9b, 0x6e, 0x71, 0xf6, 0x6d, 0x19, 0x17, 0xfc, 0x52,
+                0xdc, 0x91, 0x33, 0xae, 0x12, 0x4a, 0x40, 0x9d, 0xda, 0x38, 0x75, 0xcb, 0xae, 0xb5,
+                0xf2, 0x96, 0xd5, 0x3a, 0x9f, 0x17, 0xb0, 0x28, 0x7d, 0xaa, 0x31, 0xd6, 0x89, 0xa7,
+                0xde, 0xaf, 0x05, 0x2d, 0xab, 0xa6, 0xd0, 0xe8, 0x87, 0xcd, 0x1a, 0x3a, 0x6d, 0xd4,
+                0x67, 0x17, 0xe5, 0xda, 0x63, 0xe5, 0x59, 0x67, 0x95, 0xf8, 0xe1, 0xdb, 0x6a, 0x45,
+                0x8e, 0xab, 0x64, 0xa7, 0xd0, 0x68, 0xe1, 0x67, 0xef, 0xf1, 0x9b, 0xf2, 0x3b, 0x1b,
+                0xe7, 0x72, 0x87, 0xf9, 0x0e, 0xe5, 0xcd, 0x34, 0x13, 0x85, 0xad, 0xc9, 0xda, 0xb7,
+                0xd0, 0xef, 0x05, 0xc3, 0x61, 0x7d, 0x9f, 0x4b, 0xd7, 0xa2, 0x78, 0xb0, 0xa7, 0xc7,
+                0x57, 0x73, 0x57, 0x89, 0xd3, 0xff, 0x0e, 0x91, 0xfb, 0xe1, 0x31, 0x78, 0xae, 0x76,
+                0xeb, 0x91, 0xd8, 0x35, 0xd0, 0x65, 0xd7, 0xb3, 0x83, 0x18, 0xf5, 0x64, 0xb7, 0x69,
+                0xe8, 0xd9, 0x68, 0x97, 0xb7, 0xab, 0xc8, 0xaa, 0xf3, 0x41, 0x7a, 0x49, 0xe6, 0x8f,
+                0x35, 0xcd, 0x7f, 0x45, 0x1d, 0x99, 0x4a, 0xd8, 0x7d, 0xd4, 0xbc, 0x55, 0xc4, 0x5d,
+                0xb3, 0x21, 0xf8, 0x49, 0xce, 0xb9, 0x54, 0x30, 0xe8, 0xe6, 0xe2, 0xe4, 0x8c, 0x3b,
+                0xbf, 0x8f, 0x7a, 0x1a, 0xaf, 0x1c, 0x52, 0xf2, 0x3f, 0xca, 0x52, 0xca, 0xcc, 0xfb,
+                0x26, 0xa4, 0x58, 0x40, 0x42, 0x73, 0xe5, 0x69, 0x7f, 0xcc, 0xf5, 0xa5, 0x9a, 0x61,
+                0xb3, 0xea, 0xd6, 0x6a, 0x03, 0xfd, 0xaf, 0x31, 0xb2, 0xeb, 0x2d, 0x32, 0xa9, 0x02,
+                0x40, 0x50, 0x98, 0xa7, 0x67, 0xbb, 0x6d, 0x30, 0xbf, 0x1b, 0x48, 0x7d, 0xcc, 0x5d,
+                0x38, 0xfb, 0x9d, 0x54, 0x9c, 0xc5, 0x21, 0x30, 0x75, 0xe1, 0x2d, 0x04, 0x34, 0x71,
+                0xc3, 0xab, 0x03, 0x5b, 0x1d, 0xff, 0xd6, 0xe8, 0xaa, 0x61, 0x99, 0xc8, 0x0c, 0xe9,
+                0x9d, 0x66, 0xa5, 0x07, 0x3b, 0x91, 0x73, 0xc3, 0x25, 0x4b, 0xd2, 0x4a, 0xf5, 0x9c,
+                0x96, 0x27, 0xb9, 0x8c, 0xdb, 0x06, 0x0f, 0x07, 0x34, 0x04, 0xb4, 0xfb, 0xf6, 0x5b,
+                0xdd, 0x1a, 0xcb, 0x1c, 0xb6, 0xc0, 0xa4, 0xc1, 0x8d, 0x55, 0x4f, 0x7a, 0x4c, 0x5a,
+                0x1a, 0x93, 0x94, 0xb3, 0x85, 0xe8, 0xdf, 0xf4, 0xbb, 0xd1, 0x4a, 0x1a, 0x20, 0x1f,
+                0xa8, 0x33, 0x20, 0x37, 0x34, 0x5a, 0x62, 0x29, 0x3d, 0x8c, 0xfc, 0x5c, 0xd9, 0x4c,
+                0x0c, 0x21, 0xa9, 0xc8, 0x06, 0x52, 0x1c, 0xe2, 0x28, 0x01, 0xdb, 0xa5, 0xb5, 0xa3,
+                0xb3, 0xf6, 0x9a, 0xbd, 0x01, 0xd4, 0x4c, 0xcb, 0xc2, 0x3b, 0x06, 0x3f, 0x41, 0x2c,
+                0xa1, 0xa9, 0xd4, 0xfd, 0x17, 0xda, 0xbe, 0x54, 0x9f, 0x8b, 0x89, 0x11, 0x21, 0xe0,
+                0x79, 0xb8, 0x2b, 0x5e, 0x6e, 0xa7, 0x43, 0xe6, 0x37, 0xb9, 0xd2, 0xd1, 0x1e, 0x86,
+                0xa0, 0xc2, 0x76, 0x9a, 0xe3, 0xdc, 0xde, 0xcd, 0x74, 0xcb, 0xec, 0xe5, 0x6e, 0x52,
+                0x74, 0xca, 0x1f, 0x23, 0x25, 0xc3, 0x93, 0xe5, 0xef, 0x18, 0xef, 0x99, 0x03, 0x04,
+                0x22, 0x39, 0xe2, 0x5c, 0x2f, 0x10, 0x62, 0x21, 0x2a, 0x04, 0x67, 0x0d, 0xd3, 0xea,
+                0xd5, 0xa9, 0x55, 0xf7, 0x8b, 0x6a, 0x00, 0xdd, 0x9f, 0x12, 0xc1, 0xdc, 0x0b, 0x3a,
+                0x58, 0xaf, 0x82, 0x3b, 0x78, 0x73, 0x22, 0xaa, 0x8f, 0x2e, 0xde, 0xc8, 0x48, 0x41,
+                0x99, 0x15, 0xb0, 0x6b, 0x60, 0xd9, 0x5a, 0xf2, 0xd4, 0x41, 0xba, 0xd4, 0x35, 0x7b,
+                0xed, 0x8a, 0xdb, 0xf0, 0xd0, 0x5f, 0xc6, 0x37, 0xcb, 0xaa, 0xff, 0x15, 0x58, 0x26,
+                0x8c, 0x9c, 0x92, 0x41, 0x9e, 0x97, 0x51, 0xc4, 0x18, 0xa6, 0x7a, 0xe3, 0x86, 0x29,
+                0xf0, 0xcd, 0xf7, 0x7d, 0xaa, 0xd6, 0xf0, 0xac, 0xc9, 0x32, 0x98, 0x51, 0xcd, 0x17,
+                0xda, 0x6a, 0xd7, 0xbb, 0x73, 0xf3, 0x5d, 0x23, 0xba, 0xc7,
+            ],
+            ock: [
+                0xeb, 0x3e, 0xd9, 0xfc, 0xb3, 0xaa, 0x91, 0xc4, 0xf5, 0xec, 0xfd, 0x43, 0xdb, 0xda,
+                0x40, 0x33, 0x06, 0x93, 0xc3, 0xa6, 0x56, 0x75, 0x45, 0xfd, 0x23, 0x6a, 0xf1, 0x90,
+                0x8e, 0x29, 0x42, 0xa3,
+            ],
+            op: [
+                0x3f, 0xeb, 0x34, 0x5a, 0xec, 0xd3, 0x42, 0x9a, 0x16, 0xe1, 0x0f, 0x3d, 0x13, 0x20,
+                0xbc, 0x99, 0x71, 0xb5, 0x9e, 0x63, 0x9d, 0x62, 0xb6, 0x96, 0x1a, 0xea, 0x78, 0x15,
+                0x67, 0xa8, 0x60, 0x9e, 0x3b, 0xc1, 0x7a, 0x58, 0x0d, 0x53, 0x0f, 0x89, 0x30, 0xa3,
+                0x6b, 0x8d, 0x6f, 0xea, 0x67, 0x85, 0x7f, 0x7b, 0x85, 0x20, 0xfd, 0x2e, 0x0a, 0xb5,
+                0xd5, 0xcb, 0xab, 0x1a, 0xcc, 0xd5, 0x4e, 0x3a,
+            ],
+            c_out: [
+                0x60, 0xf3, 0xe8, 0x94, 0xe3, 0x86, 0x4e, 0xfb, 0x48, 0xcc, 0xae, 0x50, 0xe1, 0x0d,
+                0xa7, 0x73, 0xdc, 0xcf, 0x85, 0x62, 0x45, 0x5d, 0x1b, 0x73, 0x1a, 0xad, 0x44, 0xe1,
+                0x5e, 0x3e, 0x40, 0x18, 0x31, 0xce, 0x6f, 0x92, 0xf4, 0x53, 0x2d, 0x90, 0x83, 0x92,
+                0x59, 0xce, 0x9c, 0xb1, 0x44, 0x62, 0x1f, 0x12, 0x01, 0x77, 0x8f, 0x61, 0x5d, 0x09,
+                0x87, 0x01, 0x0c, 0x8d, 0x13, 0x5c, 0x32, 0xd5, 0x6e, 0xe2, 0x84, 0x68, 0x65, 0xa2,
+                0x61, 0xde, 0x14, 0x25, 0xd2, 0x3b, 0xcc, 0x51, 0xb8, 0xa0,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xc3, 0x7c, 0x7d, 0xbb, 0xe5, 0x51, 0xd9, 0xd3, 0xb1, 0xa4, 0x96, 0x88, 0x7d, 0xb2,
+                0xe8, 0x42, 0xdc, 0x94, 0x52, 0x01, 0xf4, 0x08, 0x10, 0xdf, 0x4d, 0x76, 0x39, 0x32,
+                0xed, 0x5c, 0x76, 0x39, 0x8b, 0x35, 0x73, 0xfe, 0x23, 0xf1, 0xe8, 0xb7, 0xe7, 0x9f,
+                0x1c, 0x16, 0x95, 0xc0, 0x97, 0xc1, 0x24, 0xff, 0x1f, 0x7d, 0x6e, 0x61, 0xf2, 0xc5,
+                0x8f, 0x14, 0x39, 0xa7, 0x56, 0x96, 0x9d, 0x19,
+            ],
+            ovk: [
+                0xa6, 0x68, 0xa0, 0xae, 0x2b, 0xb9, 0x34, 0xc8, 0x2c, 0x41, 0x42, 0xda, 0x69, 0xd1,
+                0x2c, 0xa7, 0xde, 0x9a, 0x7d, 0xf7, 0x06, 0x40, 0x0e, 0xc7, 0x98, 0x78, 0xd8, 0x68,
+                0xe1, 0x7e, 0x8f, 0x71,
+            ],
+            default_d: [
+                0x56, 0x4f, 0xc3, 0x81, 0xfc, 0x4d, 0xc8, 0x11, 0x8d, 0xe4, 0x7c,
+            ],
+            default_pk_d: [
+                0xae, 0xee, 0xa5, 0x0c, 0x6b, 0xb0, 0x2e, 0x5e, 0x22, 0x4d, 0xc2, 0x95, 0x9c, 0x22,
+                0x9d, 0x0e, 0x3b, 0xb8, 0x79, 0xc4, 0xab, 0x00, 0xaa, 0x0a, 0xb2, 0x5a, 0x40, 0x10,
+                0x6b, 0x80, 0xbb, 0xb7,
+            ],
+            v: 11137853725062838288,
+            rseed: [
+                0x25, 0x37, 0xb8, 0x71, 0xb4, 0x29, 0x4a, 0x65, 0xd3, 0xe0, 0x55, 0xff, 0x71, 0x8d,
+                0xd9, 0xdc, 0x8c, 0x75, 0xe7, 0xe5, 0xb2, 0xef, 0xe4, 0x42, 0x63, 0x73, 0x71, 0xb7,
+                0xc4, 0x8f, 0x6e, 0xe9,
+            ],
+            asset: [
+                0x67, 0x43, 0xf9, 0x3a, 0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3,
+                0x04, 0xfe, 0x32, 0xb2, 0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e,
+                0x7a, 0x59, 0x70, 0x2f,
+            ],
+            memo: [
+                0xff, 0x9e, 0x3e, 0xa3, 0x8a, 0x4b, 0x0f, 0x2f, 0x67, 0xfc, 0x2b, 0x90, 0x8c, 0xda,
+                0x65, 0x7e, 0xae, 0x75, 0x4e, 0x03, 0x7e, 0x26, 0x2e, 0x9a, 0x9f, 0x9b, 0xd7, 0xec,
+                0x42, 0x67, 0xed, 0x8e, 0x96, 0x93, 0x0e, 0x10, 0x84, 0x78, 0x3c, 0x37, 0xd6, 0xf9,
+                0xdd, 0x15, 0xfd, 0x29, 0xf4, 0xcc, 0x47, 0x7e, 0x66, 0xf1, 0x30, 0xd6, 0x30, 0x43,
+                0x0d, 0xcc, 0x01, 0x04, 0x89, 0x9b, 0x4f, 0x9f, 0x46, 0xeb, 0x09, 0x0e, 0xf7, 0xfc,
+                0x90, 0xb4, 0x79, 0xab, 0xf6, 0x1f, 0x93, 0x95, 0x5e, 0xe0, 0x0e, 0x6a, 0x18, 0x48,
+                0xf1, 0xab, 0x14, 0xad, 0x33, 0x4f, 0x2b, 0x68, 0x03, 0x58, 0x08, 0xcd, 0xf1, 0xbb,
+                0x9e, 0x9d, 0x9a, 0x81, 0x6b, 0xaf, 0x72, 0x8a, 0x95, 0x5b, 0x96, 0x0b, 0x77, 0x01,
+                0xfa, 0x62, 0x66, 0x87, 0xdc, 0x3c, 0x9c, 0xba, 0x64, 0x63, 0x37, 0xb5, 0x3e, 0x29,
+                0x81, 0x6e, 0x94, 0x82, 0xdd, 0xf5, 0x57, 0x8a, 0x87, 0x68, 0xaa, 0xe4, 0x77, 0xfc,
+                0xe4, 0x10, 0xac, 0x2d, 0x5d, 0xe6, 0x09, 0x58, 0x61, 0xc1, 0x11, 0xd7, 0xfe, 0xb3,
+                0xe6, 0xbb, 0x4f, 0xbb, 0x5a, 0x54, 0x95, 0x54, 0x95, 0x97, 0x27, 0x98, 0x35, 0x0a,
+                0x25, 0x3f, 0x05, 0xf6, 0x6c, 0x2e, 0xcf, 0xcb, 0xc0, 0xed, 0x43, 0xf5, 0xec, 0x2e,
+                0x6d, 0x8d, 0xba, 0x15, 0xa5, 0x12, 0x54, 0xd9, 0x7b, 0x18, 0x21, 0x10, 0x7c, 0x07,
+                0xdd, 0x9a, 0x16, 0xef, 0x84, 0x06, 0xf9, 0x43, 0xe2, 0x82, 0xb9, 0x5d, 0x4b, 0x36,
+                0x25, 0x30, 0xc9, 0x13, 0xd6, 0xba, 0x42, 0x1d, 0xf6, 0x02, 0x7d, 0xe5, 0xaf, 0x1e,
+                0x47, 0x45, 0xd5, 0x86, 0x81, 0x06, 0x95, 0x4b, 0xe6, 0xc1, 0x96, 0x27, 0x80, 0xa2,
+                0x94, 0x10, 0x72, 0xe9, 0x51, 0x31, 0xb1, 0x67, 0x9d, 0xf0, 0x63, 0x76, 0x25, 0x04,
+                0x2c, 0x37, 0xd4, 0x8f, 0xfb, 0x15, 0x2e, 0x5e, 0xbc, 0x18, 0x5c, 0x8a, 0x2b, 0x7d,
+                0x43, 0x85, 0xf1, 0xc9, 0x5a, 0xf9, 0x37, 0xdf, 0x78, 0xdf, 0xd8, 0x75, 0x7f, 0xab,
+                0x43, 0x49, 0x68, 0xb0, 0xb5, 0x7c, 0x66, 0x57, 0x44, 0x68, 0xf1, 0x60, 0xb4, 0x47,
+                0xac, 0x82, 0x21, 0xe5, 0x06, 0x06, 0x76, 0xa8, 0x42, 0xa1, 0xc6, 0xb7, 0x17, 0x2d,
+                0xd3, 0x34, 0x0f, 0x76, 0x40, 0x70, 0xab, 0x1f, 0xe0, 0x91, 0xc5, 0xc7, 0x4c, 0x95,
+                0xa5, 0xdc, 0x04, 0x33, 0x90, 0x72, 0x3a, 0x4c, 0x12, 0x7d, 0xa1, 0x4c, 0xdd, 0xe1,
+                0xdc, 0x26, 0x75, 0xa6, 0x23, 0x40, 0xb3, 0xe6, 0xaf, 0xd0, 0x52, 0x2a, 0x31, 0xde,
+                0x26, 0xe7, 0xd1, 0xec, 0x3a, 0x9c, 0x8a, 0x09, 0x1f, 0xfd, 0xc7, 0x5b, 0x7e, 0xcf,
+                0xdc, 0x7c, 0x12, 0x99, 0x5a, 0x5e, 0x37, 0xce, 0x34, 0x88, 0xbd, 0x29, 0xf8, 0x62,
+                0x9d, 0x68, 0xf6, 0x96, 0x49, 0x24, 0x48, 0xdd, 0x52, 0x66, 0x97, 0x47, 0x6d, 0xc0,
+                0x61, 0x34, 0x6e, 0xbe, 0x3f, 0x67, 0x72, 0x17, 0xff, 0x9c, 0x60, 0xef, 0xce, 0x94,
+                0x3a, 0xf2, 0x8d, 0xfd, 0x3f, 0x9e, 0x59, 0x69, 0x25, 0x98, 0xa6, 0x04, 0x7c, 0x23,
+                0xc4, 0xc0, 0x14, 0x00, 0xf1, 0xab, 0x57, 0x30, 0xea, 0xc0, 0xae, 0x8d, 0x58, 0x43,
+                0xd5, 0x05, 0x1c, 0x37, 0x62, 0x40, 0x17, 0x2a, 0xf2, 0x18, 0xd7, 0xa1, 0xec, 0xfe,
+                0x65, 0xb4, 0xf7, 0x51, 0x00, 0x63, 0x89, 0x83, 0xc1, 0x4d, 0xe4, 0x97, 0x47, 0x55,
+                0xda, 0xde, 0x80, 0x18, 0xc9, 0xb8, 0xf4, 0x54, 0x3f, 0xb0, 0x95, 0x96, 0x15, 0x13,
+                0xe6, 0x7c, 0x61, 0xdb, 0xc5, 0x9c, 0x60, 0x7f, 0x9b, 0x51, 0xf8, 0xd0, 0x9b, 0xdc,
+                0xad, 0x28, 0xbc, 0xfb, 0x9e, 0x5d, 0x27, 0x44, 0xea, 0x88, 0x48, 0xb2, 0x62, 0x3a,
+                0xc0, 0x7f, 0x8e, 0xf6, 0x1a, 0x81, 0xa3, 0x59,
+            ],
+            cv_net: [
+                0xb2, 0x7f, 0x48, 0x59, 0x15, 0x0d, 0x48, 0x45, 0xab, 0x57, 0x78, 0x82, 0x61, 0x50,
+                0x0a, 0x12, 0x01, 0x2d, 0x63, 0xc0, 0x09, 0xc6, 0x77, 0x44, 0xba, 0xe0, 0xd5, 0x83,
+                0x88, 0xff, 0xee, 0x2f,
+            ],
+            rho: [
+                0x54, 0x3e, 0xa7, 0x11, 0x56, 0xc9, 0xa6, 0xf8, 0x04, 0x1f, 0xa7, 0x7e, 0xc1, 0xc5,
+                0xaf, 0x90, 0x28, 0x8f, 0x27, 0x20, 0xf1, 0x3f, 0xf0, 0x93, 0xc6, 0x86, 0x26, 0x6b,
+                0x92, 0xd7, 0xa0, 0x24,
+            ],
+            cmx: [
+                0x1d, 0x51, 0xea, 0x92, 0xfa, 0x43, 0x55, 0x0a, 0x0e, 0xdd, 0xea, 0x23, 0x6e, 0x17,
+                0xa0, 0x16, 0x93, 0xc2, 0x2d, 0x8d, 0xd8, 0x1c, 0x9c, 0x9e, 0xc8, 0x76, 0xa2, 0x4e,
+                0x67, 0xd4, 0x93, 0x0b,
+            ],
+            esk: [
+                0x19, 0xe0, 0x26, 0x4b, 0x82, 0x88, 0xf7, 0x3e, 0xbf, 0x97, 0x14, 0xb0, 0xdf, 0x85,
+                0x8e, 0xf7, 0xab, 0x39, 0xec, 0x50, 0x2c, 0xd2, 0x98, 0xf2, 0xc4, 0x84, 0xa9, 0xf4,
+                0xc7, 0xda, 0x74, 0x36,
+            ],
+            ephemeral_key: [
+                0x8f, 0xbe, 0xb6, 0xb3, 0x03, 0x8e, 0x69, 0x49, 0x91, 0x6a, 0x2c, 0x06, 0x0e, 0xf9,
+                0xa4, 0xb1, 0xfe, 0xf1, 0x3a, 0xce, 0x2f, 0xee, 0x00, 0x25, 0xda, 0x32, 0xc3, 0x6d,
+                0x23, 0x1a, 0x61, 0x34,
+            ],
+            shared_secret: [
+                0x67, 0xd6, 0x8a, 0x5a, 0x05, 0x93, 0xfd, 0x16, 0x7d, 0x38, 0x08, 0x2e, 0x49, 0xd2,
+                0x30, 0x30, 0x86, 0xe5, 0x5a, 0x43, 0xc1, 0x24, 0xd5, 0xaa, 0xa8, 0x20, 0xab, 0x0c,
+                0x3f, 0x5c, 0xc5, 0x37,
+            ],
+            k_enc: [
+                0x6b, 0x8d, 0x83, 0xf2, 0xf1, 0xfd, 0x1e, 0xad, 0x7d, 0x45, 0x42, 0xb3, 0x63, 0x09,
+                0x34, 0x07, 0xc5, 0x0a, 0x20, 0xed, 0x7f, 0x0e, 0x8c, 0xf2, 0xdb, 0x53, 0x6d, 0xb1,
+                0xbe, 0x25, 0xe9, 0x8d,
+            ],
+            p_enc: [
+                0x03, 0x56, 0x4f, 0xc3, 0x81, 0xfc, 0x4d, 0xc8, 0x11, 0x8d, 0xe4, 0x7c, 0x10, 0xb8,
+                0xa1, 0xba, 0xf3, 0x9a, 0x91, 0x9a, 0x25, 0x37, 0xb8, 0x71, 0xb4, 0x29, 0x4a, 0x65,
+                0xd3, 0xe0, 0x55, 0xff, 0x71, 0x8d, 0xd9, 0xdc, 0x8c, 0x75, 0xe7, 0xe5, 0xb2, 0xef,
+                0xe4, 0x42, 0x63, 0x73, 0x71, 0xb7, 0xc4, 0x8f, 0x6e, 0xe9, 0x67, 0x43, 0xf9, 0x3a,
+                0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3, 0x04, 0xfe, 0x32, 0xb2,
+                0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e, 0x7a, 0x59, 0x70, 0x2f,
+                0xff, 0x9e, 0x3e, 0xa3, 0x8a, 0x4b, 0x0f, 0x2f, 0x67, 0xfc, 0x2b, 0x90, 0x8c, 0xda,
+                0x65, 0x7e, 0xae, 0x75, 0x4e, 0x03, 0x7e, 0x26, 0x2e, 0x9a, 0x9f, 0x9b, 0xd7, 0xec,
+                0x42, 0x67, 0xed, 0x8e, 0x96, 0x93, 0x0e, 0x10, 0x84, 0x78, 0x3c, 0x37, 0xd6, 0xf9,
+                0xdd, 0x15, 0xfd, 0x29, 0xf4, 0xcc, 0x47, 0x7e, 0x66, 0xf1, 0x30, 0xd6, 0x30, 0x43,
+                0x0d, 0xcc, 0x01, 0x04, 0x89, 0x9b, 0x4f, 0x9f, 0x46, 0xeb, 0x09, 0x0e, 0xf7, 0xfc,
+                0x90, 0xb4, 0x79, 0xab, 0xf6, 0x1f, 0x93, 0x95, 0x5e, 0xe0, 0x0e, 0x6a, 0x18, 0x48,
+                0xf1, 0xab, 0x14, 0xad, 0x33, 0x4f, 0x2b, 0x68, 0x03, 0x58, 0x08, 0xcd, 0xf1, 0xbb,
+                0x9e, 0x9d, 0x9a, 0x81, 0x6b, 0xaf, 0x72, 0x8a, 0x95, 0x5b, 0x96, 0x0b, 0x77, 0x01,
+                0xfa, 0x62, 0x66, 0x87, 0xdc, 0x3c, 0x9c, 0xba, 0x64, 0x63, 0x37, 0xb5, 0x3e, 0x29,
+                0x81, 0x6e, 0x94, 0x82, 0xdd, 0xf5, 0x57, 0x8a, 0x87, 0x68, 0xaa, 0xe4, 0x77, 0xfc,
+                0xe4, 0x10, 0xac, 0x2d, 0x5d, 0xe6, 0x09, 0x58, 0x61, 0xc1, 0x11, 0xd7, 0xfe, 0xb3,
+                0xe6, 0xbb, 0x4f, 0xbb, 0x5a, 0x54, 0x95, 0x54, 0x95, 0x97, 0x27, 0x98, 0x35, 0x0a,
+                0x25, 0x3f, 0x05, 0xf6, 0x6c, 0x2e, 0xcf, 0xcb, 0xc0, 0xed, 0x43, 0xf5, 0xec, 0x2e,
+                0x6d, 0x8d, 0xba, 0x15, 0xa5, 0x12, 0x54, 0xd9, 0x7b, 0x18, 0x21, 0x10, 0x7c, 0x07,
+                0xdd, 0x9a, 0x16, 0xef, 0x84, 0x06, 0xf9, 0x43, 0xe2, 0x82, 0xb9, 0x5d, 0x4b, 0x36,
+                0x25, 0x30, 0xc9, 0x13, 0xd6, 0xba, 0x42, 0x1d, 0xf6, 0x02, 0x7d, 0xe5, 0xaf, 0x1e,
+                0x47, 0x45, 0xd5, 0x86, 0x81, 0x06, 0x95, 0x4b, 0xe6, 0xc1, 0x96, 0x27, 0x80, 0xa2,
+                0x94, 0x10, 0x72, 0xe9, 0x51, 0x31, 0xb1, 0x67, 0x9d, 0xf0, 0x63, 0x76, 0x25, 0x04,
+                0x2c, 0x37, 0xd4, 0x8f, 0xfb, 0x15, 0x2e, 0x5e, 0xbc, 0x18, 0x5c, 0x8a, 0x2b, 0x7d,
+                0x43, 0x85, 0xf1, 0xc9, 0x5a, 0xf9, 0x37, 0xdf, 0x78, 0xdf, 0xd8, 0x75, 0x7f, 0xab,
+                0x43, 0x49, 0x68, 0xb0, 0xb5, 0x7c, 0x66, 0x57, 0x44, 0x68, 0xf1, 0x60, 0xb4, 0x47,
+                0xac, 0x82, 0x21, 0xe5, 0x06, 0x06, 0x76, 0xa8, 0x42, 0xa1, 0xc6, 0xb7, 0x17, 0x2d,
+                0xd3, 0x34, 0x0f, 0x76, 0x40, 0x70, 0xab, 0x1f, 0xe0, 0x91, 0xc5, 0xc7, 0x4c, 0x95,
+                0xa5, 0xdc, 0x04, 0x33, 0x90, 0x72, 0x3a, 0x4c, 0x12, 0x7d, 0xa1, 0x4c, 0xdd, 0xe1,
+                0xdc, 0x26, 0x75, 0xa6, 0x23, 0x40, 0xb3, 0xe6, 0xaf, 0xd0, 0x52, 0x2a, 0x31, 0xde,
+                0x26, 0xe7, 0xd1, 0xec, 0x3a, 0x9c, 0x8a, 0x09, 0x1f, 0xfd, 0xc7, 0x5b, 0x7e, 0xcf,
+                0xdc, 0x7c, 0x12, 0x99, 0x5a, 0x5e, 0x37, 0xce, 0x34, 0x88, 0xbd, 0x29, 0xf8, 0x62,
+                0x9d, 0x68, 0xf6, 0x96, 0x49, 0x24, 0x48, 0xdd, 0x52, 0x66, 0x97, 0x47, 0x6d, 0xc0,
+                0x61, 0x34, 0x6e, 0xbe, 0x3f, 0x67, 0x72, 0x17, 0xff, 0x9c, 0x60, 0xef, 0xce, 0x94,
+                0x3a, 0xf2, 0x8d, 0xfd, 0x3f, 0x9e, 0x59, 0x69, 0x25, 0x98, 0xa6, 0x04, 0x7c, 0x23,
+                0xc4, 0xc0, 0x14, 0x00, 0xf1, 0xab, 0x57, 0x30, 0xea, 0xc0, 0xae, 0x8d, 0x58, 0x43,
+                0xd5, 0x05, 0x1c, 0x37, 0x62, 0x40, 0x17, 0x2a, 0xf2, 0x18, 0xd7, 0xa1, 0xec, 0xfe,
+                0x65, 0xb4, 0xf7, 0x51, 0x00, 0x63, 0x89, 0x83, 0xc1, 0x4d, 0xe4, 0x97, 0x47, 0x55,
+                0xda, 0xde, 0x80, 0x18, 0xc9, 0xb8, 0xf4, 0x54, 0x3f, 0xb0, 0x95, 0x96, 0x15, 0x13,
+                0xe6, 0x7c, 0x61, 0xdb, 0xc5, 0x9c, 0x60, 0x7f, 0x9b, 0x51, 0xf8, 0xd0, 0x9b, 0xdc,
+                0xad, 0x28, 0xbc, 0xfb, 0x9e, 0x5d, 0x27, 0x44, 0xea, 0x88, 0x48, 0xb2, 0x62, 0x3a,
+                0xc0, 0x7f, 0x8e, 0xf6, 0x1a, 0x81, 0xa3, 0x59,
+            ],
+            c_enc: [
+                0x76, 0xc6, 0xef, 0xc8, 0xb5, 0x42, 0xa7, 0x07, 0xc0, 0xa5, 0xcf, 0x5c, 0xe3, 0xf3,
+                0xb9, 0x6d, 0xe1, 0x91, 0x95, 0x7c, 0x9f, 0xa6, 0xe9, 0xbb, 0x4b, 0x8d, 0x89, 0x9e,
+                0x1f, 0x19, 0xe0, 0x20, 0xba, 0x7b, 0xb3, 0xfe, 0xf1, 0x67, 0x81, 0xc8, 0x8c, 0xc5,
+                0xd4, 0x4a, 0x5e, 0xf8, 0x17, 0x31, 0x47, 0xdc, 0x3d, 0x1b, 0xc9, 0xb7, 0x31, 0x44,
+                0x93, 0x2b, 0x1e, 0xeb, 0x8c, 0x2a, 0x84, 0xf9, 0x3d, 0x9b, 0xdf, 0x53, 0x78, 0x67,
+                0xab, 0x82, 0x4c, 0xc3, 0xa4, 0xc5, 0xdc, 0x5b, 0xeb, 0xd8, 0x95, 0x26, 0xba, 0x5c,
+                0x2b, 0x5a, 0x76, 0x76, 0x4b, 0x33, 0x2f, 0x2d, 0xdc, 0x0f, 0x48, 0x2f, 0xd4, 0x57,
+                0xb3, 0x6d, 0x16, 0x05, 0xca, 0xea, 0xe2, 0xc7, 0xf1, 0x5a, 0x05, 0x91, 0xfa, 0x40,
+                0xa4, 0x57, 0x49, 0xa7, 0x58, 0xcb, 0x88, 0xaa, 0xd5, 0xd0, 0x85, 0x92, 0x11, 0x4e,
+                0x75, 0x7b, 0x19, 0x37, 0xf4, 0x99, 0x73, 0xe5, 0xba, 0x72, 0x8c, 0xa4, 0xb0, 0x9c,
+                0x71, 0xe2, 0x25, 0x54, 0xf8, 0x89, 0x34, 0x8d, 0xbe, 0x7b, 0x7d, 0x7b, 0xd5, 0x02,
+                0x84, 0x71, 0x20, 0xe1, 0xfe, 0xb6, 0xaf, 0x86, 0xeb, 0x19, 0x1a, 0xb2, 0x1d, 0x21,
+                0x20, 0xa6, 0xbd, 0x2c, 0x38, 0x04, 0x22, 0x28, 0xa7, 0xb0, 0xda, 0xc3, 0x16, 0xe3,
+                0x39, 0x05, 0x4f, 0xb4, 0x30, 0xce, 0xac, 0x6c, 0xea, 0xa8, 0xd3, 0x18, 0x10, 0xa7,
+                0x99, 0x7f, 0xfb, 0xc1, 0x58, 0xfc, 0x7b, 0x2c, 0xb6, 0x2b, 0x13, 0x5e, 0xde, 0x3f,
+                0x65, 0x6e, 0x4b, 0x13, 0x57, 0xac, 0x31, 0x48, 0x96, 0xf1, 0x35, 0x58, 0xec, 0x32,
+                0x90, 0x8e, 0x9d, 0xd6, 0x85, 0xb4, 0xee, 0x9a, 0x7d, 0x81, 0x4d, 0xdc, 0x50, 0x2c,
+                0xe7, 0xac, 0xa1, 0xda, 0x00, 0xee, 0xda, 0xe4, 0x96, 0x03, 0x35, 0xe5, 0x75, 0x6a,
+                0x42, 0xd6, 0xf4, 0x4f, 0x85, 0x2c, 0x8a, 0x7a, 0xd0, 0x0e, 0xf7, 0x9a, 0x4d, 0xb1,
+                0x4e, 0xae, 0xc9, 0x56, 0x2a, 0xba, 0xc3, 0x08, 0x01, 0x1e, 0xbf, 0x00, 0x57, 0x6e,
+                0x6c, 0xa3, 0xea, 0x16, 0xe5, 0x01, 0xbf, 0x35, 0x0f, 0x82, 0x14, 0xb6, 0x84, 0x04,
+                0xdb, 0x24, 0x2e, 0x9f, 0x85, 0x3d, 0x82, 0xbe, 0x44, 0x25, 0x0d, 0xf0, 0xa8, 0x1d,
+                0xe7, 0x0e, 0x10, 0x40, 0xfa, 0xde, 0x44, 0x69, 0x1e, 0xca, 0x6e, 0x03, 0xc4, 0x6c,
+                0x4b, 0x57, 0xc7, 0x89, 0xc9, 0x74, 0x8e, 0x0e, 0x2e, 0xf4, 0x11, 0x9d, 0xbd, 0x7b,
+                0x39, 0x3d, 0x63, 0x3c, 0x6e, 0xc8, 0xf0, 0xd0, 0x4d, 0x97, 0x1d, 0x2b, 0xd5, 0xab,
+                0xed, 0x9f, 0x36, 0xc9, 0xb4, 0xb4, 0x6e, 0x3b, 0x32, 0x56, 0x9d, 0x31, 0x89, 0x45,
+                0x6e, 0x65, 0x51, 0x67, 0x7e, 0xe7, 0x71, 0xb0, 0xf0, 0xa2, 0x6f, 0x84, 0xc2, 0x9f,
+                0xdc, 0xa3, 0xd6, 0x42, 0x82, 0x60, 0x05, 0x37, 0x34, 0x7b, 0xd7, 0xf6, 0x0c, 0xe4,
+                0x27, 0xbf, 0x55, 0xe9, 0xb1, 0xbf, 0xd4, 0xb7, 0x56, 0x4f, 0x9f, 0xb1, 0x93, 0x02,
+                0xdc, 0x41, 0xe7, 0xde, 0xde, 0x7f, 0x4f, 0xc0, 0x0f, 0x57, 0x3e, 0x33, 0xf4, 0xbe,
+                0x41, 0x40, 0xdd, 0xc9, 0x76, 0x93, 0xaf, 0x52, 0x48, 0x95, 0x87, 0xf0, 0xd0, 0x81,
+                0x0f, 0x3d, 0x9c, 0x35, 0x6f, 0x32, 0xe9, 0x3d, 0x47, 0x56, 0x0c, 0x01, 0x1c, 0x0c,
+                0x94, 0xe1, 0xa6, 0x49, 0x7e, 0x87, 0x45, 0x8e, 0xad, 0x8a, 0x34, 0x67, 0x84, 0xbc,
+                0x42, 0x66, 0x16, 0x7f, 0x87, 0x7e, 0x38, 0x92, 0xa8, 0x98, 0x77, 0x4c, 0xe3, 0xad,
+                0x3b, 0x82, 0x8d, 0x9d, 0xd1, 0xd2, 0xe4, 0x0a, 0x89, 0xf1, 0xfc, 0xe4, 0x9d, 0x6b,
+                0x20, 0x18, 0x9e, 0x0c, 0x22, 0xe0, 0x17, 0xab, 0x55, 0x5b, 0x68, 0xa7, 0x4e, 0x66,
+                0xb4, 0xeb, 0x31, 0xee, 0x78, 0xaf, 0xbe, 0x63, 0x25, 0xcb, 0xad, 0xd5, 0xa8, 0x38,
+                0x29, 0x49, 0xf3, 0xc7, 0x48, 0xa9, 0xe7, 0x22, 0xfc, 0x58, 0xeb, 0xab, 0xdc, 0x69,
+                0x64, 0x22, 0x4c, 0x48, 0x58, 0x6e, 0x94, 0x3c, 0x60, 0x2f, 0x70, 0x5e, 0x55, 0x4b,
+                0xc0, 0x1c, 0x58, 0x90, 0x4d, 0x2f, 0xa7, 0x1e, 0x4c, 0x44, 0xe3, 0x8c, 0x3d, 0x19,
+                0x04, 0x7d, 0xa9, 0x39, 0xaf, 0x3b, 0x3f, 0xba, 0x89, 0xad, 0x1b, 0x83, 0xb5, 0xb3,
+                0xb4, 0xbd, 0x8c, 0xe5, 0x99, 0xeb, 0x69, 0x7a, 0xb6, 0x5d, 0x37, 0x04, 0x5e, 0xa9,
+                0x15, 0x98, 0xdb, 0x59, 0x18, 0x75, 0xf6, 0xcc, 0x18, 0x02, 0x79, 0x0a, 0x3c, 0x1f,
+                0x40, 0xeb, 0x68, 0x8e, 0x7c, 0xb8, 0xbb, 0x3d, 0x07, 0xde,
+            ],
+            ock: [
+                0xb4, 0xf8, 0x8a, 0x29, 0x2d, 0x09, 0xd9, 0x35, 0xb4, 0x77, 0x5a, 0x29, 0x30, 0xeb,
+                0x38, 0xce, 0xbd, 0x5a, 0xf6, 0xff, 0x3f, 0x39, 0xef, 0x5b, 0xb2, 0x4c, 0xd5, 0x72,
+                0x81, 0xf0, 0x8c, 0xfb,
+            ],
+            op: [
+                0xae, 0xee, 0xa5, 0x0c, 0x6b, 0xb0, 0x2e, 0x5e, 0x22, 0x4d, 0xc2, 0x95, 0x9c, 0x22,
+                0x9d, 0x0e, 0x3b, 0xb8, 0x79, 0xc4, 0xab, 0x00, 0xaa, 0x0a, 0xb2, 0x5a, 0x40, 0x10,
+                0x6b, 0x80, 0xbb, 0xb7, 0x19, 0xe0, 0x26, 0x4b, 0x82, 0x88, 0xf7, 0x3e, 0xbf, 0x97,
+                0x14, 0xb0, 0xdf, 0x85, 0x8e, 0xf7, 0xab, 0x39, 0xec, 0x50, 0x2c, 0xd2, 0x98, 0xf2,
+                0xc4, 0x84, 0xa9, 0xf4, 0xc7, 0xda, 0x74, 0x36,
+            ],
+            c_out: [
+                0x94, 0xe3, 0x7f, 0xd6, 0x62, 0x82, 0xc0, 0x2e, 0x90, 0xe7, 0x69, 0x91, 0x4c, 0xaf,
+                0x95, 0xa4, 0x95, 0xf4, 0x89, 0x7f, 0x55, 0xa5, 0xae, 0x95, 0xad, 0xe8, 0xbf, 0x67,
+                0x61, 0xe3, 0x1b, 0xa5, 0xd1, 0xcf, 0xeb, 0x30, 0x6f, 0x4e, 0x22, 0x01, 0x42, 0x51,
+                0xcb, 0xe3, 0xf8, 0x72, 0x4b, 0xe7, 0x69, 0x21, 0xe2, 0xad, 0xa4, 0x6e, 0x3b, 0x14,
+                0x5d, 0x1b, 0x04, 0x3e, 0xb1, 0x2a, 0x0e, 0xfa, 0xb5, 0x16, 0x09, 0x34, 0xbc, 0x75,
+                0x9e, 0x02, 0x01, 0xd8, 0x66, 0xad, 0xa7, 0x44, 0x35, 0x71,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x74, 0xa8, 0x41, 0x1a, 0x20, 0xbc, 0x3c, 0x53, 0xf7, 0xe7, 0xab, 0xb9, 0x31, 0x6c,
+                0x44, 0x2b, 0x4b, 0x09, 0xcf, 0x88, 0xbb, 0xed, 0x4a, 0x90, 0xb9, 0x2f, 0x5a, 0x1c,
+                0xed, 0x93, 0x16, 0x2b, 0xc3, 0x37, 0x34, 0x67, 0x20, 0xec, 0x0c, 0xd0, 0xea, 0x73,
+                0x5d, 0x9e, 0x32, 0x3f, 0x20, 0xdb, 0x77, 0x8a, 0xd1, 0x8a, 0x84, 0xc7, 0x9e, 0xe6,
+                0x28, 0x77, 0x99, 0xef, 0x02, 0x76, 0x41, 0x07,
+            ],
+            ovk: [
+                0x0c, 0x81, 0x1e, 0x4c, 0x31, 0xfb, 0xb4, 0x9f, 0x3a, 0x90, 0xbb, 0xd0, 0x5d, 0xce,
+                0x62, 0xf3, 0x44, 0xe7, 0x07, 0x75, 0x93, 0x15, 0x9a, 0xe3, 0x50, 0x50, 0xb0, 0x4c,
+                0x9e, 0x6b, 0x86, 0xbc,
+            ],
+            default_d: [
+                0xc6, 0xe8, 0xf0, 0xd5, 0x0a, 0xe8, 0x05, 0x87, 0x91, 0xdc, 0x0e,
+            ],
+            default_pk_d: [
+                0x8e, 0x66, 0xb7, 0x92, 0xec, 0xb1, 0x56, 0xef, 0x68, 0x5e, 0xe8, 0xea, 0x35, 0xd3,
+                0x82, 0x75, 0x8b, 0xa4, 0x15, 0x97, 0xa3, 0x3a, 0x93, 0xba, 0xf3, 0x81, 0xd6, 0x3c,
+                0x17, 0x5b, 0xa9, 0x8b,
+            ],
+            v: 7387862906040043846,
+            rseed: [
+                0x25, 0x01, 0xe5, 0x1b, 0x01, 0x2a, 0xea, 0x94, 0x46, 0xa2, 0x10, 0x4e, 0x93, 0xf8,
+                0x15, 0xa0, 0xb3, 0xa2, 0x9b, 0x45, 0x83, 0x14, 0xf3, 0xd8, 0xbe, 0x2b, 0x98, 0x23,
+                0xd3, 0x42, 0xf4, 0x62,
+            ],
+            asset: [
+                0x67, 0x43, 0xf9, 0x3a, 0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3,
+                0x04, 0xfe, 0x32, 0xb2, 0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e,
+                0x7a, 0x59, 0x70, 0x2f,
+            ],
+            memo: [
+                0xff, 0x13, 0xe9, 0x42, 0xa7, 0xe1, 0x9a, 0x46, 0xe9, 0x70, 0xb5, 0xc5, 0x06, 0x70,
+                0x84, 0x30, 0x31, 0x7b, 0x1b, 0xb3, 0xb3, 0x5d, 0xf6, 0x8a, 0xe3, 0x3a, 0x49, 0x26,
+                0xa0, 0x3e, 0x6b, 0xfe, 0xb5, 0x51, 0x04, 0x16, 0xfc, 0xbb, 0x05, 0x24, 0xc9, 0xca,
+                0x50, 0x74, 0x15, 0x6c, 0xc5, 0xa5, 0xd6, 0xfe, 0x1c, 0x99, 0x5e, 0xdc, 0x60, 0xa2,
+                0xf5, 0x50, 0x41, 0x1a, 0xa4, 0x1e, 0x3d, 0xa3, 0xbd, 0xcf, 0x64, 0xbc, 0xf0, 0x4a,
+                0x05, 0x10, 0x57, 0x1b, 0x93, 0x6d, 0x47, 0xe5, 0x5c, 0xec, 0x03, 0x30, 0xee, 0x8d,
+                0xfe, 0x73, 0x56, 0x34, 0x04, 0xf0, 0x47, 0xd7, 0xf3, 0xa8, 0xa3, 0xd7, 0x74, 0x3b,
+                0xc5, 0x54, 0x95, 0x52, 0x10, 0xf1, 0xeb, 0x0d, 0x08, 0x59, 0x9e, 0xa7, 0x7d, 0x5f,
+                0x97, 0x4d, 0x87, 0x17, 0x6d, 0x37, 0xd9, 0x8b, 0x9c, 0x0a, 0xd4, 0x40, 0x40, 0x72,
+                0x09, 0xed, 0x6a, 0x9f, 0x08, 0x46, 0x4d, 0x56, 0x55, 0x93, 0xe1, 0xa6, 0x3b, 0x93,
+                0x85, 0x36, 0xb4, 0x92, 0x44, 0xe9, 0x7d, 0x88, 0x01, 0x73, 0xb6, 0x40, 0xf2, 0xdd,
+                0xb7, 0x4d, 0x06, 0x8e, 0xcb, 0x46, 0xcf, 0x28, 0x9b, 0x7d, 0x89, 0x13, 0x07, 0xbb,
+                0xa3, 0x70, 0x54, 0xcf, 0x91, 0xb3, 0x1f, 0xc8, 0x2f, 0x74, 0xd5, 0xfc, 0xc0, 0x00,
+                0x94, 0x2e, 0xde, 0x91, 0x18, 0x25, 0xf5, 0x3f, 0xe6, 0x09, 0x68, 0x6f, 0x46, 0x32,
+                0x23, 0xb1, 0xe9, 0xbc, 0x03, 0xbd, 0xe8, 0x95, 0xd1, 0x23, 0x8f, 0xad, 0x04, 0xa3,
+                0xbf, 0xce, 0x68, 0xa0, 0x75, 0xe8, 0xa3, 0x7c, 0x0e, 0x87, 0xbf, 0x46, 0xdd, 0x01,
+                0x55, 0x45, 0xf9, 0xb4, 0xfb, 0x0e, 0xec, 0x64, 0x5f, 0xfc, 0xbb, 0xe0, 0xca, 0x5f,
+                0x8c, 0x56, 0x1b, 0x25, 0x7d, 0x52, 0xd6, 0x02, 0xd8, 0xc9, 0x4c, 0x50, 0x28, 0x73,
+                0xa0, 0x1d, 0x92, 0x51, 0xd8, 0xc8, 0x60, 0xc0, 0x41, 0x52, 0x5b, 0x3b, 0xf4, 0xe3,
+                0xa2, 0xeb, 0x92, 0x72, 0x81, 0x5c, 0x75, 0x86, 0x76, 0x84, 0x28, 0xb4, 0xc2, 0xb2,
+                0x5e, 0x37, 0x45, 0xf0, 0x09, 0xc5, 0xdc, 0xe2, 0x0b, 0x69, 0xd5, 0xd7, 0xc4, 0x3c,
+                0xeb, 0x73, 0x6b, 0x68, 0x31, 0xe8, 0xc1, 0x10, 0xf1, 0x6c, 0xfd, 0xb3, 0xa4, 0x67,
+                0xe9, 0x41, 0x4c, 0x00, 0xec, 0xf1, 0x37, 0x31, 0x50, 0x08, 0x94, 0x55, 0x56, 0x78,
+                0xc4, 0x97, 0xfa, 0xba, 0x9a, 0x95, 0xd0, 0x1c, 0xc4, 0x64, 0x39, 0x0f, 0xc4, 0xa7,
+                0x6b, 0xfa, 0x8b, 0x0e, 0x1c, 0x68, 0xa5, 0x25, 0xd7, 0x06, 0xd6, 0x60, 0x4b, 0x23,
+                0x30, 0xb6, 0xb3, 0x48, 0x52, 0x15, 0xf6, 0x06, 0xf1, 0x88, 0x3a, 0x75, 0x15, 0x88,
+                0xc7, 0xef, 0xa5, 0x06, 0xc3, 0xe8, 0xd0, 0xc6, 0x01, 0x92, 0xe8, 0x47, 0x6b, 0xd1,
+                0x17, 0x5d, 0x95, 0x62, 0x08, 0x7b, 0xdb, 0x81, 0x8e, 0x66, 0x21, 0x62, 0x86, 0xba,
+                0xfe, 0x47, 0xff, 0x4d, 0xbc, 0xce, 0xd5, 0x14, 0x44, 0x48, 0x0a, 0x9a, 0x56, 0x73,
+                0xec, 0xe7, 0xfa, 0xc7, 0x3a, 0x0e, 0xd4, 0x1a, 0xb0, 0x05, 0x17, 0x53, 0xa7, 0xca,
+                0xa8, 0x9b, 0xe3, 0x13, 0x9a, 0xfd, 0x97, 0x93, 0xb3, 0xe0, 0x2f, 0x27, 0xf0, 0x40,
+                0x04, 0x65, 0x95, 0xac, 0xd4, 0x7b, 0xf1, 0x3f, 0xd0, 0xda, 0x27, 0xf0, 0x9e, 0xda,
+                0x48, 0x03, 0x6d, 0x3e, 0xe4, 0x37, 0xf2, 0xee, 0x8f, 0x86, 0x06, 0xea, 0x97, 0x34,
+                0x3c, 0x33, 0x58, 0x46, 0x57, 0xf4, 0x6d, 0xba, 0x99, 0xdb, 0x5c, 0xfe, 0x6c, 0xa1,
+                0x76, 0xfa, 0xb7, 0xb0, 0xf3, 0xbf, 0xa0, 0xab, 0x61, 0xe3, 0x40, 0xc3, 0x4e, 0xb9,
+                0xf1, 0x7c, 0x7e, 0xc2, 0xbe, 0x03, 0xb1, 0x80, 0xf0, 0xbb, 0x6f, 0x43, 0x4c, 0x2a,
+                0x65, 0x42, 0xe0, 0x0e, 0x84, 0x37, 0x3f, 0x4f,
+            ],
+            cv_net: [
+                0x47, 0x35, 0xa6, 0xfd, 0x21, 0x5c, 0x7b, 0x95, 0x03, 0x3d, 0xab, 0x62, 0xcc, 0xf9,
+                0xcd, 0x51, 0x00, 0x89, 0x08, 0xa6, 0xcd, 0xd0, 0xaa, 0x02, 0x1b, 0x88, 0x8b, 0x98,
+                0xe2, 0x3c, 0x39, 0x11,
+            ],
+            rho: [
+                0xbd, 0xda, 0xe8, 0xdf, 0xf1, 0x20, 0x5e, 0x04, 0x96, 0x8f, 0xae, 0x1f, 0xd9, 0xbe,
+                0x51, 0xd8, 0x25, 0xf5, 0xd8, 0x78, 0x1d, 0x93, 0x3d, 0x0f, 0x5b, 0xce, 0x9c, 0xa8,
+                0x3e, 0xe8, 0xed, 0x20,
+            ],
+            cmx: [
+                0xbe, 0x43, 0xee, 0x84, 0x70, 0x70, 0x75, 0xac, 0x48, 0x08, 0xd0, 0x97, 0x54, 0x07,
+                0xc0, 0x27, 0x36, 0xd7, 0x66, 0x64, 0xf4, 0xe7, 0xae, 0xce, 0x01, 0xd9, 0xcc, 0x68,
+                0x32, 0x4a, 0xe9, 0x04,
+            ],
+            esk: [
+                0xf9, 0xf7, 0xa0, 0x10, 0x5e, 0xa9, 0xf4, 0x45, 0xfb, 0x7a, 0x14, 0x49, 0x72, 0x62,
+                0xc6, 0xe4, 0xd7, 0x32, 0x89, 0x32, 0x7b, 0x8a, 0x2d, 0xf5, 0xe2, 0x63, 0xf3, 0xe3,
+                0x99, 0x07, 0xea, 0x0c,
+            ],
+            ephemeral_key: [
+                0xfa, 0x19, 0xa1, 0x52, 0x7b, 0x76, 0x04, 0x8f, 0xf3, 0x7f, 0xa4, 0xf8, 0x27, 0x89,
+                0xfe, 0x80, 0xb0, 0xcd, 0xd3, 0x5d, 0x5d, 0xa9, 0xc2, 0xec, 0x3f, 0xe3, 0x04, 0x38,
+                0x05, 0xc0, 0x61, 0x23,
+            ],
+            shared_secret: [
+                0x2d, 0xb5, 0xb8, 0x92, 0xb6, 0x1b, 0x9c, 0x55, 0x3b, 0x6c, 0x9b, 0x7a, 0xcc, 0x7d,
+                0x71, 0x05, 0xc1, 0xdd, 0x4c, 0x28, 0xc6, 0x7f, 0x97, 0x8b, 0x6d, 0x79, 0xc7, 0x1b,
+                0x98, 0xa0, 0xd0, 0x00,
+            ],
+            k_enc: [
+                0x16, 0xe3, 0xf9, 0x85, 0xc0, 0x7f, 0xef, 0xe5, 0x30, 0xd9, 0xe6, 0x94, 0x5e, 0xde,
+                0xc1, 0x90, 0x3b, 0xb1, 0xca, 0x8d, 0xa5, 0xa2, 0x5b, 0xe9, 0x59, 0x78, 0x63, 0x7a,
+                0x40, 0x8c, 0x2e, 0xfe,
+            ],
+            p_enc: [
+                0x03, 0xc6, 0xe8, 0xf0, 0xd5, 0x0a, 0xe8, 0x05, 0x87, 0x91, 0xdc, 0x0e, 0x46, 0x49,
+                0xcd, 0xa3, 0x2b, 0xf6, 0x86, 0x66, 0x25, 0x01, 0xe5, 0x1b, 0x01, 0x2a, 0xea, 0x94,
+                0x46, 0xa2, 0x10, 0x4e, 0x93, 0xf8, 0x15, 0xa0, 0xb3, 0xa2, 0x9b, 0x45, 0x83, 0x14,
+                0xf3, 0xd8, 0xbe, 0x2b, 0x98, 0x23, 0xd3, 0x42, 0xf4, 0x62, 0x67, 0x43, 0xf9, 0x3a,
+                0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3, 0x04, 0xfe, 0x32, 0xb2,
+                0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e, 0x7a, 0x59, 0x70, 0x2f,
+                0xff, 0x13, 0xe9, 0x42, 0xa7, 0xe1, 0x9a, 0x46, 0xe9, 0x70, 0xb5, 0xc5, 0x06, 0x70,
+                0x84, 0x30, 0x31, 0x7b, 0x1b, 0xb3, 0xb3, 0x5d, 0xf6, 0x8a, 0xe3, 0x3a, 0x49, 0x26,
+                0xa0, 0x3e, 0x6b, 0xfe, 0xb5, 0x51, 0x04, 0x16, 0xfc, 0xbb, 0x05, 0x24, 0xc9, 0xca,
+                0x50, 0x74, 0x15, 0x6c, 0xc5, 0xa5, 0xd6, 0xfe, 0x1c, 0x99, 0x5e, 0xdc, 0x60, 0xa2,
+                0xf5, 0x50, 0x41, 0x1a, 0xa4, 0x1e, 0x3d, 0xa3, 0xbd, 0xcf, 0x64, 0xbc, 0xf0, 0x4a,
+                0x05, 0x10, 0x57, 0x1b, 0x93, 0x6d, 0x47, 0xe5, 0x5c, 0xec, 0x03, 0x30, 0xee, 0x8d,
+                0xfe, 0x73, 0x56, 0x34, 0x04, 0xf0, 0x47, 0xd7, 0xf3, 0xa8, 0xa3, 0xd7, 0x74, 0x3b,
+                0xc5, 0x54, 0x95, 0x52, 0x10, 0xf1, 0xeb, 0x0d, 0x08, 0x59, 0x9e, 0xa7, 0x7d, 0x5f,
+                0x97, 0x4d, 0x87, 0x17, 0x6d, 0x37, 0xd9, 0x8b, 0x9c, 0x0a, 0xd4, 0x40, 0x40, 0x72,
+                0x09, 0xed, 0x6a, 0x9f, 0x08, 0x46, 0x4d, 0x56, 0x55, 0x93, 0xe1, 0xa6, 0x3b, 0x93,
+                0x85, 0x36, 0xb4, 0x92, 0x44, 0xe9, 0x7d, 0x88, 0x01, 0x73, 0xb6, 0x40, 0xf2, 0xdd,
+                0xb7, 0x4d, 0x06, 0x8e, 0xcb, 0x46, 0xcf, 0x28, 0x9b, 0x7d, 0x89, 0x13, 0x07, 0xbb,
+                0xa3, 0x70, 0x54, 0xcf, 0x91, 0xb3, 0x1f, 0xc8, 0x2f, 0x74, 0xd5, 0xfc, 0xc0, 0x00,
+                0x94, 0x2e, 0xde, 0x91, 0x18, 0x25, 0xf5, 0x3f, 0xe6, 0x09, 0x68, 0x6f, 0x46, 0x32,
+                0x23, 0xb1, 0xe9, 0xbc, 0x03, 0xbd, 0xe8, 0x95, 0xd1, 0x23, 0x8f, 0xad, 0x04, 0xa3,
+                0xbf, 0xce, 0x68, 0xa0, 0x75, 0xe8, 0xa3, 0x7c, 0x0e, 0x87, 0xbf, 0x46, 0xdd, 0x01,
+                0x55, 0x45, 0xf9, 0xb4, 0xfb, 0x0e, 0xec, 0x64, 0x5f, 0xfc, 0xbb, 0xe0, 0xca, 0x5f,
+                0x8c, 0x56, 0x1b, 0x25, 0x7d, 0x52, 0xd6, 0x02, 0xd8, 0xc9, 0x4c, 0x50, 0x28, 0x73,
+                0xa0, 0x1d, 0x92, 0x51, 0xd8, 0xc8, 0x60, 0xc0, 0x41, 0x52, 0x5b, 0x3b, 0xf4, 0xe3,
+                0xa2, 0xeb, 0x92, 0x72, 0x81, 0x5c, 0x75, 0x86, 0x76, 0x84, 0x28, 0xb4, 0xc2, 0xb2,
+                0x5e, 0x37, 0x45, 0xf0, 0x09, 0xc5, 0xdc, 0xe2, 0x0b, 0x69, 0xd5, 0xd7, 0xc4, 0x3c,
+                0xeb, 0x73, 0x6b, 0x68, 0x31, 0xe8, 0xc1, 0x10, 0xf1, 0x6c, 0xfd, 0xb3, 0xa4, 0x67,
+                0xe9, 0x41, 0x4c, 0x00, 0xec, 0xf1, 0x37, 0x31, 0x50, 0x08, 0x94, 0x55, 0x56, 0x78,
+                0xc4, 0x97, 0xfa, 0xba, 0x9a, 0x95, 0xd0, 0x1c, 0xc4, 0x64, 0x39, 0x0f, 0xc4, 0xa7,
+                0x6b, 0xfa, 0x8b, 0x0e, 0x1c, 0x68, 0xa5, 0x25, 0xd7, 0x06, 0xd6, 0x60, 0x4b, 0x23,
+                0x30, 0xb6, 0xb3, 0x48, 0x52, 0x15, 0xf6, 0x06, 0xf1, 0x88, 0x3a, 0x75, 0x15, 0x88,
+                0xc7, 0xef, 0xa5, 0x06, 0xc3, 0xe8, 0xd0, 0xc6, 0x01, 0x92, 0xe8, 0x47, 0x6b, 0xd1,
+                0x17, 0x5d, 0x95, 0x62, 0x08, 0x7b, 0xdb, 0x81, 0x8e, 0x66, 0x21, 0x62, 0x86, 0xba,
+                0xfe, 0x47, 0xff, 0x4d, 0xbc, 0xce, 0xd5, 0x14, 0x44, 0x48, 0x0a, 0x9a, 0x56, 0x73,
+                0xec, 0xe7, 0xfa, 0xc7, 0x3a, 0x0e, 0xd4, 0x1a, 0xb0, 0x05, 0x17, 0x53, 0xa7, 0xca,
+                0xa8, 0x9b, 0xe3, 0x13, 0x9a, 0xfd, 0x97, 0x93, 0xb3, 0xe0, 0x2f, 0x27, 0xf0, 0x40,
+                0x04, 0x65, 0x95, 0xac, 0xd4, 0x7b, 0xf1, 0x3f, 0xd0, 0xda, 0x27, 0xf0, 0x9e, 0xda,
+                0x48, 0x03, 0x6d, 0x3e, 0xe4, 0x37, 0xf2, 0xee, 0x8f, 0x86, 0x06, 0xea, 0x97, 0x34,
+                0x3c, 0x33, 0x58, 0x46, 0x57, 0xf4, 0x6d, 0xba, 0x99, 0xdb, 0x5c, 0xfe, 0x6c, 0xa1,
+                0x76, 0xfa, 0xb7, 0xb0, 0xf3, 0xbf, 0xa0, 0xab, 0x61, 0xe3, 0x40, 0xc3, 0x4e, 0xb9,
+                0xf1, 0x7c, 0x7e, 0xc2, 0xbe, 0x03, 0xb1, 0x80, 0xf0, 0xbb, 0x6f, 0x43, 0x4c, 0x2a,
+                0x65, 0x42, 0xe0, 0x0e, 0x84, 0x37, 0x3f, 0x4f,
+            ],
+            c_enc: [
+                0x2c, 0x40, 0x4a, 0x68, 0x81, 0xa6, 0xee, 0x76, 0x0c, 0xb5, 0x3b, 0x9c, 0xc2, 0x71,
+                0x5c, 0xa7, 0x6a, 0x3a, 0x2f, 0xc9, 0x69, 0x3b, 0x1a, 0xbb, 0xcd, 0xc7, 0x5c, 0xb6,
+                0xd6, 0xc3, 0x6e, 0xcf, 0x84, 0xd6, 0x93, 0x67, 0x2c, 0x53, 0xce, 0xd8, 0x79, 0x8c,
+                0xc8, 0xf1, 0xe5, 0x3b, 0x8a, 0x9d, 0xe7, 0xbb, 0xb5, 0xe8, 0x5d, 0xf4, 0x7c, 0x42,
+                0xbd, 0x4e, 0xe2, 0x7d, 0xa0, 0xd6, 0xf9, 0x5a, 0xa4, 0xf1, 0x10, 0xd4, 0x5a, 0xe2,
+                0x8e, 0x6f, 0xea, 0x40, 0xe4, 0x7b, 0xc6, 0x08, 0x1b, 0x78, 0xe2, 0xcb, 0xa1, 0x78,
+                0xf5, 0x3b, 0x2c, 0x0f, 0xfd, 0x71, 0xf1, 0x52, 0x54, 0x55, 0x70, 0x8a, 0x92, 0x50,
+                0xb0, 0x28, 0x17, 0x90, 0x70, 0xc7, 0xd3, 0xbe, 0x38, 0xdc, 0x67, 0x3f, 0xc1, 0x20,
+                0x6c, 0xce, 0x64, 0xd5, 0x13, 0xed, 0x14, 0x3e, 0xbf, 0x45, 0x76, 0x3c, 0xa5, 0xea,
+                0x12, 0x6e, 0xc1, 0x4d, 0x01, 0xda, 0xcb, 0x64, 0x60, 0xa5, 0xdc, 0xd2, 0x26, 0xd1,
+                0xa9, 0x5c, 0x8d, 0xf9, 0xc4, 0x64, 0xd9, 0x35, 0xb6, 0xaa, 0x60, 0x7f, 0xff, 0x2d,
+                0x3d, 0x72, 0x55, 0x83, 0xf8, 0x82, 0x1a, 0xe9, 0xb4, 0x7f, 0xce, 0x87, 0x5e, 0xa8,
+                0x7c, 0xea, 0x41, 0x21, 0xec, 0xc8, 0x5b, 0x93, 0xa6, 0x38, 0xf5, 0x6f, 0x48, 0xf7,
+                0x0a, 0xc8, 0x85, 0xb4, 0x89, 0x03, 0x02, 0xdf, 0x12, 0x5f, 0x80, 0x20, 0x16, 0x4d,
+                0xd0, 0x13, 0xc7, 0x3f, 0xd2, 0xb4, 0x0f, 0x38, 0xc6, 0x9b, 0xe8, 0xcf, 0x0a, 0x3b,
+                0xaf, 0xa6, 0x3b, 0x2b, 0xa0, 0x4d, 0x98, 0x65, 0xa2, 0x55, 0xc2, 0x34, 0x60, 0x83,
+                0x33, 0x04, 0xf6, 0xe7, 0xf6, 0xec, 0xd4, 0x7d, 0xa7, 0x8b, 0x29, 0xfa, 0x95, 0x15,
+                0xba, 0x60, 0xed, 0x15, 0x78, 0x78, 0x02, 0xe7, 0xa9, 0xf6, 0x63, 0xe9, 0xad, 0xda,
+                0x54, 0x64, 0x77, 0xf7, 0xa9, 0x94, 0xc1, 0x6b, 0x81, 0x41, 0xf4, 0x54, 0xc4, 0x34,
+                0xd5, 0x7f, 0x8b, 0xd3, 0xb8, 0xc0, 0xe7, 0x21, 0x1c, 0x91, 0x5f, 0xc3, 0xfe, 0xb5,
+                0xdd, 0xe3, 0xb9, 0x1c, 0xed, 0x14, 0x93, 0x7a, 0x00, 0xff, 0xfc, 0xba, 0x37, 0x2e,
+                0x69, 0x28, 0x70, 0xca, 0x44, 0xd0, 0x0c, 0x24, 0xc0, 0x0d, 0x61, 0x0a, 0x75, 0xa5,
+                0x18, 0xca, 0x83, 0x62, 0xcd, 0xb3, 0xcf, 0xb6, 0xdc, 0x10, 0x5a, 0xa6, 0x86, 0x37,
+                0x69, 0x52, 0x03, 0x45, 0xae, 0x51, 0x3d, 0x60, 0x89, 0x85, 0xba, 0x9b, 0xab, 0x2f,
+                0x61, 0x4c, 0xd8, 0xad, 0xfc, 0xe6, 0x07, 0x15, 0x6d, 0x04, 0xe7, 0x70, 0xe6, 0x3e,
+                0x2c, 0xd4, 0x7a, 0xb8, 0x5f, 0x8e, 0x74, 0x51, 0x8e, 0x19, 0x70, 0x7d, 0x83, 0xe3,
+                0xc4, 0x86, 0xad, 0x9e, 0x0a, 0x28, 0x34, 0xc5, 0x8b, 0x4b, 0x72, 0x7a, 0x9b, 0xb0,
+                0xc3, 0x7e, 0x8f, 0xcb, 0xdd, 0x9a, 0x49, 0xe8, 0x23, 0x74, 0xd5, 0x24, 0x44, 0x42,
+                0x9b, 0x6e, 0x9a, 0x0d, 0xf2, 0xaf, 0x47, 0xe9, 0xd4, 0x58, 0x1d, 0xbe, 0xc7, 0xc6,
+                0x0f, 0xb9, 0x33, 0x79, 0x4e, 0xc6, 0x88, 0x16, 0xbe, 0xd4, 0x2e, 0x97, 0xfb, 0xbc,
+                0x91, 0xbd, 0x5e, 0x25, 0x69, 0x07, 0xb3, 0x9d, 0x24, 0xad, 0x54, 0xb5, 0x06, 0x4a,
+                0x46, 0xb4, 0x01, 0x83, 0x38, 0x26, 0xfe, 0x4d, 0xff, 0x2e, 0x9f, 0xcc, 0xca, 0x8c,
+                0x54, 0xf7, 0x83, 0x25, 0x4d, 0x28, 0x05, 0xe9, 0x56, 0x04, 0x41, 0x72, 0xa7, 0x65,
+                0x81, 0xff, 0xfd, 0x45, 0x8b, 0x6a, 0x64, 0x69, 0xdc, 0x40, 0xf9, 0x4e, 0x60, 0x65,
+                0xf9, 0x9c, 0x3f, 0x63, 0xda, 0x89, 0xf3, 0x26, 0x0a, 0xfe, 0xde, 0x0f, 0xfa, 0x0c,
+                0xd3, 0x3a, 0xb0, 0x89, 0xb1, 0x31, 0xed, 0x55, 0x40, 0x29, 0x06, 0xba, 0xf8, 0x0b,
+                0xcc, 0x64, 0x3d, 0xf9, 0x34, 0x1c, 0xce, 0x9a, 0x55, 0x3b, 0x5a, 0xe5, 0x11, 0xe5,
+                0xdc, 0xd2, 0x83, 0x5c, 0x3b, 0xf5, 0x71, 0xe8, 0xaa, 0xd1, 0x61, 0x8c, 0xf7, 0x06,
+                0xd9, 0x14, 0xe6, 0xa3, 0x99, 0xd1, 0x8d, 0xeb, 0xf5, 0x6b, 0x3b, 0x46, 0xc5, 0xd4,
+                0x56, 0x2f, 0x1c, 0x7d, 0x24, 0x2d, 0xdc, 0x53, 0xa5, 0x73, 0x63, 0x6e, 0x75, 0x3c,
+                0x91, 0x52, 0x4c, 0xb9, 0x3f, 0xcd, 0x88, 0xa2, 0x3b, 0xe9, 0xb3, 0x4e, 0xca, 0xb4,
+                0xbf, 0x89, 0x71, 0x01, 0x34, 0xfc, 0xe8, 0x34, 0x5b, 0xcd, 0x6a, 0x5a, 0x3d, 0x72,
+                0x1e, 0xa8, 0xb6, 0x20, 0x7c, 0x2f, 0xcf, 0x81, 0x75, 0x80, 0xe0, 0xa6, 0x3d, 0xb4,
+                0x37, 0x7c, 0x86, 0xe4, 0x15, 0x1e, 0xd8, 0xd3, 0x0a, 0x71,
+            ],
+            ock: [
+                0x8b, 0x0d, 0x29, 0x8e, 0xe8, 0xb4, 0x25, 0x34, 0xa4, 0x2f, 0xb9, 0x63, 0x5b, 0xa7,
+                0x58, 0xea, 0x9f, 0x91, 0x8b, 0x83, 0x16, 0xc0, 0xe8, 0x94, 0xa9, 0x08, 0x48, 0x89,
+                0x01, 0xd9, 0xfb, 0xa3,
+            ],
+            op: [
+                0x8e, 0x66, 0xb7, 0x92, 0xec, 0xb1, 0x56, 0xef, 0x68, 0x5e, 0xe8, 0xea, 0x35, 0xd3,
+                0x82, 0x75, 0x8b, 0xa4, 0x15, 0x97, 0xa3, 0x3a, 0x93, 0xba, 0xf3, 0x81, 0xd6, 0x3c,
+                0x17, 0x5b, 0xa9, 0x8b, 0xf9, 0xf7, 0xa0, 0x10, 0x5e, 0xa9, 0xf4, 0x45, 0xfb, 0x7a,
+                0x14, 0x49, 0x72, 0x62, 0xc6, 0xe4, 0xd7, 0x32, 0x89, 0x32, 0x7b, 0x8a, 0x2d, 0xf5,
+                0xe2, 0x63, 0xf3, 0xe3, 0x99, 0x07, 0xea, 0x0c,
+            ],
+            c_out: [
+                0xf3, 0xbf, 0x90, 0x76, 0xf3, 0xdb, 0x66, 0x32, 0x6d, 0xa6, 0x0c, 0xc7, 0x94, 0x3c,
+                0x85, 0x4d, 0x8d, 0xe9, 0x9f, 0x57, 0x53, 0xf7, 0x0c, 0x32, 0xed, 0x01, 0xfb, 0x2e,
+                0x84, 0x9c, 0x9d, 0xc7, 0x3f, 0x80, 0xb5, 0xcb, 0xaa, 0xb4, 0x99, 0x2d, 0xd7, 0xe7,
+                0x38, 0xb9, 0x61, 0xfd, 0x75, 0x3f, 0x7c, 0x5b, 0x29, 0x24, 0xd1, 0xd9, 0x63, 0x06,
+                0x61, 0x33, 0x92, 0x59, 0x28, 0x3e, 0x3a, 0x95, 0x3c, 0x57, 0xdf, 0x3a, 0x48, 0xca,
+                0x82, 0x71, 0xfc, 0x5f, 0x26, 0x4d, 0x6f, 0x15, 0xb6, 0xb3,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x73, 0xa2, 0x5e, 0xba, 0x9b, 0xd7, 0xa8, 0xed, 0x2b, 0x5b, 0x1b, 0x8d, 0x5a, 0x05,
+                0x6b, 0xde, 0x8d, 0x05, 0xe6, 0xa2, 0x80, 0x67, 0xb3, 0x84, 0x57, 0x91, 0xbe, 0xbf,
+                0xa7, 0xae, 0x2a, 0xcd, 0x36, 0x32, 0x6f, 0xe6, 0x27, 0xbe, 0xe8, 0x0e, 0x32, 0x92,
+                0xe0, 0xe5, 0x13, 0x2d, 0xe1, 0x6c, 0xa4, 0xf8, 0x1e, 0x5a, 0x6f, 0xc0, 0x9c, 0x95,
+                0xff, 0x13, 0xb5, 0x2e, 0x96, 0xb7, 0x89, 0x0f,
+            ],
+            ovk: [
+                0xf5, 0xe8, 0xde, 0xd8, 0x18, 0x92, 0x51, 0x1c, 0xc2, 0x85, 0x1b, 0x00, 0xb8, 0x32,
+                0x71, 0x2a, 0x6d, 0x3b, 0xa5, 0x66, 0x65, 0x17, 0xbc, 0xd3, 0x56, 0x76, 0x21, 0xa7,
+                0xcf, 0x84, 0x45, 0x58,
+            ],
+            default_d: [
+                0x81, 0xf2, 0x75, 0x7c, 0x53, 0x2e, 0xd3, 0xb6, 0x2e, 0x89, 0x01,
+            ],
+            default_pk_d: [
+                0x55, 0xdb, 0x72, 0x90, 0x07, 0x3b, 0xa0, 0x06, 0x66, 0xe8, 0x7d, 0x25, 0x61, 0xb8,
+                0x88, 0x3c, 0x66, 0x2c, 0x56, 0x78, 0xff, 0x27, 0x30, 0x2a, 0x82, 0xe2, 0x0a, 0x72,
+                0x01, 0x70, 0x89, 0x1a,
+            ],
+            v: 17209482587585417762,
+            rseed: [
+                0xfc, 0x54, 0x88, 0x62, 0xf5, 0xa0, 0x70, 0x94, 0xfd, 0x42, 0x8a, 0x7b, 0xbc, 0x15,
+                0xd7, 0xb3, 0x8d, 0x05, 0x36, 0x2c, 0x9c, 0xa9, 0x85, 0xf5, 0x8a, 0x76, 0x64, 0x7d,
+                0x2b, 0xe4, 0xc2, 0xcd,
+            ],
+            asset: [
+                0x67, 0x43, 0xf9, 0x3a, 0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3,
+                0x04, 0xfe, 0x32, 0xb2, 0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e,
+                0x7a, 0x59, 0x70, 0x2f,
+            ],
+            memo: [
+                0xff, 0x6b, 0x3d, 0x17, 0xd6, 0x87, 0x09, 0x71, 0xd7, 0xa0, 0x98, 0xba, 0xf7, 0x2c,
+                0x6f, 0x6f, 0x12, 0x14, 0xcf, 0x1f, 0xaa, 0xe4, 0x88, 0xbd, 0x7d, 0xe2, 0x59, 0xd3,
+                0x41, 0x5c, 0x2f, 0x0d, 0xde, 0xc7, 0x45, 0x70, 0x04, 0xf3, 0x57, 0x08, 0xd1, 0xec,
+                0xcc, 0xcc, 0x0d, 0xf6, 0x5a, 0x04, 0x94, 0x3a, 0xd5, 0xcb, 0xc1, 0x3f, 0x29, 0x5f,
+                0x00, 0x0f, 0xe0, 0x56, 0xc4, 0x0b, 0x2d, 0x88, 0xf2, 0x7d, 0xc3, 0x4c, 0xfe, 0xb8,
+                0x03, 0xbe, 0x34, 0x83, 0xa9, 0xeb, 0xf9, 0xb5, 0xa9, 0x02, 0x60, 0x57, 0x72, 0x5d,
+                0x63, 0xea, 0xd2, 0xc0, 0xc0, 0xff, 0x1f, 0xe2, 0x6a, 0xc1, 0xe7, 0xbd, 0xfc, 0xd6,
+                0xfa, 0xd8, 0x75, 0x84, 0x2d, 0x19, 0x4f, 0x33, 0x17, 0x50, 0x46, 0x2c, 0x06, 0xb8,
+                0xd7, 0x98, 0x2d, 0x67, 0x99, 0x5e, 0xd5, 0xd3, 0xae, 0x96, 0xa0, 0x5a, 0xe0, 0x06,
+                0x7f, 0x4e, 0xb1, 0xc7, 0xc9, 0x32, 0x31, 0xbd, 0x39, 0x77, 0x3c, 0xbe, 0x0a, 0x9d,
+                0x66, 0xb0, 0xc9, 0xaa, 0x8c, 0xff, 0x6a, 0x37, 0x6e, 0x1f, 0x37, 0x2e, 0xac, 0x6a,
+                0xc4, 0xe4, 0x6c, 0xc0, 0x94, 0x22, 0x45, 0xd4, 0xc2, 0xdc, 0xf0, 0x2d, 0x76, 0x40,
+                0xff, 0xcc, 0x5a, 0x6a, 0xc3, 0xa8, 0x7f, 0x5c, 0x41, 0x15, 0x51, 0xbc, 0xc2, 0xf2,
+                0x6c, 0xb9, 0x49, 0x61, 0xd5, 0x3f, 0x95, 0xdd, 0xb1, 0x9a, 0xe9, 0x30, 0xc8, 0xd7,
+                0x0f, 0x03, 0x1b, 0x29, 0xa5, 0xdf, 0x99, 0xff, 0x36, 0x69, 0x5e, 0x80, 0x2c, 0xbc,
+                0xb6, 0xb5, 0x8c, 0x1b, 0xa7, 0xed, 0x5e, 0xac, 0xfa, 0x76, 0x41, 0x4a, 0x41, 0xad,
+                0x4a, 0x44, 0xf7, 0x1f, 0x1b, 0x58, 0x0d, 0x34, 0xc3, 0xa9, 0x52, 0x92, 0x0b, 0x25,
+                0x4a, 0x14, 0x5f, 0xea, 0x51, 0x7f, 0x5b, 0x42, 0xb2, 0xf6, 0x5e, 0xcd, 0x0f, 0x82,
+                0x59, 0x54, 0x78, 0xd8, 0x0a, 0xe5, 0xc8, 0xce, 0xea, 0x12, 0xa1, 0x61, 0xcc, 0xbb,
+                0x5e, 0xac, 0x09, 0x99, 0x0f, 0xc6, 0x19, 0xa4, 0x60, 0x80, 0x43, 0x6d, 0xbd, 0x08,
+                0xd7, 0x47, 0x84, 0xaf, 0x00, 0x2d, 0x58, 0xe0, 0x6f, 0xaf, 0x7f, 0x3c, 0xea, 0xe7,
+                0xd3, 0x41, 0x9b, 0x1f, 0xca, 0x26, 0x5a, 0x55, 0x59, 0xcf, 0x9e, 0x2d, 0x3b, 0x60,
+                0x97, 0x8d, 0x81, 0xa6, 0x78, 0xb9, 0xed, 0x8e, 0x44, 0x86, 0xb4, 0xd1, 0x46, 0x09,
+                0xd6, 0xc1, 0x27, 0xc0, 0xc2, 0xfb, 0xff, 0xe3, 0x0a, 0x60, 0xf7, 0xbf, 0xf1, 0xd9,
+                0xfb, 0x83, 0x00, 0xed, 0x00, 0x92, 0x53, 0xba, 0x9b, 0x99, 0x6f, 0xa0, 0x52, 0x41,
+                0xb1, 0x0f, 0x5a, 0xc9, 0xa8, 0x40, 0x8e, 0x92, 0x5b, 0x62, 0x6b, 0xb2, 0x1a, 0x47,
+                0x1f, 0xe3, 0xbe, 0xde, 0x52, 0xbb, 0xa0, 0x97, 0xb2, 0xa9, 0x9a, 0x9b, 0xa5, 0xa8,
+                0x66, 0x58, 0xc3, 0xfd, 0x9e, 0xc5, 0x5b, 0xfa, 0x9b, 0x32, 0x85, 0x67, 0x25, 0x4a,
+                0xb3, 0x6d, 0x2c, 0x7f, 0x44, 0xd2, 0xc7, 0xe1, 0x3e, 0xb5, 0x4b, 0xeb, 0x70, 0xea,
+                0x8f, 0xa9, 0x4b, 0x6c, 0x6e, 0x01, 0x2d, 0x79, 0xe3, 0xf5, 0x36, 0x89, 0xc2, 0xb1,
+                0xa1, 0x8e, 0xaf, 0x2d, 0x47, 0x1d, 0x13, 0xc1, 0xab, 0x39, 0xd9, 0x19, 0x4a, 0xe8,
+                0x43, 0xab, 0x1d, 0x28, 0xff, 0xa8, 0xf6, 0x9d, 0xc7, 0xe1, 0x5c, 0xc3, 0x8b, 0x12,
+                0xe8, 0xfc, 0xd7, 0x92, 0x55, 0xb7, 0x21, 0x60, 0x56, 0xd9, 0xed, 0xb7, 0x48, 0x2f,
+                0xb9, 0x8a, 0xa0, 0x33, 0xb6, 0x5e, 0x51, 0xc1, 0xa0, 0x8b, 0x8a, 0x11, 0xd8, 0x4d,
+                0x04, 0x09, 0xb7, 0x34, 0xf4, 0x52, 0xaa, 0xf0, 0xd6, 0xb1, 0x8f, 0x50, 0x25, 0x86,
+                0x83, 0xd3, 0xf9, 0xa7, 0x6d, 0x39, 0x9f, 0xd0, 0x47, 0xee, 0xe2, 0x88, 0xbb, 0x45,
+                0x85, 0x85, 0x1d, 0xc9, 0x3e, 0xcc, 0xc6, 0x23,
+            ],
+            cv_net: [
+                0xe8, 0x06, 0x5c, 0x40, 0x96, 0xd3, 0x54, 0x33, 0x40, 0x01, 0x1f, 0x58, 0x90, 0xb1,
+                0x7e, 0xed, 0xd2, 0xa7, 0x06, 0x44, 0x07, 0x34, 0x78, 0x41, 0x01, 0xae, 0x2d, 0x8e,
+                0x87, 0xe5, 0x05, 0xad,
+            ],
+            rho: [
+                0xc2, 0x79, 0xfa, 0x9d, 0x1c, 0x84, 0x11, 0x93, 0xd3, 0x32, 0xf8, 0xcc, 0xf4, 0xd0,
+                0xb1, 0xe4, 0x56, 0x01, 0xa8, 0xaf, 0x66, 0x76, 0xd7, 0x62, 0xfb, 0xa7, 0x31, 0x33,
+                0x45, 0x89, 0x35, 0x14,
+            ],
+            cmx: [
+                0x6d, 0x29, 0x97, 0xd1, 0xce, 0x0a, 0x94, 0x9a, 0x63, 0x70, 0x0f, 0x46, 0x1b, 0x57,
+                0x12, 0xae, 0xeb, 0x43, 0xd4, 0x55, 0x04, 0xe3, 0x5b, 0xda, 0x16, 0x52, 0x97, 0x77,
+                0xc7, 0x4d, 0x19, 0x1b,
+            ],
+            esk: [
+                0x9d, 0xc4, 0xc8, 0xc0, 0x32, 0xd3, 0xbe, 0x66, 0xd2, 0x63, 0x6b, 0xa0, 0x02, 0x0c,
+                0x63, 0xf4, 0x26, 0x53, 0x29, 0xff, 0xac, 0x2a, 0xe6, 0x35, 0x57, 0x32, 0x63, 0xf4,
+                0x99, 0xbd, 0x4c, 0x13,
+            ],
+            ephemeral_key: [
+                0xe4, 0x76, 0x95, 0x86, 0x30, 0x4a, 0x6a, 0x9b, 0x3a, 0x2a, 0xef, 0x3a, 0xf5, 0x8b,
+                0x97, 0xda, 0xc2, 0xcc, 0x4a, 0xeb, 0x38, 0x9f, 0x68, 0xc1, 0x28, 0x87, 0x73, 0x1e,
+                0x0e, 0x12, 0xbc, 0x1e,
+            ],
+            shared_secret: [
+                0xf6, 0xba, 0x4b, 0x1f, 0xbe, 0x01, 0xfa, 0x2f, 0x1d, 0xd4, 0x09, 0x3c, 0x5c, 0xc4,
+                0x85, 0xa9, 0xbf, 0xd9, 0xef, 0x0f, 0x57, 0x89, 0x49, 0xd6, 0xe1, 0x00, 0xb0, 0x05,
+                0x5c, 0xb8, 0xf3, 0x31,
+            ],
+            k_enc: [
+                0xd3, 0xc2, 0x20, 0x51, 0x00, 0x3e, 0x88, 0x2a, 0x5d, 0xdd, 0xfb, 0x48, 0x23, 0xd6,
+                0x77, 0x26, 0x96, 0xa7, 0xe9, 0x9f, 0x26, 0xb1, 0xa6, 0xac, 0xd2, 0x4b, 0xee, 0xd5,
+                0xf2, 0x2f, 0x9f, 0xf8,
+            ],
+            p_enc: [
+                0x03, 0x81, 0xf2, 0x75, 0x7c, 0x53, 0x2e, 0xd3, 0xb6, 0x2e, 0x89, 0x01, 0x22, 0x92,
+                0x4c, 0xd1, 0x3b, 0x5d, 0xd4, 0xee, 0xfc, 0x54, 0x88, 0x62, 0xf5, 0xa0, 0x70, 0x94,
+                0xfd, 0x42, 0x8a, 0x7b, 0xbc, 0x15, 0xd7, 0xb3, 0x8d, 0x05, 0x36, 0x2c, 0x9c, 0xa9,
+                0x85, 0xf5, 0x8a, 0x76, 0x64, 0x7d, 0x2b, 0xe4, 0xc2, 0xcd, 0x67, 0x43, 0xf9, 0x3a,
+                0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3, 0x04, 0xfe, 0x32, 0xb2,
+                0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e, 0x7a, 0x59, 0x70, 0x2f,
+                0xff, 0x6b, 0x3d, 0x17, 0xd6, 0x87, 0x09, 0x71, 0xd7, 0xa0, 0x98, 0xba, 0xf7, 0x2c,
+                0x6f, 0x6f, 0x12, 0x14, 0xcf, 0x1f, 0xaa, 0xe4, 0x88, 0xbd, 0x7d, 0xe2, 0x59, 0xd3,
+                0x41, 0x5c, 0x2f, 0x0d, 0xde, 0xc7, 0x45, 0x70, 0x04, 0xf3, 0x57, 0x08, 0xd1, 0xec,
+                0xcc, 0xcc, 0x0d, 0xf6, 0x5a, 0x04, 0x94, 0x3a, 0xd5, 0xcb, 0xc1, 0x3f, 0x29, 0x5f,
+                0x00, 0x0f, 0xe0, 0x56, 0xc4, 0x0b, 0x2d, 0x88, 0xf2, 0x7d, 0xc3, 0x4c, 0xfe, 0xb8,
+                0x03, 0xbe, 0x34, 0x83, 0xa9, 0xeb, 0xf9, 0xb5, 0xa9, 0x02, 0x60, 0x57, 0x72, 0x5d,
+                0x63, 0xea, 0xd2, 0xc0, 0xc0, 0xff, 0x1f, 0xe2, 0x6a, 0xc1, 0xe7, 0xbd, 0xfc, 0xd6,
+                0xfa, 0xd8, 0x75, 0x84, 0x2d, 0x19, 0x4f, 0x33, 0x17, 0x50, 0x46, 0x2c, 0x06, 0xb8,
+                0xd7, 0x98, 0x2d, 0x67, 0x99, 0x5e, 0xd5, 0xd3, 0xae, 0x96, 0xa0, 0x5a, 0xe0, 0x06,
+                0x7f, 0x4e, 0xb1, 0xc7, 0xc9, 0x32, 0x31, 0xbd, 0x39, 0x77, 0x3c, 0xbe, 0x0a, 0x9d,
+                0x66, 0xb0, 0xc9, 0xaa, 0x8c, 0xff, 0x6a, 0x37, 0x6e, 0x1f, 0x37, 0x2e, 0xac, 0x6a,
+                0xc4, 0xe4, 0x6c, 0xc0, 0x94, 0x22, 0x45, 0xd4, 0xc2, 0xdc, 0xf0, 0x2d, 0x76, 0x40,
+                0xff, 0xcc, 0x5a, 0x6a, 0xc3, 0xa8, 0x7f, 0x5c, 0x41, 0x15, 0x51, 0xbc, 0xc2, 0xf2,
+                0x6c, 0xb9, 0x49, 0x61, 0xd5, 0x3f, 0x95, 0xdd, 0xb1, 0x9a, 0xe9, 0x30, 0xc8, 0xd7,
+                0x0f, 0x03, 0x1b, 0x29, 0xa5, 0xdf, 0x99, 0xff, 0x36, 0x69, 0x5e, 0x80, 0x2c, 0xbc,
+                0xb6, 0xb5, 0x8c, 0x1b, 0xa7, 0xed, 0x5e, 0xac, 0xfa, 0x76, 0x41, 0x4a, 0x41, 0xad,
+                0x4a, 0x44, 0xf7, 0x1f, 0x1b, 0x58, 0x0d, 0x34, 0xc3, 0xa9, 0x52, 0x92, 0x0b, 0x25,
+                0x4a, 0x14, 0x5f, 0xea, 0x51, 0x7f, 0x5b, 0x42, 0xb2, 0xf6, 0x5e, 0xcd, 0x0f, 0x82,
+                0x59, 0x54, 0x78, 0xd8, 0x0a, 0xe5, 0xc8, 0xce, 0xea, 0x12, 0xa1, 0x61, 0xcc, 0xbb,
+                0x5e, 0xac, 0x09, 0x99, 0x0f, 0xc6, 0x19, 0xa4, 0x60, 0x80, 0x43, 0x6d, 0xbd, 0x08,
+                0xd7, 0x47, 0x84, 0xaf, 0x00, 0x2d, 0x58, 0xe0, 0x6f, 0xaf, 0x7f, 0x3c, 0xea, 0xe7,
+                0xd3, 0x41, 0x9b, 0x1f, 0xca, 0x26, 0x5a, 0x55, 0x59, 0xcf, 0x9e, 0x2d, 0x3b, 0x60,
+                0x97, 0x8d, 0x81, 0xa6, 0x78, 0xb9, 0xed, 0x8e, 0x44, 0x86, 0xb4, 0xd1, 0x46, 0x09,
+                0xd6, 0xc1, 0x27, 0xc0, 0xc2, 0xfb, 0xff, 0xe3, 0x0a, 0x60, 0xf7, 0xbf, 0xf1, 0xd9,
+                0xfb, 0x83, 0x00, 0xed, 0x00, 0x92, 0x53, 0xba, 0x9b, 0x99, 0x6f, 0xa0, 0x52, 0x41,
+                0xb1, 0x0f, 0x5a, 0xc9, 0xa8, 0x40, 0x8e, 0x92, 0x5b, 0x62, 0x6b, 0xb2, 0x1a, 0x47,
+                0x1f, 0xe3, 0xbe, 0xde, 0x52, 0xbb, 0xa0, 0x97, 0xb2, 0xa9, 0x9a, 0x9b, 0xa5, 0xa8,
+                0x66, 0x58, 0xc3, 0xfd, 0x9e, 0xc5, 0x5b, 0xfa, 0x9b, 0x32, 0x85, 0x67, 0x25, 0x4a,
+                0xb3, 0x6d, 0x2c, 0x7f, 0x44, 0xd2, 0xc7, 0xe1, 0x3e, 0xb5, 0x4b, 0xeb, 0x70, 0xea,
+                0x8f, 0xa9, 0x4b, 0x6c, 0x6e, 0x01, 0x2d, 0x79, 0xe3, 0xf5, 0x36, 0x89, 0xc2, 0xb1,
+                0xa1, 0x8e, 0xaf, 0x2d, 0x47, 0x1d, 0x13, 0xc1, 0xab, 0x39, 0xd9, 0x19, 0x4a, 0xe8,
+                0x43, 0xab, 0x1d, 0x28, 0xff, 0xa8, 0xf6, 0x9d, 0xc7, 0xe1, 0x5c, 0xc3, 0x8b, 0x12,
+                0xe8, 0xfc, 0xd7, 0x92, 0x55, 0xb7, 0x21, 0x60, 0x56, 0xd9, 0xed, 0xb7, 0x48, 0x2f,
+                0xb9, 0x8a, 0xa0, 0x33, 0xb6, 0x5e, 0x51, 0xc1, 0xa0, 0x8b, 0x8a, 0x11, 0xd8, 0x4d,
+                0x04, 0x09, 0xb7, 0x34, 0xf4, 0x52, 0xaa, 0xf0, 0xd6, 0xb1, 0x8f, 0x50, 0x25, 0x86,
+                0x83, 0xd3, 0xf9, 0xa7, 0x6d, 0x39, 0x9f, 0xd0, 0x47, 0xee, 0xe2, 0x88, 0xbb, 0x45,
+                0x85, 0x85, 0x1d, 0xc9, 0x3e, 0xcc, 0xc6, 0x23,
+            ],
+            c_enc: [
+                0x73, 0x29, 0xa0, 0xa5, 0x6a, 0x14, 0x4b, 0x04, 0x2c, 0x1e, 0xad, 0x91, 0x80, 0xac,
+                0x54, 0xda, 0xc6, 0xc5, 0x5c, 0xf4, 0xc2, 0x2f, 0xbe, 0x7c, 0xde, 0x99, 0x96, 0x0b,
+                0xc6, 0x20, 0xd4, 0xdd, 0x60, 0xe4, 0xbf, 0x18, 0xa0, 0xea, 0x7a, 0xd9, 0x09, 0x3b,
+                0xcd, 0x3f, 0xf6, 0xd1, 0x61, 0x1c, 0x56, 0x5f, 0x88, 0xe7, 0xad, 0xc7, 0x88, 0x7c,
+                0x34, 0x4d, 0x78, 0x79, 0x73, 0x3d, 0x26, 0x30, 0xbd, 0x45, 0x07, 0x25, 0xcd, 0xfc,
+                0xef, 0x8f, 0xe4, 0x0f, 0xf0, 0xdc, 0x6f, 0x45, 0x9e, 0xc6, 0x67, 0x38, 0x5a, 0x94,
+                0xfb, 0x63, 0x44, 0x5a, 0x61, 0xc7, 0x3d, 0x9d, 0x16, 0x1b, 0x77, 0x06, 0xf6, 0xb3,
+                0x26, 0xf4, 0x07, 0xc2, 0xde, 0x59, 0xe3, 0xe6, 0x01, 0xdb, 0xa0, 0x00, 0xe7, 0x73,
+                0x81, 0x5d, 0xb0, 0x97, 0x22, 0xe9, 0xbd, 0x23, 0x07, 0x4d, 0x20, 0x6d, 0xbe, 0xfd,
+                0x0b, 0x7f, 0x8b, 0x55, 0x14, 0xee, 0x62, 0x46, 0xb5, 0xde, 0x97, 0x68, 0xad, 0x50,
+                0x18, 0x17, 0xa4, 0x42, 0x04, 0x87, 0x07, 0x78, 0x61, 0xa0, 0x6c, 0xf5, 0xfa, 0xa0,
+                0xae, 0x0d, 0xf9, 0x03, 0x02, 0x51, 0xa9, 0xe3, 0x9e, 0x7c, 0xde, 0x48, 0x3e, 0xd8,
+                0x28, 0xd8, 0xb2, 0x7e, 0xbd, 0x6d, 0xa9, 0xca, 0x96, 0x54, 0xaf, 0xc1, 0xdf, 0x94,
+                0x00, 0xb2, 0xbe, 0xc7, 0x60, 0xfb, 0x26, 0x00, 0xa4, 0x53, 0x67, 0x3f, 0x6e, 0x7c,
+                0x89, 0x4b, 0x9c, 0xcd, 0x8a, 0x57, 0x2d, 0x24, 0xa5, 0x47, 0x31, 0x22, 0xfe, 0x40,
+                0x06, 0xe8, 0x0c, 0x9a, 0x97, 0x5e, 0x93, 0xbe, 0xc5, 0x7e, 0xbc, 0x4c, 0x44, 0xb2,
+                0x8e, 0xb0, 0x1f, 0xbc, 0xb2, 0xb2, 0xde, 0x55, 0x9b, 0xf0, 0x2d, 0x7b, 0x2c, 0xe4,
+                0xf3, 0xd1, 0x1e, 0x86, 0xcb, 0xaa, 0x10, 0x00, 0xee, 0xbd, 0x0d, 0x1b, 0x58, 0x8c,
+                0x99, 0xd7, 0xf9, 0xd9, 0x57, 0xc6, 0x4e, 0x0a, 0x1e, 0x59, 0x67, 0x66, 0xe7, 0x6c,
+                0x0e, 0xdc, 0xc6, 0xd9, 0xef, 0x34, 0x58, 0x74, 0x52, 0x04, 0x46, 0x39, 0x48, 0xd9,
+                0x78, 0xd1, 0x3c, 0x4b, 0xc0, 0xf4, 0x2c, 0xc9, 0xb8, 0x93, 0x65, 0x27, 0x71, 0xf6,
+                0xd1, 0x17, 0x7c, 0x78, 0x58, 0xf5, 0x77, 0x03, 0xec, 0x38, 0x3c, 0x3b, 0xad, 0x82,
+                0x1b, 0x2f, 0x82, 0x87, 0x9c, 0x3e, 0x1d, 0x39, 0x91, 0xd2, 0x09, 0xb5, 0xc8, 0x94,
+                0xc4, 0x65, 0xdd, 0x5e, 0xd9, 0x57, 0x19, 0x27, 0x2f, 0x9f, 0x03, 0x4c, 0xd9, 0x41,
+                0xa0, 0x32, 0x33, 0xe1, 0x10, 0xd5, 0x80, 0xc1, 0x93, 0xc1, 0x9a, 0x92, 0x91, 0x19,
+                0x45, 0x5a, 0xa6, 0x2e, 0x10, 0x35, 0x78, 0xa2, 0xd6, 0x46, 0x06, 0x26, 0xba, 0x04,
+                0x37, 0x82, 0xb8, 0xd1, 0x3a, 0x31, 0x4e, 0x51, 0xf4, 0xa2, 0x81, 0x59, 0x32, 0x5f,
+                0xbb, 0x35, 0xbe, 0xbb, 0xba, 0xf5, 0x27, 0x25, 0x64, 0xa7, 0xf5, 0x3f, 0x4c, 0x38,
+                0xb0, 0xf6, 0xea, 0xed, 0x1a, 0xfc, 0x71, 0x31, 0x59, 0x87, 0xac, 0xbc, 0x95, 0x91,
+                0x82, 0xab, 0xd3, 0xee, 0x9d, 0x87, 0x18, 0xc2, 0x26, 0x2f, 0x53, 0x1b, 0xfb, 0x57,
+                0x1b, 0xb7, 0x4e, 0x9a, 0xf3, 0x63, 0x61, 0x36, 0x75, 0xce, 0xed, 0x6f, 0x97, 0xbe,
+                0x67, 0x4c, 0x43, 0xf2, 0xad, 0x13, 0xdf, 0x86, 0x8d, 0xf6, 0xd4, 0x6f, 0x80, 0x72,
+                0x6b, 0xe7, 0x88, 0x79, 0x04, 0xdf, 0x5b, 0x6b, 0xb5, 0x15, 0x7a, 0x87, 0x42, 0x06,
+                0xe1, 0x77, 0x8a, 0x5d, 0x08, 0x4f, 0xd7, 0x60, 0x98, 0x6d, 0xb8, 0x39, 0xb0, 0xd9,
+                0x6c, 0xcd, 0x41, 0x34, 0x38, 0xef, 0x02, 0xc7, 0x9e, 0xba, 0xc9, 0xe7, 0x49, 0xf8,
+                0x93, 0x60, 0xb7, 0x5d, 0xcd, 0x1e, 0xb7, 0x73, 0x94, 0x73, 0xe3, 0x1f, 0xa9, 0xca,
+                0xe4, 0x94, 0x30, 0x6e, 0xa4, 0x82, 0x4a, 0xb4, 0xa9, 0xbf, 0x92, 0x5d, 0xb7, 0x4c,
+                0xf3, 0xdb, 0xac, 0x38, 0x93, 0xe7, 0xf0, 0x71, 0x00, 0x77, 0xff, 0x37, 0x90, 0x2d,
+                0x18, 0x7f, 0xce, 0xbe, 0xf9, 0x76, 0xd6, 0x2c, 0xae, 0xfd, 0xcc, 0x14, 0x8c, 0x68,
+                0xd7, 0x7e, 0x3e, 0xb2, 0x1d, 0xd5, 0x0c, 0x34, 0x01, 0x08, 0x34, 0x23, 0xf0, 0x38,
+                0x11, 0x73, 0x0b, 0xc5, 0xf8, 0x14, 0xe0, 0x99, 0x02, 0xf0, 0x60, 0x80, 0xbf, 0xb4,
+                0x8b, 0x34, 0x1e, 0xce, 0x80, 0xac, 0x29, 0xcb, 0x41, 0xe3, 0x20, 0x9d, 0x07, 0x9a,
+                0xc8, 0x4e, 0x85, 0x1b, 0xfb, 0x26, 0xdd, 0x39, 0xd9, 0x66, 0x2a, 0x11, 0x90, 0x28,
+                0x17, 0xb0, 0x8d, 0xa3, 0x89, 0x7a, 0x5c, 0x87, 0x62, 0x22,
+            ],
+            ock: [
+                0x1b, 0xa4, 0xac, 0xd7, 0x75, 0x10, 0xc4, 0xf0, 0xc7, 0x66, 0xad, 0xf7, 0xc7, 0xdf,
+                0x1d, 0x1c, 0x54, 0xd5, 0xbc, 0xe3, 0xd6, 0x0a, 0xf3, 0x5e, 0x8d, 0xd4, 0x8f, 0xdd,
+                0x04, 0xa7, 0x8c, 0x0b,
+            ],
+            op: [
+                0x55, 0xdb, 0x72, 0x90, 0x07, 0x3b, 0xa0, 0x06, 0x66, 0xe8, 0x7d, 0x25, 0x61, 0xb8,
+                0x88, 0x3c, 0x66, 0x2c, 0x56, 0x78, 0xff, 0x27, 0x30, 0x2a, 0x82, 0xe2, 0x0a, 0x72,
+                0x01, 0x70, 0x89, 0x1a, 0x9d, 0xc4, 0xc8, 0xc0, 0x32, 0xd3, 0xbe, 0x66, 0xd2, 0x63,
+                0x6b, 0xa0, 0x02, 0x0c, 0x63, 0xf4, 0x26, 0x53, 0x29, 0xff, 0xac, 0x2a, 0xe6, 0x35,
+                0x57, 0x32, 0x63, 0xf4, 0x99, 0xbd, 0x4c, 0x13,
+            ],
+            c_out: [
+                0x43, 0x0d, 0xaa, 0x6b, 0x75, 0x63, 0x22, 0x80, 0xd5, 0xe6, 0xda, 0xcb, 0xd2, 0xa0,
+                0xff, 0xe2, 0xaf, 0x98, 0x60, 0xc8, 0x3a, 0x3d, 0x2a, 0x87, 0xf1, 0x79, 0x62, 0x88,
+                0xeb, 0xed, 0x64, 0xd0, 0xcd, 0xc4, 0x60, 0xe2, 0xc8, 0x61, 0xc4, 0xf9, 0x38, 0x7d,
+                0x92, 0x59, 0xfc, 0x60, 0x01, 0xac, 0xd0, 0xe7, 0x6f, 0x3b, 0x0f, 0xdb, 0x5d, 0xac,
+                0x97, 0x4c, 0x26, 0xb5, 0x1b, 0x85, 0x9f, 0xab, 0xe0, 0x2e, 0xab, 0xae, 0x96, 0x8a,
+                0xab, 0x2e, 0x5e, 0x61, 0xef, 0xc2, 0xd4, 0x46, 0x2c, 0x1e,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xa4, 0xd7, 0x9c, 0x81, 0x9a, 0x6c, 0x5e, 0x01, 0x67, 0xfc, 0xa9, 0x8c, 0xe2, 0x62,
+                0x98, 0x15, 0xf9, 0xba, 0xc9, 0x26, 0xb6, 0x27, 0x18, 0xcf, 0xbe, 0x50, 0x45, 0xd9,
+                0x2d, 0xd7, 0x1c, 0xd3, 0x36, 0x75, 0xd5, 0x56, 0xe0, 0x77, 0x1e, 0x40, 0xcc, 0x3d,
+                0x61, 0x8d, 0x9b, 0xda, 0x13, 0x2f, 0x13, 0x95, 0x3d, 0x82, 0x43, 0x2e, 0x81, 0x59,
+                0x4a, 0x97, 0x1e, 0x98, 0xb0, 0x71, 0x40, 0x39,
+            ],
+            ovk: [
+                0x67, 0x79, 0x9a, 0x90, 0x01, 0xa2, 0xed, 0x36, 0x76, 0xa8, 0xb4, 0x03, 0xae, 0x25,
+                0xff, 0xd7, 0x72, 0xf7, 0x08, 0x1e, 0x9a, 0x32, 0xbc, 0xc1, 0xc5, 0xe2, 0xed, 0xd4,
+                0xe2, 0xa6, 0x57, 0x6b,
+            ],
+            default_d: [
+                0xdd, 0xb7, 0xc5, 0xbc, 0x4d, 0xe9, 0xdf, 0x52, 0x1b, 0xb0, 0x4b,
+            ],
+            default_pk_d: [
+                0x65, 0x3d, 0x07, 0xc9, 0x07, 0x94, 0x6a, 0xc3, 0x02, 0x0e, 0xbd, 0xe1, 0xb4, 0xf6,
+                0x10, 0x21, 0x0c, 0x30, 0xc4, 0x50, 0xe4, 0x27, 0x12, 0x65, 0xa0, 0x5d, 0x6e, 0xce,
+                0x44, 0x6d, 0xf4, 0x39,
+            ],
+            v: 7122345086698755501,
+            rseed: [
+                0x2d, 0xd4, 0x17, 0xdf, 0x26, 0xdc, 0xd2, 0x20, 0xf2, 0xb7, 0x31, 0x77, 0x2b, 0x43,
+                0x9e, 0x96, 0xd6, 0x14, 0xe1, 0xfa, 0xcb, 0x48, 0x6c, 0x7a, 0x7d, 0x51, 0x71, 0xb1,
+                0xde, 0x35, 0x9f, 0x6a,
+            ],
+            asset: [
+                0x67, 0x43, 0xf9, 0x3a, 0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3,
+                0x04, 0xfe, 0x32, 0xb2, 0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e,
+                0x7a, 0x59, 0x70, 0x2f,
+            ],
+            memo: [
+                0xff, 0xd3, 0xa9, 0x6f, 0x64, 0x9c, 0x96, 0x91, 0x02, 0xa1, 0x96, 0x4f, 0xb4, 0xb4,
+                0xa1, 0xa4, 0x27, 0x9c, 0x68, 0xe6, 0xc3, 0x72, 0xe4, 0x21, 0x87, 0xd7, 0x54, 0xe8,
+                0x04, 0xa6, 0x16, 0x53, 0x09, 0x20, 0x69, 0xfb, 0x9b, 0x6d, 0x25, 0x26, 0x68, 0x90,
+                0x80, 0x8b, 0x01, 0x5d, 0xf2, 0x8c, 0x80, 0x10, 0x65, 0xda, 0x6f, 0xeb, 0xdc, 0x1a,
+                0x56, 0xbf, 0xd0, 0x02, 0x62, 0x5a, 0xcf, 0xaa, 0x53, 0x73, 0xfd, 0xe1, 0x49, 0xc1,
+                0xcf, 0xc3, 0x64, 0x9b, 0x48, 0x69, 0x69, 0x6d, 0x44, 0xec, 0xb1, 0x24, 0x79, 0xc5,
+                0xeb, 0xef, 0x99, 0x5f, 0x10, 0x02, 0x9f, 0x8b, 0x53, 0x0e, 0xeb, 0x3f, 0xdc, 0x2e,
+                0x50, 0xe8, 0x75, 0x7f, 0xc0, 0xbb, 0x9e, 0x26, 0x30, 0x23, 0xdb, 0x82, 0xf8, 0x78,
+                0xd9, 0xac, 0x7f, 0xfb, 0x0b, 0xd4, 0x39, 0x1d, 0xf1, 0xd8, 0x79, 0x89, 0x9a, 0x3e,
+                0xf5, 0x7b, 0xfd, 0x0d, 0x1f, 0x77, 0x55, 0x64, 0x8e, 0xdd, 0x85, 0xbb, 0x05, 0x2a,
+                0x6e, 0xdf, 0x71, 0xcd, 0x26, 0x28, 0xc9, 0x87, 0x42, 0x9f, 0x36, 0xdc, 0x50, 0x5c,
+                0xcc, 0x43, 0xf3, 0x0e, 0x7a, 0x86, 0x9c, 0x9e, 0x25, 0x5e, 0x2a, 0xf9, 0xfc, 0xf3,
+                0x0c, 0x12, 0x17, 0x96, 0xd1, 0x90, 0x00, 0x09, 0x60, 0xcb, 0x6f, 0xe2, 0xf1, 0xbf,
+                0x24, 0x61, 0x18, 0xb4, 0x98, 0xf3, 0x24, 0x7f, 0x9d, 0x48, 0x4c, 0x73, 0xcf, 0x09,
+                0x39, 0x30, 0x39, 0xe4, 0x53, 0x26, 0xb8, 0xff, 0xff, 0xb3, 0xe7, 0xe6, 0x15, 0x9c,
+                0x46, 0x69, 0x9f, 0x10, 0x07, 0x92, 0xd4, 0x67, 0x29, 0x50, 0x34, 0x8a, 0x90, 0x55,
+                0x2e, 0x45, 0x94, 0x3b, 0xee, 0xac, 0xf0, 0x3f, 0x32, 0x16, 0xf9, 0x4e, 0x27, 0x4d,
+                0x63, 0xd6, 0x37, 0xd9, 0xf1, 0x90, 0xe8, 0xa2, 0x66, 0xcd, 0xee, 0xf1, 0x53, 0x53,
+                0x0b, 0xee, 0x5c, 0xb8, 0x35, 0x52, 0x60, 0x50, 0x5c, 0x2c, 0x2e, 0x5d, 0x99, 0x0f,
+                0xff, 0xdc, 0x34, 0xec, 0x0f, 0xf7, 0xf1, 0xaf, 0x81, 0xb2, 0x4c, 0xed, 0x0e, 0xfa,
+                0x62, 0x13, 0xda, 0x6c, 0x7c, 0x60, 0xc4, 0x87, 0xf5, 0xf7, 0xb0, 0x3f, 0x81, 0x60,
+                0xa0, 0x57, 0xf4, 0x6d, 0x05, 0xbf, 0x82, 0x18, 0xb3, 0xad, 0xd9, 0xc0, 0x68, 0x93,
+                0xbd, 0x02, 0xdb, 0x9b, 0x61, 0x19, 0x1d, 0xfb, 0x13, 0x3b, 0xfa, 0xbe, 0x48, 0x58,
+                0xe4, 0x7a, 0x4c, 0xc3, 0x2e, 0x41, 0x6e, 0xc0, 0x8b, 0x8a, 0xc7, 0x91, 0x5a, 0x43,
+                0x73, 0x3f, 0x44, 0x06, 0xe9, 0xd9, 0x67, 0xc5, 0x60, 0xf3, 0x44, 0xd7, 0xe9, 0x04,
+                0xa2, 0x80, 0x45, 0xd9, 0x9f, 0x3a, 0xf8, 0xc8, 0x2e, 0x97, 0xe1, 0xb9, 0xc1, 0xb2,
+                0x05, 0xe5, 0x85, 0xfb, 0xeb, 0xb4, 0x8f, 0xaf, 0x58, 0xf1, 0xb6, 0x5d, 0xca, 0x24,
+                0x97, 0xe0, 0x9a, 0x70, 0xaa, 0xd4, 0x86, 0x5f, 0x85, 0x71, 0x5a, 0x28, 0x0e, 0x18,
+                0x6f, 0x3f, 0xc1, 0x74, 0x0d, 0x81, 0x84, 0xd3, 0x3e, 0x83, 0x22, 0x16, 0x95, 0x21,
+                0xcd, 0xc1, 0x32, 0x21, 0x29, 0x39, 0xc8, 0x4a, 0x10, 0x89, 0x64, 0xe2, 0xde, 0x74,
+                0xb6, 0xea, 0x55, 0xb4, 0xcb, 0x8f, 0x6f, 0x9b, 0xee, 0x98, 0xb1, 0x0d, 0x41, 0x51,
+                0x09, 0x45, 0x5f, 0x48, 0xb7, 0x76, 0x08, 0x2d, 0xc3, 0x0b, 0x4b, 0xc7, 0x34, 0x77,
+                0x07, 0x55, 0x11, 0x70, 0x03, 0x08, 0x15, 0x8c, 0xe2, 0xf2, 0xf9, 0xbf, 0x0f, 0x69,
+                0x1b, 0x2c, 0xe5, 0x3e, 0x61, 0x14, 0x2c, 0xb7, 0x40, 0xc1, 0x5b, 0x7b, 0x62, 0x3c,
+                0xf4, 0x8b, 0x3f, 0x7b, 0xfe, 0xfa, 0x31, 0xbc, 0xdc, 0x66, 0x5c, 0x6d, 0x71, 0x23,
+                0xe9, 0x53, 0x50, 0x81, 0x13, 0x75, 0x94, 0x7b, 0x05, 0x5a, 0x43, 0xdb, 0x07, 0xe0,
+                0x3f, 0x33, 0x62, 0x7d, 0xf5, 0xc6, 0x38, 0xbf,
+            ],
+            cv_net: [
+                0x00, 0x55, 0xf3, 0x5c, 0x6c, 0x82, 0x62, 0xac, 0x74, 0xfe, 0x27, 0xd7, 0x2a, 0x33,
+                0xbd, 0xb9, 0x6f, 0x1c, 0xe0, 0x57, 0xc3, 0x30, 0xd1, 0xcc, 0xba, 0x2f, 0x7d, 0xa8,
+                0x71, 0x55, 0x00, 0xb5,
+            ],
+            rho: [
+                0xea, 0x38, 0x44, 0x75, 0x9a, 0x9a, 0x1c, 0xc5, 0x28, 0xb2, 0x95, 0xce, 0x70, 0x13,
+                0x7a, 0x85, 0xf9, 0xf0, 0x8e, 0x41, 0xa5, 0xc7, 0xc1, 0xca, 0xc1, 0x55, 0xa6, 0x69,
+                0xa3, 0x18, 0x53, 0x3e,
+            ],
+            cmx: [
+                0x6a, 0xba, 0x28, 0x10, 0x5b, 0xc0, 0x72, 0xc5, 0x2a, 0xb8, 0xa3, 0x14, 0x79, 0x7f,
+                0xf8, 0x66, 0x66, 0xdf, 0xb7, 0xcd, 0x8a, 0x2a, 0xe1, 0x7c, 0x58, 0x5f, 0xb7, 0xb6,
+                0x51, 0x5b, 0x97, 0x1c,
+            ],
+            esk: [
+                0x03, 0xfb, 0x79, 0x43, 0x75, 0x27, 0x5d, 0x23, 0xd1, 0x58, 0xd5, 0x64, 0x6b, 0xc4,
+                0x63, 0xa8, 0xb7, 0x38, 0xbc, 0x79, 0x38, 0xf6, 0x0d, 0xfb, 0x15, 0x5b, 0xef, 0x4d,
+                0x46, 0x1e, 0xec, 0x29,
+            ],
+            ephemeral_key: [
+                0x95, 0x9b, 0xea, 0x8e, 0x11, 0x96, 0x8b, 0x0f, 0x34, 0x3c, 0x04, 0xcd, 0x6d, 0x50,
+                0x16, 0xfc, 0xd4, 0x33, 0x90, 0x75, 0x36, 0xa2, 0x46, 0xba, 0x1c, 0x5d, 0x3e, 0x88,
+                0x97, 0xf3, 0x23, 0x1c,
+            ],
+            shared_secret: [
+                0xe2, 0x69, 0x19, 0xb4, 0x0c, 0x70, 0xaf, 0x74, 0x1d, 0xf9, 0x04, 0x51, 0x72, 0x55,
+                0x03, 0x58, 0x89, 0xee, 0x5a, 0x44, 0x42, 0x6d, 0x6a, 0xb8, 0x5c, 0x07, 0x4b, 0x86,
+                0x2b, 0xa0, 0x63, 0x08,
+            ],
+            k_enc: [
+                0x09, 0xda, 0xc6, 0x51, 0x1c, 0x38, 0x44, 0x58, 0x7f, 0x82, 0x9c, 0x2f, 0x1e, 0xa0,
+                0x37, 0xa8, 0x1a, 0x8d, 0x54, 0x85, 0xed, 0x04, 0xea, 0xf2, 0x75, 0x80, 0x05, 0xb3,
+                0x2a, 0x20, 0x47, 0x0b,
+            ],
+            p_enc: [
+                0x03, 0xdd, 0xb7, 0xc5, 0xbc, 0x4d, 0xe9, 0xdf, 0x52, 0x1b, 0xb0, 0x4b, 0xad, 0x95,
+                0x6d, 0xdc, 0x1e, 0xa7, 0xd7, 0x62, 0x2d, 0xd4, 0x17, 0xdf, 0x26, 0xdc, 0xd2, 0x20,
+                0xf2, 0xb7, 0x31, 0x77, 0x2b, 0x43, 0x9e, 0x96, 0xd6, 0x14, 0xe1, 0xfa, 0xcb, 0x48,
+                0x6c, 0x7a, 0x7d, 0x51, 0x71, 0xb1, 0xde, 0x35, 0x9f, 0x6a, 0x67, 0x43, 0xf9, 0x3a,
+                0x6e, 0xbd, 0xa7, 0x2a, 0x8c, 0x7c, 0x5a, 0x2b, 0x7f, 0xa3, 0x04, 0xfe, 0x32, 0xb2,
+                0x9b, 0x4f, 0x70, 0x6a, 0xa8, 0xf7, 0x42, 0x0f, 0x3d, 0x8e, 0x7a, 0x59, 0x70, 0x2f,
+                0xff, 0xd3, 0xa9, 0x6f, 0x64, 0x9c, 0x96, 0x91, 0x02, 0xa1, 0x96, 0x4f, 0xb4, 0xb4,
+                0xa1, 0xa4, 0x27, 0x9c, 0x68, 0xe6, 0xc3, 0x72, 0xe4, 0x21, 0x87, 0xd7, 0x54, 0xe8,
+                0x04, 0xa6, 0x16, 0x53, 0x09, 0x20, 0x69, 0xfb, 0x9b, 0x6d, 0x25, 0x26, 0x68, 0x90,
+                0x80, 0x8b, 0x01, 0x5d, 0xf2, 0x8c, 0x80, 0x10, 0x65, 0xda, 0x6f, 0xeb, 0xdc, 0x1a,
+                0x56, 0xbf, 0xd0, 0x02, 0x62, 0x5a, 0xcf, 0xaa, 0x53, 0x73, 0xfd, 0xe1, 0x49, 0xc1,
+                0xcf, 0xc3, 0x64, 0x9b, 0x48, 0x69, 0x69, 0x6d, 0x44, 0xec, 0xb1, 0x24, 0x79, 0xc5,
+                0xeb, 0xef, 0x99, 0x5f, 0x10, 0x02, 0x9f, 0x8b, 0x53, 0x0e, 0xeb, 0x3f, 0xdc, 0x2e,
+                0x50, 0xe8, 0x75, 0x7f, 0xc0, 0xbb, 0x9e, 0x26, 0x30, 0x23, 0xdb, 0x82, 0xf8, 0x78,
+                0xd9, 0xac, 0x7f, 0xfb, 0x0b, 0xd4, 0x39, 0x1d, 0xf1, 0xd8, 0x79, 0x89, 0x9a, 0x3e,
+                0xf5, 0x7b, 0xfd, 0x0d, 0x1f, 0x77, 0x55, 0x64, 0x8e, 0xdd, 0x85, 0xbb, 0x05, 0x2a,
+                0x6e, 0xdf, 0x71, 0xcd, 0x26, 0x28, 0xc9, 0x87, 0x42, 0x9f, 0x36, 0xdc, 0x50, 0x5c,
+                0xcc, 0x43, 0xf3, 0x0e, 0x7a, 0x86, 0x9c, 0x9e, 0x25, 0x5e, 0x2a, 0xf9, 0xfc, 0xf3,
+                0x0c, 0x12, 0x17, 0x96, 0xd1, 0x90, 0x00, 0x09, 0x60, 0xcb, 0x6f, 0xe2, 0xf1, 0xbf,
+                0x24, 0x61, 0x18, 0xb4, 0x98, 0xf3, 0x24, 0x7f, 0x9d, 0x48, 0x4c, 0x73, 0xcf, 0x09,
+                0x39, 0x30, 0x39, 0xe4, 0x53, 0x26, 0xb8, 0xff, 0xff, 0xb3, 0xe7, 0xe6, 0x15, 0x9c,
+                0x46, 0x69, 0x9f, 0x10, 0x07, 0x92, 0xd4, 0x67, 0x29, 0x50, 0x34, 0x8a, 0x90, 0x55,
+                0x2e, 0x45, 0x94, 0x3b, 0xee, 0xac, 0xf0, 0x3f, 0x32, 0x16, 0xf9, 0x4e, 0x27, 0x4d,
+                0x63, 0xd6, 0x37, 0xd9, 0xf1, 0x90, 0xe8, 0xa2, 0x66, 0xcd, 0xee, 0xf1, 0x53, 0x53,
+                0x0b, 0xee, 0x5c, 0xb8, 0x35, 0x52, 0x60, 0x50, 0x5c, 0x2c, 0x2e, 0x5d, 0x99, 0x0f,
+                0xff, 0xdc, 0x34, 0xec, 0x0f, 0xf7, 0xf1, 0xaf, 0x81, 0xb2, 0x4c, 0xed, 0x0e, 0xfa,
+                0x62, 0x13, 0xda, 0x6c, 0x7c, 0x60, 0xc4, 0x87, 0xf5, 0xf7, 0xb0, 0x3f, 0x81, 0x60,
+                0xa0, 0x57, 0xf4, 0x6d, 0x05, 0xbf, 0x82, 0x18, 0xb3, 0xad, 0xd9, 0xc0, 0x68, 0x93,
+                0xbd, 0x02, 0xdb, 0x9b, 0x61, 0x19, 0x1d, 0xfb, 0x13, 0x3b, 0xfa, 0xbe, 0x48, 0x58,
+                0xe4, 0x7a, 0x4c, 0xc3, 0x2e, 0x41, 0x6e, 0xc0, 0x8b, 0x8a, 0xc7, 0x91, 0x5a, 0x43,
+                0x73, 0x3f, 0x44, 0x06, 0xe9, 0xd9, 0x67, 0xc5, 0x60, 0xf3, 0x44, 0xd7, 0xe9, 0x04,
+                0xa2, 0x80, 0x45, 0xd9, 0x9f, 0x3a, 0xf8, 0xc8, 0x2e, 0x97, 0xe1, 0xb9, 0xc1, 0xb2,
+                0x05, 0xe5, 0x85, 0xfb, 0xeb, 0xb4, 0x8f, 0xaf, 0x58, 0xf1, 0xb6, 0x5d, 0xca, 0x24,
+                0x97, 0xe0, 0x9a, 0x70, 0xaa, 0xd4, 0x86, 0x5f, 0x85, 0x71, 0x5a, 0x28, 0x0e, 0x18,
+                0x6f, 0x3f, 0xc1, 0x74, 0x0d, 0x81, 0x84, 0xd3, 0x3e, 0x83, 0x22, 0x16, 0x95, 0x21,
+                0xcd, 0xc1, 0x32, 0x21, 0x29, 0x39, 0xc8, 0x4a, 0x10, 0x89, 0x64, 0xe2, 0xde, 0x74,
+                0xb6, 0xea, 0x55, 0xb4, 0xcb, 0x8f, 0x6f, 0x9b, 0xee, 0x98, 0xb1, 0x0d, 0x41, 0x51,
+                0x09, 0x45, 0x5f, 0x48, 0xb7, 0x76, 0x08, 0x2d, 0xc3, 0x0b, 0x4b, 0xc7, 0x34, 0x77,
+                0x07, 0x55, 0x11, 0x70, 0x03, 0x08, 0x15, 0x8c, 0xe2, 0xf2, 0xf9, 0xbf, 0x0f, 0x69,
+                0x1b, 0x2c, 0xe5, 0x3e, 0x61, 0x14, 0x2c, 0xb7, 0x40, 0xc1, 0x5b, 0x7b, 0x62, 0x3c,
+                0xf4, 0x8b, 0x3f, 0x7b, 0xfe, 0xfa, 0x31, 0xbc, 0xdc, 0x66, 0x5c, 0x6d, 0x71, 0x23,
+                0xe9, 0x53, 0x50, 0x81, 0x13, 0x75, 0x94, 0x7b, 0x05, 0x5a, 0x43, 0xdb, 0x07, 0xe0,
+                0x3f, 0x33, 0x62, 0x7d, 0xf5, 0xc6, 0x38, 0xbf,
+            ],
+            c_enc: [
+                0x7a, 0x59, 0x87, 0x78, 0xa7, 0x28, 0x4d, 0x52, 0xa7, 0x47, 0x77, 0x4c, 0x54, 0xbd,
+                0x92, 0x57, 0xb3, 0xf1, 0x7a, 0xf1, 0x3e, 0xcc, 0x72, 0xc0, 0xe3, 0xcd, 0x95, 0xeb,
+                0xfa, 0xfa, 0xa3, 0x7d, 0x16, 0x65, 0x15, 0x53, 0xdd, 0x27, 0xf0, 0x1c, 0x9c, 0xf2,
+                0x4b, 0x62, 0xd7, 0xdc, 0xfd, 0x52, 0xfa, 0x4b, 0x2b, 0x3b, 0xd2, 0x1c, 0xf9, 0xbe,
+                0xf6, 0xc6, 0xc5, 0x47, 0x62, 0xfa, 0x2a, 0x61, 0x45, 0x53, 0xcd, 0x9b, 0x45, 0x3e,
+                0x23, 0xbe, 0x78, 0x88, 0x56, 0x69, 0x77, 0xf6, 0xc4, 0xe0, 0xe7, 0x7c, 0x90, 0xe6,
+                0x1b, 0x01, 0x1a, 0xe9, 0x95, 0x5e, 0x62, 0x87, 0x04, 0xd6, 0x20, 0x36, 0x6e, 0xda,
+                0xef, 0xcc, 0x17, 0x13, 0xc7, 0x48, 0xc5, 0xb3, 0x6a, 0x32, 0x76, 0x51, 0xaf, 0x94,
+                0xcf, 0x94, 0x82, 0x10, 0xb6, 0x10, 0x8b, 0xe4, 0x82, 0x5b, 0xe5, 0x75, 0x2e, 0x7f,
+                0xcd, 0xe1, 0x2d, 0x1a, 0x03, 0x74, 0xa3, 0x85, 0xeb, 0x58, 0xfa, 0xde, 0x07, 0x3e,
+                0x04, 0x87, 0xdc, 0x92, 0x17, 0x6c, 0x48, 0xc3, 0x6b, 0x7a, 0x2b, 0x34, 0x7a, 0x0f,
+                0x96, 0x87, 0x5a, 0x31, 0x2a, 0xd5, 0x17, 0x9d, 0xa3, 0xfc, 0x81, 0x9c, 0xf0, 0xd4,
+                0x8a, 0xb1, 0x46, 0xec, 0x2a, 0x2d, 0xd1, 0x45, 0xd7, 0x8d, 0x9d, 0x9f, 0x88, 0x84,
+                0x82, 0x16, 0x55, 0x7d, 0x6e, 0x28, 0x30, 0x33, 0x56, 0xea, 0xfb, 0x2d, 0xbb, 0xe4,
+                0xfd, 0x12, 0x24, 0x71, 0x37, 0x31, 0x73, 0x0e, 0xae, 0x6f, 0x52, 0x62, 0x5a, 0x59,
+                0xe5, 0xb6, 0x06, 0xd2, 0xb2, 0x77, 0xe4, 0x09, 0x7e, 0x4f, 0x54, 0x24, 0x56, 0x84,
+                0xeb, 0x3b, 0x64, 0xf5, 0x4d, 0xf6, 0x69, 0x7d, 0x6f, 0x39, 0x82, 0xba, 0xc4, 0x98,
+                0xdf, 0x5a, 0x14, 0x43, 0x4f, 0x2e, 0x51, 0xab, 0x4c, 0xc2, 0x9d, 0x6f, 0x31, 0x28,
+                0x8f, 0xf6, 0x67, 0x80, 0xb7, 0x89, 0xa8, 0x30, 0x6b, 0x20, 0xc6, 0x55, 0x3a, 0x52,
+                0x46, 0x35, 0xb6, 0xec, 0xb6, 0x79, 0xe5, 0x03, 0x09, 0x54, 0x02, 0x96, 0xed, 0xef,
+                0x53, 0x83, 0x31, 0x63, 0xc4, 0xa2, 0x86, 0x00, 0xd1, 0xca, 0xa8, 0x43, 0x7e, 0x6f,
+                0xb9, 0xce, 0xc4, 0xb9, 0xea, 0xf5, 0x66, 0xe1, 0x7b, 0xe8, 0xf8, 0xcc, 0x34, 0xcd,
+                0xdb, 0x35, 0x88, 0xce, 0xb2, 0xbf, 0xe8, 0x8c, 0xc3, 0xee, 0xb4, 0x1b, 0x92, 0x63,
+                0x1f, 0x13, 0xc5, 0xeb, 0xa6, 0x86, 0x30, 0xbf, 0xa5, 0x35, 0x31, 0x30, 0x06, 0x57,
+                0x49, 0x44, 0x83, 0x3c, 0xea, 0x59, 0xd9, 0xb2, 0xd1, 0x94, 0xd8, 0xc1, 0xac, 0xc1,
+                0xa4, 0x17, 0x62, 0xf8, 0x98, 0x09, 0xf7, 0x8d, 0xab, 0xe9, 0x9b, 0x95, 0xb5, 0xdd,
+                0xbe, 0xd1, 0xd0, 0x01, 0x03, 0x26, 0x84, 0x4f, 0x23, 0x04, 0x85, 0x84, 0xaa, 0x14,
+                0x66, 0x0f, 0xe2, 0x54, 0x9c, 0xbe, 0xe9, 0xaf, 0x4b, 0x63, 0xdd, 0xde, 0x1c, 0xec,
+                0x9f, 0x8d, 0x7c, 0xcb, 0xa6, 0x2a, 0x39, 0xf2, 0xf4, 0x48, 0x04, 0x96, 0xa1, 0x0f,
+                0x17, 0xe9, 0xf9, 0x12, 0xc6, 0xc0, 0xa1, 0x3d, 0xbd, 0x90, 0x32, 0x60, 0x42, 0x89,
+                0x4b, 0xcd, 0xf6, 0xa8, 0x07, 0x32, 0xc5, 0xfb, 0x03, 0x09, 0xee, 0xbd, 0xc4, 0x34,
+                0x0c, 0x5e, 0xb5, 0x66, 0x41, 0x7c, 0xc6, 0xc8, 0xa6, 0xa6, 0x09, 0xdf, 0x5b, 0x41,
+                0xc6, 0xc2, 0x95, 0xd6, 0x47, 0x3d, 0xab, 0xc7, 0x4c, 0xbb, 0x34, 0xb5, 0x5b, 0xa7,
+                0x9a, 0x89, 0x46, 0x35, 0xa9, 0x00, 0x93, 0x27, 0xcc, 0x1e, 0x6d, 0x3e, 0x42, 0xba,
+                0x3c, 0xba, 0xfb, 0x32, 0x1b, 0xc0, 0xb2, 0xee, 0x28, 0xe4, 0x1e, 0xf3, 0xba, 0xec,
+                0xbe, 0x50, 0x46, 0x72, 0xf6, 0xe9, 0x35, 0x08, 0x66, 0x90, 0x87, 0xd5, 0x03, 0x34,
+                0x36, 0x41, 0xb5, 0x9b, 0x90, 0x6a, 0x56, 0x4b, 0x7b, 0x67, 0x53, 0xd6, 0x19, 0xee,
+                0xc4, 0xf5, 0xe8, 0x10, 0x62, 0x0e, 0x7b, 0x50, 0x65, 0x1a, 0xb6, 0x5e, 0x0a, 0x3d,
+                0xbb, 0x1d, 0x0a, 0xb7, 0x72, 0x1c, 0x5b, 0xf0, 0xd5, 0x40, 0xe1, 0x30, 0x2d, 0x8c,
+                0xce, 0x27, 0x07, 0x71, 0x91, 0x99, 0xfa, 0xa5, 0x32, 0x11, 0x06, 0xab, 0x06, 0x81,
+                0x6a, 0x8c, 0x04, 0x6e, 0x47, 0x8b, 0xd5, 0xc3, 0xb4, 0x8f, 0xe6, 0x65, 0xc8, 0xd5,
+                0x92, 0xfb, 0x30, 0x6b, 0xa9, 0x37, 0x10, 0x23, 0x30, 0xe4, 0x56, 0x48, 0xf1, 0xc1,
+                0x6f, 0x3d, 0x1a, 0x96, 0x0f, 0x2f, 0x5f, 0x8c, 0x4d, 0x00, 0x12, 0x07, 0x8f, 0x9c,
+                0xfd, 0xf6, 0xb6, 0x6d, 0xe9, 0x61, 0xca, 0x2e, 0x14, 0x0d,
+            ],
+            ock: [
+                0x4a, 0x25, 0x25, 0x4c, 0xcc, 0x44, 0x4e, 0xc6, 0x1c, 0x2b, 0xac, 0xeb, 0x2e, 0xe3,
+                0x97, 0x7a, 0x63, 0x32, 0x44, 0x9a, 0x3a, 0x53, 0xad, 0xd2, 0x31, 0xab, 0xf3, 0xd1,
+                0x8b, 0xb3, 0x29, 0x3d,
+            ],
+            op: [
+                0x65, 0x3d, 0x07, 0xc9, 0x07, 0x94, 0x6a, 0xc3, 0x02, 0x0e, 0xbd, 0xe1, 0xb4, 0xf6,
+                0x10, 0x21, 0x0c, 0x30, 0xc4, 0x50, 0xe4, 0x27, 0x12, 0x65, 0xa0, 0x5d, 0x6e, 0xce,
+                0x44, 0x6d, 0xf4, 0x39, 0x03, 0xfb, 0x79, 0x43, 0x75, 0x27, 0x5d, 0x23, 0xd1, 0x58,
+                0xd5, 0x64, 0x6b, 0xc4, 0x63, 0xa8, 0xb7, 0x38, 0xbc, 0x79, 0x38, 0xf6, 0x0d, 0xfb,
+                0x15, 0x5b, 0xef, 0x4d, 0x46, 0x1e, 0xec, 0x29,
+            ],
+            c_out: [
+                0x7b, 0xf4, 0x12, 0x7d, 0x22, 0xcc, 0x57, 0x35, 0x87, 0x51, 0x2f, 0xf8, 0x1e, 0x55,
+                0x3e, 0x3c, 0x98, 0x23, 0x5f, 0x51, 0xc7, 0x23, 0x7e, 0x9e, 0x76, 0x1a, 0x08, 0xf2,
+                0xe1, 0xe8, 0x0d, 0x04, 0x26, 0x98, 0xfc, 0x3b, 0x1d, 0x03, 0x18, 0xf1, 0xfd, 0xca,
+                0x8e, 0x41, 0xa3, 0x16, 0xd6, 0xaf, 0x3a, 0xc0, 0xc4, 0x0c, 0xe1, 0x99, 0x47, 0xa2,
+                0xba, 0xfe, 0x80, 0x4d, 0x46, 0x6e, 0xd0, 0x79, 0x82, 0x7f, 0xc1, 0x41, 0x91, 0xeb,
+                0xb5, 0x99, 0x17, 0x87, 0x49, 0xe9, 0xc4, 0x06, 0xaf, 0x26,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xdc, 0x10, 0x95, 0x20, 0x57, 0xc4, 0xbe, 0xaa, 0xd8, 0xaf, 0x37, 0xce, 0x4e, 0xee,
+                0x9b, 0x10, 0xed, 0x84, 0xf4, 0x6b, 0xad, 0xd4, 0x8e, 0x0a, 0x22, 0x9b, 0xe8, 0x41,
+                0x54, 0xa9, 0xbf, 0x75, 0x6b, 0xe0, 0x2e, 0xcf, 0xa9, 0xad, 0x6d, 0x9c, 0x02, 0xc8,
+                0xf9, 0x54, 0xcb, 0x15, 0x71, 0x7b, 0x79, 0x46, 0x1f, 0x00, 0x4b, 0xf1, 0xbc, 0x5c,
+                0x7e, 0x3f, 0xda, 0x73, 0x53, 0x7c, 0x1a, 0x0a,
+            ],
+            ovk: [
+                0x97, 0x74, 0x85, 0xcd, 0xdf, 0xbe, 0xd5, 0x93, 0x2f, 0x50, 0x7b, 0x79, 0x94, 0x7a,
+                0xdb, 0x2f, 0xad, 0x37, 0x61, 0x5a, 0xa7, 0x17, 0xdb, 0x5f, 0x29, 0x80, 0x99, 0xf2,
+                0x0f, 0x26, 0x3b, 0x35,
+            ],
+            default_d: [
+                0xf6, 0xb0, 0x18, 0xdf, 0xa7, 0x26, 0x31, 0x5b, 0x44, 0xcf, 0x9e,
+            ],
+            default_pk_d: [
+                0x05, 0x82, 0x53, 0xd4, 0x85, 0x76, 0x44, 0x88, 0x5e, 0x26, 0xa9, 0x09, 0xc8, 0x38,
+                0x59, 0x25, 0x23, 0x5a, 0x75, 0x29, 0x85, 0x44, 0x6e, 0x11, 0x69, 0x5f, 0x36, 0xc2,
+                0xe6, 0x84, 0x45, 0xbb,
+            ],
+            v: 2111628168871420429,
+            rseed: [
+                0xcc, 0x57, 0x9a, 0x7a, 0x8f, 0xff, 0x7c, 0xa7, 0xcf, 0x14, 0x5d, 0xfc, 0x13, 0xea,
+                0xfc, 0x34, 0x15, 0x3b, 0x2c, 0x3e, 0x8a, 0xfb, 0xe5, 0x34, 0x44, 0xd0, 0xc7, 0x3b,
+                0x3b, 0xd5, 0xbc, 0x87,
+            ],
+            asset: [
+                0xa9, 0x71, 0x5e, 0x65, 0xaf, 0x82, 0x67, 0x37, 0x3d, 0x34, 0x51, 0x67, 0x4f, 0xf0,
+                0x84, 0xef, 0xd9, 0x2c, 0xcf, 0x3b, 0xcc, 0x7a, 0xca, 0x14, 0x67, 0xb6, 0x32, 0x7e,
+                0x4f, 0x95, 0x22, 0xb2,
+            ],
+            memo: [
+                0xff, 0x0b, 0x01, 0xcd, 0x45, 0x79, 0x11, 0xe3, 0x56, 0x31, 0x3f, 0xd1, 0xda, 0xfb,
+                0x4c, 0x81, 0x51, 0x63, 0x4a, 0x01, 0xaf, 0xf7, 0xcf, 0x11, 0x6d, 0x43, 0x3c, 0x3d,
+                0x2b, 0x3a, 0xdd, 0xa9, 0xce, 0xbe, 0x18, 0xf7, 0xd1, 0x72, 0x44, 0x3e, 0x5e, 0x7b,
+                0x5a, 0xc9, 0xab, 0xe8, 0xdb, 0x22, 0x56, 0xd7, 0xeb, 0xe2, 0xff, 0x28, 0x02, 0x09,
+                0x39, 0x50, 0x38, 0x70, 0x59, 0x7b, 0x9a, 0x95, 0x58, 0x92, 0xc7, 0x38, 0x96, 0x50,
+                0xa2, 0xd4, 0x2e, 0xc9, 0x2b, 0xe7, 0x23, 0xfe, 0xdf, 0x2f, 0x2e, 0xde, 0x5a, 0x47,
+                0x2a, 0xa1, 0xe7, 0x4f, 0x33, 0xad, 0x41, 0x90, 0x15, 0x44, 0xed, 0xbb, 0xe3, 0xac,
+                0x46, 0x4c, 0xf4, 0x39, 0x19, 0x60, 0x15, 0xf4, 0xf2, 0x2a, 0xc2, 0xb8, 0xfc, 0x01,
+                0x49, 0x6b, 0xea, 0xb4, 0xd4, 0x59, 0x07, 0xf4, 0x79, 0x81, 0x2a, 0x25, 0x94, 0x31,
+                0xa2, 0xcb, 0xc9, 0x3d, 0x4f, 0x3b, 0x84, 0xe4, 0xdd, 0x36, 0x60, 0x20, 0x27, 0x3a,
+                0x67, 0x52, 0xe5, 0x01, 0xaf, 0x6f, 0xf1, 0xb7, 0x8d, 0xdc, 0x81, 0x7e, 0x6e, 0xa3,
+                0x51, 0xd6, 0x00, 0x6b, 0xec, 0xf8, 0xd2, 0xff, 0xb0, 0x39, 0x90, 0xf6, 0x77, 0x74,
+                0xa8, 0x1e, 0x05, 0xb7, 0xf4, 0xbb, 0xad, 0x85, 0x77, 0xfa, 0x27, 0xc9, 0xde, 0x64,
+                0xe1, 0xb1, 0x1d, 0xcf, 0x38, 0x4f, 0x59, 0x56, 0x44, 0x37, 0x48, 0x75, 0x5a, 0x9f,
+                0xc6, 0xf2, 0xa0, 0x0b, 0x10, 0xc3, 0x65, 0x7e, 0xba, 0xc0, 0x3b, 0xfc, 0x0b, 0x58,
+                0x7b, 0xef, 0x2f, 0x45, 0xec, 0x8a, 0xcd, 0xaa, 0x51, 0xc1, 0x43, 0xb0, 0xcb, 0x25,
+                0xb9, 0x14, 0x2c, 0x61, 0xbd, 0x79, 0x0a, 0x80, 0xd7, 0xc2, 0x3f, 0x90, 0xcc, 0x03,
+                0x49, 0x5b, 0x51, 0xe4, 0xd2, 0x84, 0x3e, 0x55, 0x7f, 0x9e, 0x25, 0x45, 0x10, 0x8c,
+                0x6c, 0x6f, 0xae, 0x35, 0x9f, 0x64, 0x5c, 0x27, 0x68, 0x91, 0xc0, 0xdc, 0xab, 0x3f,
+                0xaf, 0x18, 0x77, 0x00, 0xc0, 0x82, 0xdc, 0x47, 0x77, 0x40, 0xfb, 0x3f, 0x2c, 0xd7,
+                0xbb, 0x59, 0xfb, 0x35, 0x85, 0x54, 0xe9, 0x4c, 0x7e, 0x67, 0x8c, 0xe0, 0x1a, 0xeb,
+                0xf9, 0x4e, 0x51, 0x5e, 0x49, 0x72, 0x29, 0x67, 0x99, 0x5a, 0xea, 0x85, 0x8d, 0x64,
+                0xe7, 0x78, 0x9f, 0xf3, 0x06, 0x36, 0x95, 0x77, 0x22, 0x81, 0x80, 0x32, 0x6a, 0x5b,
+                0x0a, 0xf4, 0x75, 0xe2, 0x7a, 0x54, 0xb2, 0x07, 0xb4, 0x1f, 0x92, 0xe3, 0x76, 0x17,
+                0x0e, 0x3f, 0xb0, 0x05, 0x02, 0x82, 0x61, 0xc9, 0x9c, 0x2d, 0xbd, 0x0e, 0xed, 0xee,
+                0x87, 0x1c, 0x1c, 0x0f, 0x48, 0xb8, 0xe9, 0xb8, 0xe4, 0xbe, 0x77, 0xd1, 0xb7, 0x37,
+                0xfe, 0x21, 0xf0, 0xfa, 0x5a, 0x18, 0xeb, 0xb5, 0x27, 0x55, 0xb5, 0xa6, 0xcf, 0x61,
+                0x30, 0xfb, 0x56, 0x94, 0x4c, 0xfa, 0xb8, 0x75, 0x27, 0xc2, 0x50, 0xd1, 0x13, 0xb2,
+                0x9b, 0xca, 0xc9, 0xaa, 0xa1, 0x0c, 0x2e, 0x7d, 0xe4, 0x15, 0xed, 0xb0, 0x80, 0x6c,
+                0x6d, 0xa0, 0x30, 0x20, 0xa1, 0x34, 0xca, 0x7e, 0xcd, 0xc8, 0xda, 0x1b, 0xd5, 0x7a,
+                0x37, 0xf5, 0x5a, 0x46, 0x94, 0x0b, 0x45, 0xb2, 0x41, 0xb1, 0xc1, 0x6e, 0xe1, 0x00,
+                0x92, 0x7d, 0x1b, 0xd8, 0x60, 0xd4, 0x45, 0xa9, 0xde, 0x50, 0xd4, 0xc3, 0x84, 0xd6,
+                0xe1, 0xd0, 0x01, 0x08, 0x02, 0x6c, 0x0e, 0xa5, 0xeb, 0xbf, 0x0b, 0x72, 0xfb, 0xf5,
+                0xc3, 0x70, 0xbc, 0xe1, 0x8d, 0x3a, 0xcb, 0xc4, 0x65, 0x99, 0x09, 0x9b, 0xaa, 0xe1,
+                0xd8, 0x02, 0xf7, 0x73, 0x33, 0x49, 0x4a, 0x7a, 0xe1, 0x30, 0xfe, 0x86, 0xe8, 0xf8,
+                0x18, 0xf9, 0x26, 0x1a, 0x2d, 0xad, 0xb4, 0x12, 0x52, 0x29, 0xba, 0x0f, 0xfc, 0x0e,
+                0x70, 0x90, 0x32, 0x44, 0x30, 0xb5, 0x21, 0xa9,
+            ],
+            cv_net: [
+                0xba, 0x69, 0x9c, 0xe4, 0x21, 0x41, 0x85, 0x30, 0x94, 0xe2, 0x84, 0x00, 0x50, 0x17,
+                0x2c, 0x3b, 0x94, 0x21, 0x3e, 0x86, 0x47, 0x3b, 0x5e, 0x2f, 0xdd, 0x70, 0x97, 0x80,
+                0xbc, 0xca, 0x68, 0xb4,
+            ],
+            rho: [
+                0xf6, 0x5d, 0x22, 0x96, 0x09, 0x58, 0xd7, 0x28, 0x59, 0x60, 0x9c, 0x99, 0x46, 0xd8,
+                0xa9, 0x4a, 0x06, 0x04, 0xb8, 0x00, 0x6c, 0xc7, 0x94, 0xbc, 0xab, 0x57, 0x73, 0x49,
+                0xbc, 0xf8, 0x63, 0x37,
+            ],
+            cmx: [
+                0x85, 0xec, 0x16, 0xe8, 0x78, 0x77, 0x33, 0x37, 0x07, 0x9a, 0xec, 0xf3, 0x2c, 0x45,
+                0x5e, 0xbf, 0x16, 0x96, 0x8d, 0xa1, 0xd4, 0x34, 0x51, 0xb7, 0xa3, 0x06, 0x87, 0x6c,
+                0xa3, 0x08, 0xea, 0x3c,
+            ],
+            esk: [
+                0x05, 0x18, 0xdd, 0xc0, 0xc4, 0x7b, 0x7f, 0x77, 0xed, 0xcd, 0x39, 0x16, 0x0f, 0xe5,
+                0x67, 0x75, 0x1e, 0xb8, 0x4a, 0xa2, 0x1d, 0x33, 0xa6, 0x90, 0xe0, 0xd2, 0x9b, 0x35,
+                0x9a, 0xc4, 0xfa, 0x2c,
+            ],
+            ephemeral_key: [
+                0x10, 0x0d, 0xf0, 0x1d, 0x49, 0x86, 0x01, 0x21, 0x8a, 0x28, 0x6b, 0x8f, 0x4e, 0x54,
+                0xda, 0x9b, 0x3f, 0x14, 0x5c, 0x34, 0x70, 0xa9, 0xdb, 0xc4, 0x14, 0x48, 0x0a, 0xa8,
+                0xf2, 0xf4, 0x90, 0x9c,
+            ],
+            shared_secret: [
+                0x93, 0x68, 0xdd, 0x4f, 0x2a, 0xf6, 0x23, 0x34, 0xb8, 0x85, 0xb9, 0x6b, 0xc4, 0xc3,
+                0x8f, 0x10, 0x3a, 0xec, 0x25, 0x6b, 0xed, 0xc2, 0x8b, 0x5e, 0x2e, 0x10, 0x36, 0x4c,
+                0xdd, 0xf3, 0x84, 0xa4,
+            ],
+            k_enc: [
+                0x7a, 0xff, 0xfc, 0x6e, 0xae, 0x5d, 0x56, 0xb2, 0x7b, 0x86, 0xdb, 0x9e, 0xc8, 0xae,
+                0xc2, 0x70, 0xbb, 0x0a, 0xb7, 0x31, 0x23, 0xfd, 0x2a, 0x0b, 0x83, 0xf4, 0xef, 0x84,
+                0xc6, 0x98, 0xe1, 0x67,
+            ],
+            p_enc: [
+                0x03, 0xf6, 0xb0, 0x18, 0xdf, 0xa7, 0x26, 0x31, 0x5b, 0x44, 0xcf, 0x9e, 0x0d, 0x22,
+                0x4a, 0xb7, 0xa1, 0x02, 0x4e, 0x1d, 0xcc, 0x57, 0x9a, 0x7a, 0x8f, 0xff, 0x7c, 0xa7,
+                0xcf, 0x14, 0x5d, 0xfc, 0x13, 0xea, 0xfc, 0x34, 0x15, 0x3b, 0x2c, 0x3e, 0x8a, 0xfb,
+                0xe5, 0x34, 0x44, 0xd0, 0xc7, 0x3b, 0x3b, 0xd5, 0xbc, 0x87, 0xa9, 0x71, 0x5e, 0x65,
+                0xaf, 0x82, 0x67, 0x37, 0x3d, 0x34, 0x51, 0x67, 0x4f, 0xf0, 0x84, 0xef, 0xd9, 0x2c,
+                0xcf, 0x3b, 0xcc, 0x7a, 0xca, 0x14, 0x67, 0xb6, 0x32, 0x7e, 0x4f, 0x95, 0x22, 0xb2,
+                0xff, 0x0b, 0x01, 0xcd, 0x45, 0x79, 0x11, 0xe3, 0x56, 0x31, 0x3f, 0xd1, 0xda, 0xfb,
+                0x4c, 0x81, 0x51, 0x63, 0x4a, 0x01, 0xaf, 0xf7, 0xcf, 0x11, 0x6d, 0x43, 0x3c, 0x3d,
+                0x2b, 0x3a, 0xdd, 0xa9, 0xce, 0xbe, 0x18, 0xf7, 0xd1, 0x72, 0x44, 0x3e, 0x5e, 0x7b,
+                0x5a, 0xc9, 0xab, 0xe8, 0xdb, 0x22, 0x56, 0xd7, 0xeb, 0xe2, 0xff, 0x28, 0x02, 0x09,
+                0x39, 0x50, 0x38, 0x70, 0x59, 0x7b, 0x9a, 0x95, 0x58, 0x92, 0xc7, 0x38, 0x96, 0x50,
+                0xa2, 0xd4, 0x2e, 0xc9, 0x2b, 0xe7, 0x23, 0xfe, 0xdf, 0x2f, 0x2e, 0xde, 0x5a, 0x47,
+                0x2a, 0xa1, 0xe7, 0x4f, 0x33, 0xad, 0x41, 0x90, 0x15, 0x44, 0xed, 0xbb, 0xe3, 0xac,
+                0x46, 0x4c, 0xf4, 0x39, 0x19, 0x60, 0x15, 0xf4, 0xf2, 0x2a, 0xc2, 0xb8, 0xfc, 0x01,
+                0x49, 0x6b, 0xea, 0xb4, 0xd4, 0x59, 0x07, 0xf4, 0x79, 0x81, 0x2a, 0x25, 0x94, 0x31,
+                0xa2, 0xcb, 0xc9, 0x3d, 0x4f, 0x3b, 0x84, 0xe4, 0xdd, 0x36, 0x60, 0x20, 0x27, 0x3a,
+                0x67, 0x52, 0xe5, 0x01, 0xaf, 0x6f, 0xf1, 0xb7, 0x8d, 0xdc, 0x81, 0x7e, 0x6e, 0xa3,
+                0x51, 0xd6, 0x00, 0x6b, 0xec, 0xf8, 0xd2, 0xff, 0xb0, 0x39, 0x90, 0xf6, 0x77, 0x74,
+                0xa8, 0x1e, 0x05, 0xb7, 0xf4, 0xbb, 0xad, 0x85, 0x77, 0xfa, 0x27, 0xc9, 0xde, 0x64,
+                0xe1, 0xb1, 0x1d, 0xcf, 0x38, 0x4f, 0x59, 0x56, 0x44, 0x37, 0x48, 0x75, 0x5a, 0x9f,
+                0xc6, 0xf2, 0xa0, 0x0b, 0x10, 0xc3, 0x65, 0x7e, 0xba, 0xc0, 0x3b, 0xfc, 0x0b, 0x58,
+                0x7b, 0xef, 0x2f, 0x45, 0xec, 0x8a, 0xcd, 0xaa, 0x51, 0xc1, 0x43, 0xb0, 0xcb, 0x25,
+                0xb9, 0x14, 0x2c, 0x61, 0xbd, 0x79, 0x0a, 0x80, 0xd7, 0xc2, 0x3f, 0x90, 0xcc, 0x03,
+                0x49, 0x5b, 0x51, 0xe4, 0xd2, 0x84, 0x3e, 0x55, 0x7f, 0x9e, 0x25, 0x45, 0x10, 0x8c,
+                0x6c, 0x6f, 0xae, 0x35, 0x9f, 0x64, 0x5c, 0x27, 0x68, 0x91, 0xc0, 0xdc, 0xab, 0x3f,
+                0xaf, 0x18, 0x77, 0x00, 0xc0, 0x82, 0xdc, 0x47, 0x77, 0x40, 0xfb, 0x3f, 0x2c, 0xd7,
+                0xbb, 0x59, 0xfb, 0x35, 0x85, 0x54, 0xe9, 0x4c, 0x7e, 0x67, 0x8c, 0xe0, 0x1a, 0xeb,
+                0xf9, 0x4e, 0x51, 0x5e, 0x49, 0x72, 0x29, 0x67, 0x99, 0x5a, 0xea, 0x85, 0x8d, 0x64,
+                0xe7, 0x78, 0x9f, 0xf3, 0x06, 0x36, 0x95, 0x77, 0x22, 0x81, 0x80, 0x32, 0x6a, 0x5b,
+                0x0a, 0xf4, 0x75, 0xe2, 0x7a, 0x54, 0xb2, 0x07, 0xb4, 0x1f, 0x92, 0xe3, 0x76, 0x17,
+                0x0e, 0x3f, 0xb0, 0x05, 0x02, 0x82, 0x61, 0xc9, 0x9c, 0x2d, 0xbd, 0x0e, 0xed, 0xee,
+                0x87, 0x1c, 0x1c, 0x0f, 0x48, 0xb8, 0xe9, 0xb8, 0xe4, 0xbe, 0x77, 0xd1, 0xb7, 0x37,
+                0xfe, 0x21, 0xf0, 0xfa, 0x5a, 0x18, 0xeb, 0xb5, 0x27, 0x55, 0xb5, 0xa6, 0xcf, 0x61,
+                0x30, 0xfb, 0x56, 0x94, 0x4c, 0xfa, 0xb8, 0x75, 0x27, 0xc2, 0x50, 0xd1, 0x13, 0xb2,
+                0x9b, 0xca, 0xc9, 0xaa, 0xa1, 0x0c, 0x2e, 0x7d, 0xe4, 0x15, 0xed, 0xb0, 0x80, 0x6c,
+                0x6d, 0xa0, 0x30, 0x20, 0xa1, 0x34, 0xca, 0x7e, 0xcd, 0xc8, 0xda, 0x1b, 0xd5, 0x7a,
+                0x37, 0xf5, 0x5a, 0x46, 0x94, 0x0b, 0x45, 0xb2, 0x41, 0xb1, 0xc1, 0x6e, 0xe1, 0x00,
+                0x92, 0x7d, 0x1b, 0xd8, 0x60, 0xd4, 0x45, 0xa9, 0xde, 0x50, 0xd4, 0xc3, 0x84, 0xd6,
+                0xe1, 0xd0, 0x01, 0x08, 0x02, 0x6c, 0x0e, 0xa5, 0xeb, 0xbf, 0x0b, 0x72, 0xfb, 0xf5,
+                0xc3, 0x70, 0xbc, 0xe1, 0x8d, 0x3a, 0xcb, 0xc4, 0x65, 0x99, 0x09, 0x9b, 0xaa, 0xe1,
+                0xd8, 0x02, 0xf7, 0x73, 0x33, 0x49, 0x4a, 0x7a, 0xe1, 0x30, 0xfe, 0x86, 0xe8, 0xf8,
+                0x18, 0xf9, 0x26, 0x1a, 0x2d, 0xad, 0xb4, 0x12, 0x52, 0x29, 0xba, 0x0f, 0xfc, 0x0e,
+                0x70, 0x90, 0x32, 0x44, 0x30, 0xb5, 0x21, 0xa9,
+            ],
+            c_enc: [
+                0x45, 0x6b, 0x2b, 0xb8, 0x03, 0xc7, 0xdf, 0xf7, 0xac, 0x82, 0xe6, 0x42, 0xf4, 0xd8,
+                0x46, 0x1e, 0x0b, 0x7a, 0x3b, 0x3c, 0x95, 0xa4, 0xcb, 0xf1, 0xc0, 0x6f, 0xeb, 0x93,
+                0xa1, 0x8b, 0xeb, 0xa2, 0x9f, 0x2b, 0x8f, 0x12, 0x1a, 0x61, 0x5c, 0xa5, 0x3f, 0xc2,
+                0xa7, 0x60, 0x63, 0xb8, 0x0d, 0xaa, 0x71, 0x01, 0x8b, 0x66, 0x3b, 0x7c, 0x46, 0x6d,
+                0xb2, 0x63, 0xf9, 0x04, 0x27, 0xd0, 0x11, 0x7f, 0x0b, 0x89, 0x90, 0x6e, 0x98, 0x41,
+                0x7f, 0x3e, 0xe8, 0x5a, 0xcc, 0xed, 0xb1, 0x41, 0xfb, 0x10, 0x26, 0xa3, 0xb3, 0xf7,
+                0xa4, 0xfd, 0x10, 0x24, 0xf9, 0xc8, 0x08, 0x9a, 0x2e, 0xbe, 0x1a, 0x27, 0x82, 0xf8,
+                0xb0, 0xbf, 0x5c, 0x40, 0xb6, 0xd5, 0x2f, 0xfe, 0x38, 0x37, 0xf4, 0xe4, 0x42, 0x52,
+                0x13, 0x41, 0xc2, 0x4d, 0x3e, 0x89, 0x55, 0x95, 0x08, 0x86, 0x27, 0x85, 0xea, 0x63,
+                0x56, 0xb4, 0xe4, 0x66, 0xc3, 0x25, 0x9c, 0xeb, 0x0d, 0x28, 0x2e, 0x07, 0xbb, 0x35,
+                0xdc, 0xf2, 0xd9, 0xa8, 0x62, 0xc7, 0x47, 0x58, 0xd3, 0x83, 0xaa, 0xa2, 0x82, 0xfa,
+                0xc4, 0xfa, 0xcf, 0xe5, 0x39, 0xe4, 0xe1, 0xbb, 0xd5, 0x46, 0x8a, 0xcf, 0x25, 0xec,
+                0x2b, 0x4b, 0xa5, 0x11, 0x9d, 0xea, 0xed, 0x01, 0x1d, 0x4f, 0x30, 0xb0, 0xc5, 0x82,
+                0x01, 0xfe, 0xe1, 0xc6, 0xe4, 0xf6, 0xb5, 0x2e, 0x41, 0xad, 0xfa, 0x5d, 0x6f, 0xda,
+                0x94, 0xa5, 0x23, 0x20, 0xe8, 0x3b, 0x80, 0xc6, 0xfc, 0xee, 0xb8, 0x97, 0x89, 0xd8,
+                0x79, 0x94, 0xb7, 0xa0, 0x16, 0xec, 0x64, 0xe4, 0x70, 0x78, 0x07, 0xf8, 0xf2, 0xd2,
+                0x30, 0x63, 0x10, 0x74, 0x10, 0x9f, 0xc5, 0x9d, 0xe3, 0xe4, 0x37, 0x10, 0xca, 0xe8,
+                0x9c, 0xb1, 0x89, 0xa0, 0xa4, 0x64, 0x8b, 0x37, 0x54, 0x5d, 0x25, 0x49, 0x47, 0x95,
+                0xa8, 0xdf, 0x3f, 0xfc, 0x7a, 0x3a, 0x21, 0xe3, 0xb9, 0x1c, 0x95, 0x96, 0xe0, 0xd5,
+                0x10, 0x5d, 0xf8, 0xad, 0xa9, 0xcf, 0xe9, 0x31, 0x10, 0xb1, 0x9f, 0xf2, 0xaf, 0x83,
+                0x03, 0xb5, 0xd2, 0x79, 0x3f, 0xff, 0xd0, 0x4d, 0x8e, 0x02, 0xf7, 0xb9, 0x30, 0x14,
+                0x80, 0xdf, 0xd9, 0x35, 0x50, 0x2d, 0x98, 0xe2, 0xf3, 0xc3, 0xe9, 0xe9, 0x5e, 0x64,
+                0xe4, 0x96, 0xeb, 0x7d, 0x15, 0xcf, 0x2c, 0x70, 0x11, 0x94, 0xe6, 0x25, 0xde, 0x52,
+                0x1a, 0x02, 0x55, 0x20, 0xdf, 0x67, 0xac, 0x2b, 0xa4, 0x3b, 0x9c, 0x4a, 0x6d, 0x77,
+                0xb8, 0x6a, 0x40, 0x18, 0x2d, 0x70, 0x31, 0x8b, 0x8f, 0xa3, 0x48, 0xb1, 0x86, 0x47,
+                0xd8, 0x4e, 0x0e, 0xe5, 0xf0, 0x56, 0x07, 0xa2, 0xb8, 0xf2, 0x69, 0xe1, 0x86, 0xc7,
+                0x94, 0x28, 0xbe, 0xa6, 0x7c, 0xbf, 0x71, 0xda, 0xcc, 0x98, 0xe9, 0xcc, 0x72, 0x5e,
+                0x50, 0x53, 0xa4, 0x40, 0xca, 0xa6, 0xca, 0xd2, 0x41, 0xa5, 0x06, 0x28, 0x18, 0x3a,
+                0xe9, 0xef, 0x9f, 0x0c, 0xbd, 0xfe, 0xf7, 0x0a, 0x42, 0xe5, 0xb7, 0x97, 0xbc, 0x99,
+                0xd9, 0x22, 0xfc, 0xc2, 0x81, 0x37, 0x84, 0xea, 0xe4, 0x48, 0x60, 0x18, 0x0e, 0xf8,
+                0xe8, 0x1f, 0x7b, 0x94, 0xf2, 0xad, 0x62, 0x12, 0x8b, 0xb6, 0x1f, 0x10, 0xd5, 0x0c,
+                0x9c, 0xad, 0x9d, 0x80, 0x48, 0xd9, 0x78, 0x01, 0x8a, 0x1f, 0x3b, 0xc9, 0x24, 0x28,
+                0xf8, 0x9d, 0x7d, 0xdc, 0xe5, 0x45, 0x4b, 0xc4, 0x49, 0x1f, 0xb4, 0xc2, 0xcb, 0x66,
+                0x88, 0x35, 0xb2, 0x2f, 0xcc, 0x4d, 0xf2, 0x08, 0xf2, 0x16, 0x64, 0xf7, 0x12, 0x94,
+                0xc5, 0xce, 0xd3, 0x3c, 0x8e, 0x11, 0xd4, 0x25, 0xd1, 0x39, 0x85, 0x23, 0xc2, 0x79,
+                0x88, 0x3a, 0x38, 0x2f, 0x70, 0xfe, 0xfe, 0xc8, 0x25, 0xc5, 0xe3, 0x50, 0x85, 0xaf,
+                0x82, 0xd0, 0xa0, 0xa9, 0xbf, 0x45, 0x11, 0x65, 0x0a, 0x2b, 0xfb, 0xf0, 0xb2, 0x18,
+                0x82, 0x10, 0x5e, 0xc6, 0xe5, 0x99, 0x74, 0xd8, 0xd6, 0xce, 0x73, 0x07, 0x8f, 0xb4,
+                0xb5, 0x63, 0x4e, 0x85, 0xd7, 0xe2, 0x0a, 0x97, 0xff, 0xb6, 0x5d, 0x4f, 0x5e, 0xaf,
+                0x42, 0x63, 0x9b, 0x09, 0xf5, 0xed, 0xa5, 0x9a, 0xb1, 0x04, 0x97, 0x69, 0x95, 0x41,
+                0xd1, 0xc8, 0x22, 0x8e, 0xca, 0x31, 0x3f, 0xd0, 0x0a, 0x21, 0xb3, 0x02, 0x7b, 0x40,
+                0xd0, 0xc1, 0xfd, 0x4c, 0x2f, 0x0d, 0x97, 0xf1, 0xa9, 0x58, 0xe9, 0x2b, 0x45, 0xd5,
+                0xd4, 0xbf, 0xc2, 0xef, 0x18, 0xef, 0xd6, 0xb2, 0x5b, 0x47, 0xa9, 0x4d, 0xae, 0x73,
+                0xc3, 0xcf, 0xc9, 0xca, 0xd8, 0xdb, 0x82, 0x3f, 0xbd, 0x74,
+            ],
+            ock: [
+                0xc6, 0x7c, 0x23, 0x33, 0xc3, 0xcf, 0x4a, 0xc4, 0x6e, 0xde, 0x34, 0xe3, 0xe3, 0xe0,
+                0xdb, 0xff, 0x1e, 0x96, 0xb7, 0xa7, 0x8f, 0x16, 0xaa, 0xef, 0x1c, 0x74, 0xa3, 0xef,
+                0x07, 0xc5, 0x97, 0x16,
+            ],
+            op: [
+                0x05, 0x82, 0x53, 0xd4, 0x85, 0x76, 0x44, 0x88, 0x5e, 0x26, 0xa9, 0x09, 0xc8, 0x38,
+                0x59, 0x25, 0x23, 0x5a, 0x75, 0x29, 0x85, 0x44, 0x6e, 0x11, 0x69, 0x5f, 0x36, 0xc2,
+                0xe6, 0x84, 0x45, 0xbb, 0x05, 0x18, 0xdd, 0xc0, 0xc4, 0x7b, 0x7f, 0x77, 0xed, 0xcd,
+                0x39, 0x16, 0x0f, 0xe5, 0x67, 0x75, 0x1e, 0xb8, 0x4a, 0xa2, 0x1d, 0x33, 0xa6, 0x90,
+                0xe0, 0xd2, 0x9b, 0x35, 0x9a, 0xc4, 0xfa, 0x2c,
+            ],
+            c_out: [
+                0xe4, 0xba, 0x0e, 0xa2, 0x92, 0x3b, 0x40, 0x19, 0xac, 0x8a, 0xbc, 0xd1, 0x9b, 0xe6,
+                0x1c, 0x90, 0xf1, 0x8e, 0xef, 0xae, 0x87, 0xc4, 0xed, 0x8c, 0x76, 0x70, 0x85, 0xba,
+                0xa8, 0x3b, 0x4d, 0x61, 0x0c, 0xf3, 0x63, 0x70, 0xda, 0x07, 0x90, 0x1e, 0xad, 0x6d,
+                0x4f, 0x4b, 0x71, 0xdc, 0xae, 0x31, 0x1f, 0xa0, 0x36, 0x40, 0x6d, 0x64, 0x7b, 0x7e,
+                0xe1, 0x41, 0x1e, 0xf5, 0xae, 0xe0, 0x34, 0x68, 0xb1, 0x09, 0x13, 0xc9, 0x90, 0xcb,
+                0x61, 0x61, 0x22, 0xeb, 0xbe, 0x49, 0xda, 0x67, 0x81, 0xc2,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xb6, 0x6c, 0x73, 0x33, 0x75, 0xda, 0xc6, 0xff, 0xcc, 0x98, 0xf5, 0x0f, 0x3a, 0xf0,
+                0xb0, 0x76, 0x05, 0x53, 0xfe, 0x98, 0xed, 0x61, 0xff, 0xa4, 0x93, 0xea, 0xe6, 0x8d,
+                0xf0, 0xb3, 0x33, 0x4e, 0xe8, 0xd4, 0x39, 0x37, 0xb7, 0xdb, 0x8e, 0xbb, 0xfe, 0xbd,
+                0x54, 0x8a, 0x28, 0x02, 0x51, 0xea, 0x87, 0xaa, 0x5d, 0x8c, 0xa5, 0x36, 0x86, 0x1b,
+                0x38, 0x4f, 0x20, 0x86, 0x9f, 0x8f, 0xe8, 0x01,
+            ],
+            ovk: [
+                0xe9, 0x4c, 0x15, 0x24, 0x5f, 0x1a, 0x95, 0x88, 0x40, 0xba, 0x3f, 0x38, 0x0a, 0x4d,
+                0x20, 0xf1, 0x18, 0x4e, 0x77, 0x82, 0x7d, 0xe3, 0xff, 0x8f, 0x3d, 0x73, 0x45, 0x9a,
+                0xfe, 0x24, 0x1f, 0x72,
+            ],
+            default_d: [
+                0x7c, 0x51, 0xbe, 0xc6, 0xee, 0x28, 0x46, 0xfd, 0x85, 0x12, 0x64,
+            ],
+            default_pk_d: [
+                0x7a, 0xfc, 0xa0, 0x5d, 0x04, 0x2c, 0x84, 0x3e, 0xec, 0xdc, 0x37, 0x24, 0x10, 0x52,
+                0xc4, 0x6f, 0x93, 0xd4, 0xaf, 0xd5, 0xc9, 0xb0, 0x4d, 0x2b, 0x26, 0x4e, 0x81, 0x0f,
+                0x25, 0xc8, 0xd6, 0xae,
+            ],
+            v: 16065731808124965111,
+            rseed: [
+                0x26, 0xf2, 0x84, 0x38, 0xe5, 0x78, 0x2f, 0x45, 0xac, 0x1d, 0x07, 0xf6, 0xf6, 0xf5,
+                0xed, 0x73, 0x74, 0x1d, 0x57, 0x85, 0x83, 0x7a, 0x6b, 0x84, 0x4b, 0x47, 0x47, 0x75,
+                0x71, 0x8c, 0x29, 0xdd,
+            ],
+            asset: [
+                0xdf, 0xfd, 0x79, 0xa9, 0xde, 0xd0, 0x5e, 0x88, 0x89, 0x58, 0x19, 0x9e, 0xea, 0x45,
+                0x01, 0xe2, 0x99, 0x0a, 0x53, 0xa5, 0xcd, 0x2a, 0x46, 0xa4, 0x01, 0x57, 0x65, 0x88,
+                0xfd, 0x7d, 0x05, 0x8a,
+            ],
+            memo: [
+                0xff, 0x99, 0x08, 0x4e, 0x9f, 0x88, 0xef, 0x15, 0x3a, 0x83, 0x29, 0xf5, 0x32, 0xa6,
+                0x90, 0x17, 0xdc, 0x3a, 0x97, 0xed, 0x75, 0x43, 0x67, 0x72, 0x30, 0x98, 0xe5, 0x76,
+                0x58, 0x40, 0xb0, 0x22, 0x89, 0x72, 0x44, 0x74, 0x5f, 0xbb, 0xbb, 0x30, 0xa7, 0xcb,
+                0x54, 0xfa, 0x05, 0x11, 0x16, 0x6e, 0x95, 0x44, 0x12, 0x20, 0x00, 0x61, 0x0b, 0xd2,
+                0xaa, 0xcb, 0xd8, 0x23, 0x25, 0xa5, 0x9b, 0x95, 0x15, 0x4e, 0xcd, 0x82, 0xc8, 0x8d,
+                0x23, 0xab, 0xd1, 0xe2, 0x07, 0x70, 0xff, 0xb8, 0xaa, 0xbf, 0x83, 0xfc, 0x07, 0x34,
+                0x96, 0x4c, 0xcd, 0x41, 0x1d, 0x1c, 0x93, 0x57, 0x14, 0xe2, 0x4a, 0xab, 0x56, 0x6f,
+                0x4f, 0x08, 0x42, 0x40, 0x14, 0xc4, 0xec, 0xa9, 0x1b, 0x59, 0x0f, 0x08, 0x2b, 0x47,
+                0x3f, 0x36, 0x1c, 0x87, 0x41, 0x5d, 0x37, 0xbd, 0x20, 0xd7, 0x0f, 0xd0, 0xb5, 0x2b,
+                0x6d, 0xdf, 0x18, 0x65, 0xf7, 0x66, 0x70, 0x2e, 0x32, 0xb0, 0x5b, 0x3c, 0xf1, 0x63,
+                0x0e, 0xe8, 0x59, 0x7a, 0xae, 0x19, 0x63, 0x3f, 0x35, 0x16, 0xa8, 0x55, 0x5a, 0xc5,
+                0xbe, 0x32, 0xc6, 0x75, 0xbe, 0x18, 0x17, 0xef, 0xbf, 0xfd, 0x93, 0x69, 0x04, 0x1a,
+                0x08, 0x9c, 0x28, 0x3f, 0x19, 0x64, 0x99, 0x68, 0xc2, 0x49, 0x8c, 0xde, 0x56, 0xf5,
+                0x00, 0x43, 0x4f, 0x28, 0x0d, 0x77, 0xa9, 0xc6, 0x2e, 0x43, 0xcb, 0xd3, 0xf1, 0x36,
+                0xa4, 0xc6, 0xa0, 0x0a, 0x43, 0xe6, 0xed, 0x53, 0x0c, 0xb2, 0xe8, 0xae, 0x83, 0x88,
+                0x60, 0xad, 0xc8, 0x8a, 0xac, 0xc7, 0xbd, 0x6a, 0x00, 0xae, 0x0c, 0x19, 0xff, 0x45,
+                0x33, 0xa4, 0x85, 0xef, 0xde, 0x08, 0x2b, 0x5f, 0x4d, 0x1f, 0x7a, 0x8e, 0xbe, 0x7e,
+                0xd8, 0x2b, 0x7b, 0x05, 0xa8, 0xcf, 0xe1, 0xe3, 0x73, 0x45, 0x9f, 0x1b, 0xdc, 0xbf,
+                0x95, 0x25, 0x74, 0x7e, 0x8c, 0x95, 0x08, 0xa5, 0x55, 0xfa, 0xcb, 0x79, 0x87, 0x40,
+                0xe0, 0xbd, 0xf9, 0x94, 0xd9, 0x73, 0x9b, 0xbe, 0x55, 0x38, 0xa0, 0xae, 0x0f, 0x07,
+                0x6c, 0x58, 0x2c, 0x0f, 0x5b, 0xa8, 0x78, 0xb9, 0x9b, 0x82, 0x49, 0xdb, 0x1d, 0x7e,
+                0x95, 0x05, 0x6c, 0x98, 0xaf, 0x08, 0x3d, 0x98, 0xcb, 0x0e, 0xd9, 0xe3, 0xf7, 0x43,
+                0x6e, 0x1c, 0x76, 0x43, 0x76, 0x6f, 0x96, 0x6b, 0x83, 0xe9, 0x99, 0x20, 0x6e, 0xbd,
+                0x13, 0x93, 0xb9, 0xb2, 0xa7, 0xf4, 0x14, 0x48, 0x0f, 0xa0, 0x17, 0x48, 0x00, 0x69,
+                0xf8, 0x5c, 0x77, 0x49, 0xc4, 0x35, 0xae, 0x2f, 0xba, 0x2d, 0xdc, 0x10, 0x38, 0xd5,
+                0x47, 0xd8, 0x48, 0x54, 0x81, 0x7e, 0xf3, 0x96, 0x35, 0xc2, 0x98, 0x27, 0xaa, 0xd8,
+                0x67, 0x26, 0xc9, 0xad, 0xe3, 0xb2, 0x65, 0xb9, 0x08, 0x6c, 0x8b, 0x5b, 0x75, 0xef,
+                0x56, 0xfe, 0x4b, 0xd8, 0xb4, 0xd6, 0x28, 0x93, 0x89, 0x5b, 0x3f, 0xd2, 0x73, 0x4f,
+                0xda, 0xc4, 0x64, 0x15, 0x6d, 0x7e, 0x5e, 0xbc, 0x7e, 0xcf, 0x1d, 0x83, 0xb8, 0x6f,
+                0x65, 0x96, 0x37, 0xe3, 0xb1, 0x42, 0xc1, 0x64, 0x96, 0x3b, 0x8c, 0xdc, 0xf4, 0xba,
+                0x4f, 0x40, 0x35, 0xdf, 0xfc, 0x5a, 0x78, 0x94, 0x58, 0x84, 0x77, 0x81, 0x91, 0x8a,
+                0xc7, 0x2f, 0xc1, 0x8b, 0xbb, 0xf5, 0x11, 0x00, 0x32, 0xe6, 0x6d, 0x75, 0xb3, 0x17,
+                0x1e, 0xf4, 0xb5, 0x13, 0x29, 0x01, 0x64, 0xa7, 0x7b, 0x42, 0xb0, 0xa4, 0xcf, 0xb8,
+                0x96, 0x39, 0xab, 0x23, 0x84, 0x5e, 0x1a, 0xa2, 0xa4, 0x52, 0xf3, 0x73, 0x1c, 0x8c,
+                0xb6, 0x50, 0x82, 0xa6, 0x22, 0xa7, 0xc2, 0xe0, 0x01, 0x3e, 0xa4, 0x7d, 0x0b, 0xdd,
+                0x42, 0xd6, 0x99, 0x04, 0x66, 0x64, 0x9a, 0x90, 0x5c, 0x68, 0x4c, 0x32, 0x51, 0x71,
+                0x6d, 0x61, 0xf7, 0x60, 0xd5, 0x3d, 0xe6, 0xe3,
+            ],
+            cv_net: [
+                0x0a, 0x1f, 0x28, 0x15, 0xb7, 0xaf, 0xe2, 0x19, 0x06, 0x87, 0x15, 0xfc, 0x76, 0x6b,
+                0x87, 0x2e, 0xf2, 0x17, 0x35, 0x43, 0xac, 0x81, 0x4c, 0x32, 0xb4, 0xb6, 0x9c, 0x9c,
+                0x34, 0x5e, 0x46, 0x98,
+            ],
+            rho: [
+                0x27, 0x3c, 0x68, 0xd1, 0x9c, 0xda, 0xa8, 0x62, 0x8b, 0xac, 0x37, 0xa2, 0xd4, 0x2c,
+                0x51, 0x1c, 0x9b, 0xab, 0x65, 0xb6, 0xd8, 0xd5, 0xc5, 0xbd, 0x1e, 0x32, 0x77, 0x1a,
+                0xb6, 0xf6, 0x4c, 0x26,
+            ],
+            cmx: [
+                0x40, 0x8f, 0x59, 0x4f, 0xdd, 0xc5, 0x0c, 0x67, 0xf5, 0x47, 0xe1, 0xeb, 0x3e, 0xa2,
+                0x99, 0xa3, 0x1f, 0x69, 0xf5, 0x7f, 0xc9, 0x92, 0x03, 0x01, 0x42, 0x90, 0x35, 0xa6,
+                0xc2, 0x49, 0x79, 0x1a,
+            ],
+            esk: [
+                0xcb, 0xfc, 0x51, 0x10, 0xff, 0x2f, 0xe9, 0xc5, 0xd5, 0x9e, 0xef, 0x08, 0xbd, 0xf6,
+                0xf8, 0x57, 0xe7, 0x1a, 0xab, 0x45, 0x0e, 0x6c, 0xd6, 0x13, 0xf5, 0x3b, 0x57, 0xc3,
+                0x45, 0xa9, 0x87, 0x2f,
+            ],
+            ephemeral_key: [
+                0xa5, 0xc8, 0x0a, 0x29, 0xf2, 0xec, 0xdd, 0xd7, 0x01, 0x96, 0xef, 0x45, 0x9e, 0xd5,
+                0x03, 0xc4, 0xb3, 0xc2, 0x22, 0x8d, 0x10, 0xcc, 0xbc, 0xad, 0x9a, 0x28, 0x23, 0x30,
+                0x07, 0x7b, 0xca, 0x0c,
+            ],
+            shared_secret: [
+                0x37, 0x14, 0x15, 0xfc, 0x1e, 0x98, 0x42, 0xa1, 0x26, 0xa3, 0x7a, 0xa7, 0x7b, 0x8f,
+                0x0f, 0x1a, 0xb6, 0x48, 0xa3, 0xf7, 0x43, 0x57, 0x34, 0x89, 0x6f, 0x07, 0x59, 0x52,
+                0xe7, 0xd1, 0x60, 0x17,
+            ],
+            k_enc: [
+                0xd7, 0x36, 0xf0, 0x3c, 0x81, 0x2d, 0x9b, 0xf9, 0x54, 0xff, 0xd2, 0x41, 0x84, 0x07,
+                0xf3, 0x36, 0xa5, 0xf9, 0x69, 0x8b, 0x62, 0x85, 0x23, 0x2f, 0x5c, 0x85, 0xf0, 0xd1,
+                0x1d, 0x5e, 0x9d, 0x0a,
+            ],
+            p_enc: [
+                0x03, 0x7c, 0x51, 0xbe, 0xc6, 0xee, 0x28, 0x46, 0xfd, 0x85, 0x12, 0x64, 0xf7, 0x90,
+                0xfb, 0xa7, 0xf5, 0xf1, 0xf4, 0xde, 0x26, 0xf2, 0x84, 0x38, 0xe5, 0x78, 0x2f, 0x45,
+                0xac, 0x1d, 0x07, 0xf6, 0xf6, 0xf5, 0xed, 0x73, 0x74, 0x1d, 0x57, 0x85, 0x83, 0x7a,
+                0x6b, 0x84, 0x4b, 0x47, 0x47, 0x75, 0x71, 0x8c, 0x29, 0xdd, 0xdf, 0xfd, 0x79, 0xa9,
+                0xde, 0xd0, 0x5e, 0x88, 0x89, 0x58, 0x19, 0x9e, 0xea, 0x45, 0x01, 0xe2, 0x99, 0x0a,
+                0x53, 0xa5, 0xcd, 0x2a, 0x46, 0xa4, 0x01, 0x57, 0x65, 0x88, 0xfd, 0x7d, 0x05, 0x8a,
+                0xff, 0x99, 0x08, 0x4e, 0x9f, 0x88, 0xef, 0x15, 0x3a, 0x83, 0x29, 0xf5, 0x32, 0xa6,
+                0x90, 0x17, 0xdc, 0x3a, 0x97, 0xed, 0x75, 0x43, 0x67, 0x72, 0x30, 0x98, 0xe5, 0x76,
+                0x58, 0x40, 0xb0, 0x22, 0x89, 0x72, 0x44, 0x74, 0x5f, 0xbb, 0xbb, 0x30, 0xa7, 0xcb,
+                0x54, 0xfa, 0x05, 0x11, 0x16, 0x6e, 0x95, 0x44, 0x12, 0x20, 0x00, 0x61, 0x0b, 0xd2,
+                0xaa, 0xcb, 0xd8, 0x23, 0x25, 0xa5, 0x9b, 0x95, 0x15, 0x4e, 0xcd, 0x82, 0xc8, 0x8d,
+                0x23, 0xab, 0xd1, 0xe2, 0x07, 0x70, 0xff, 0xb8, 0xaa, 0xbf, 0x83, 0xfc, 0x07, 0x34,
+                0x96, 0x4c, 0xcd, 0x41, 0x1d, 0x1c, 0x93, 0x57, 0x14, 0xe2, 0x4a, 0xab, 0x56, 0x6f,
+                0x4f, 0x08, 0x42, 0x40, 0x14, 0xc4, 0xec, 0xa9, 0x1b, 0x59, 0x0f, 0x08, 0x2b, 0x47,
+                0x3f, 0x36, 0x1c, 0x87, 0x41, 0x5d, 0x37, 0xbd, 0x20, 0xd7, 0x0f, 0xd0, 0xb5, 0x2b,
+                0x6d, 0xdf, 0x18, 0x65, 0xf7, 0x66, 0x70, 0x2e, 0x32, 0xb0, 0x5b, 0x3c, 0xf1, 0x63,
+                0x0e, 0xe8, 0x59, 0x7a, 0xae, 0x19, 0x63, 0x3f, 0x35, 0x16, 0xa8, 0x55, 0x5a, 0xc5,
+                0xbe, 0x32, 0xc6, 0x75, 0xbe, 0x18, 0x17, 0xef, 0xbf, 0xfd, 0x93, 0x69, 0x04, 0x1a,
+                0x08, 0x9c, 0x28, 0x3f, 0x19, 0x64, 0x99, 0x68, 0xc2, 0x49, 0x8c, 0xde, 0x56, 0xf5,
+                0x00, 0x43, 0x4f, 0x28, 0x0d, 0x77, 0xa9, 0xc6, 0x2e, 0x43, 0xcb, 0xd3, 0xf1, 0x36,
+                0xa4, 0xc6, 0xa0, 0x0a, 0x43, 0xe6, 0xed, 0x53, 0x0c, 0xb2, 0xe8, 0xae, 0x83, 0x88,
+                0x60, 0xad, 0xc8, 0x8a, 0xac, 0xc7, 0xbd, 0x6a, 0x00, 0xae, 0x0c, 0x19, 0xff, 0x45,
+                0x33, 0xa4, 0x85, 0xef, 0xde, 0x08, 0x2b, 0x5f, 0x4d, 0x1f, 0x7a, 0x8e, 0xbe, 0x7e,
+                0xd8, 0x2b, 0x7b, 0x05, 0xa8, 0xcf, 0xe1, 0xe3, 0x73, 0x45, 0x9f, 0x1b, 0xdc, 0xbf,
+                0x95, 0x25, 0x74, 0x7e, 0x8c, 0x95, 0x08, 0xa5, 0x55, 0xfa, 0xcb, 0x79, 0x87, 0x40,
+                0xe0, 0xbd, 0xf9, 0x94, 0xd9, 0x73, 0x9b, 0xbe, 0x55, 0x38, 0xa0, 0xae, 0x0f, 0x07,
+                0x6c, 0x58, 0x2c, 0x0f, 0x5b, 0xa8, 0x78, 0xb9, 0x9b, 0x82, 0x49, 0xdb, 0x1d, 0x7e,
+                0x95, 0x05, 0x6c, 0x98, 0xaf, 0x08, 0x3d, 0x98, 0xcb, 0x0e, 0xd9, 0xe3, 0xf7, 0x43,
+                0x6e, 0x1c, 0x76, 0x43, 0x76, 0x6f, 0x96, 0x6b, 0x83, 0xe9, 0x99, 0x20, 0x6e, 0xbd,
+                0x13, 0x93, 0xb9, 0xb2, 0xa7, 0xf4, 0x14, 0x48, 0x0f, 0xa0, 0x17, 0x48, 0x00, 0x69,
+                0xf8, 0x5c, 0x77, 0x49, 0xc4, 0x35, 0xae, 0x2f, 0xba, 0x2d, 0xdc, 0x10, 0x38, 0xd5,
+                0x47, 0xd8, 0x48, 0x54, 0x81, 0x7e, 0xf3, 0x96, 0x35, 0xc2, 0x98, 0x27, 0xaa, 0xd8,
+                0x67, 0x26, 0xc9, 0xad, 0xe3, 0xb2, 0x65, 0xb9, 0x08, 0x6c, 0x8b, 0x5b, 0x75, 0xef,
+                0x56, 0xfe, 0x4b, 0xd8, 0xb4, 0xd6, 0x28, 0x93, 0x89, 0x5b, 0x3f, 0xd2, 0x73, 0x4f,
+                0xda, 0xc4, 0x64, 0x15, 0x6d, 0x7e, 0x5e, 0xbc, 0x7e, 0xcf, 0x1d, 0x83, 0xb8, 0x6f,
+                0x65, 0x96, 0x37, 0xe3, 0xb1, 0x42, 0xc1, 0x64, 0x96, 0x3b, 0x8c, 0xdc, 0xf4, 0xba,
+                0x4f, 0x40, 0x35, 0xdf, 0xfc, 0x5a, 0x78, 0x94, 0x58, 0x84, 0x77, 0x81, 0x91, 0x8a,
+                0xc7, 0x2f, 0xc1, 0x8b, 0xbb, 0xf5, 0x11, 0x00, 0x32, 0xe6, 0x6d, 0x75, 0xb3, 0x17,
+                0x1e, 0xf4, 0xb5, 0x13, 0x29, 0x01, 0x64, 0xa7, 0x7b, 0x42, 0xb0, 0xa4, 0xcf, 0xb8,
+                0x96, 0x39, 0xab, 0x23, 0x84, 0x5e, 0x1a, 0xa2, 0xa4, 0x52, 0xf3, 0x73, 0x1c, 0x8c,
+                0xb6, 0x50, 0x82, 0xa6, 0x22, 0xa7, 0xc2, 0xe0, 0x01, 0x3e, 0xa4, 0x7d, 0x0b, 0xdd,
+                0x42, 0xd6, 0x99, 0x04, 0x66, 0x64, 0x9a, 0x90, 0x5c, 0x68, 0x4c, 0x32, 0x51, 0x71,
+                0x6d, 0x61, 0xf7, 0x60, 0xd5, 0x3d, 0xe6, 0xe3,
+            ],
+            c_enc: [
+                0xfc, 0x90, 0xcb, 0xe1, 0xcd, 0x9f, 0x59, 0x9a, 0x1a, 0x24, 0xc7, 0xa3, 0xea, 0xf6,
+                0x07, 0xd9, 0x13, 0xbf, 0x48, 0xbd, 0xc1, 0xa4, 0x6d, 0xf7, 0xb1, 0x74, 0x7f, 0x12,
+                0x60, 0x64, 0x49, 0x4b, 0xf5, 0x39, 0x61, 0xe9, 0xa5, 0xa2, 0xb9, 0x69, 0x80, 0x57,
+                0x63, 0x44, 0x2e, 0x2c, 0x38, 0x8d, 0x21, 0x2d, 0x74, 0x84, 0x6e, 0x57, 0x27, 0x87,
+                0x2d, 0x06, 0x3f, 0xc9, 0x94, 0xa4, 0x4f, 0x9e, 0xb6, 0x55, 0x25, 0xd6, 0x8f, 0x98,
+                0x24, 0xa6, 0x03, 0x75, 0xfe, 0x43, 0xc0, 0x5f, 0x08, 0xfe, 0x45, 0x42, 0xa7, 0xe4,
+                0x0c, 0x03, 0x8d, 0xe7, 0x10, 0x85, 0x01, 0x17, 0x95, 0x1b, 0x9a, 0x32, 0x1e, 0xea,
+                0x4f, 0x8c, 0x91, 0xc0, 0x1d, 0x39, 0xdb, 0xb5, 0xd4, 0x12, 0x40, 0xf8, 0xb1, 0xb1,
+                0xdb, 0xb3, 0x3f, 0x45, 0x87, 0x87, 0xdb, 0x8c, 0xda, 0x06, 0x9b, 0x64, 0x5a, 0x76,
+                0x38, 0xc2, 0xec, 0xca, 0xd3, 0xd9, 0xa7, 0x39, 0xd6, 0x4c, 0x9a, 0xd5, 0xd5, 0xb3,
+                0xa0, 0x24, 0x55, 0xa4, 0xec, 0xd6, 0x96, 0x7c, 0xf3, 0xb3, 0x3b, 0xf0, 0x4e, 0xf6,
+                0xdd, 0x88, 0x10, 0xe1, 0x0c, 0x25, 0x86, 0xf7, 0x89, 0x32, 0x44, 0xea, 0x72, 0x80,
+                0xd1, 0x34, 0xcf, 0x37, 0xb3, 0xdc, 0x0c, 0x32, 0x82, 0x3b, 0x1a, 0x29, 0xc5, 0x0c,
+                0xa6, 0x48, 0x31, 0xd8, 0x4e, 0xbd, 0xf5, 0xe0, 0x1c, 0x14, 0xca, 0x36, 0x05, 0xbe,
+                0x02, 0xf1, 0x5f, 0x31, 0x57, 0x90, 0xf7, 0x4e, 0x20, 0x57, 0x7f, 0x92, 0x39, 0x51,
+                0x2f, 0xbd, 0xdd, 0x67, 0x63, 0x77, 0xae, 0x50, 0xc3, 0xfe, 0x71, 0xc9, 0x30, 0xa8,
+                0x29, 0x57, 0xd1, 0x54, 0x70, 0xeb, 0x1b, 0x55, 0xb2, 0x0c, 0xe5, 0x02, 0x35, 0x64,
+                0xfe, 0xa7, 0xe1, 0x81, 0xbe, 0x04, 0xa9, 0x33, 0xa7, 0xa3, 0xa1, 0x11, 0x89, 0x4d,
+                0xec, 0xf7, 0x2a, 0x56, 0x54, 0xcb, 0x4e, 0xac, 0x32, 0xe1, 0xd5, 0x96, 0xad, 0x99,
+                0x1a, 0x2f, 0x4c, 0x62, 0xe8, 0xe2, 0x82, 0x57, 0x13, 0x7b, 0xcb, 0xa5, 0x03, 0xdc,
+                0x91, 0xed, 0x9e, 0x90, 0xb3, 0x08, 0xcd, 0xa5, 0xcc, 0xcc, 0xc9, 0xd1, 0x4e, 0xa6,
+                0xd0, 0x3b, 0x3d, 0xec, 0xa1, 0x57, 0xd5, 0x30, 0xde, 0x63, 0x1e, 0x1e, 0x45, 0x8f,
+                0x6a, 0x60, 0x8e, 0x1f, 0x9d, 0x57, 0x9b, 0x6e, 0xe6, 0x00, 0x5c, 0xd0, 0xa8, 0xc3,
+                0xe2, 0xdf, 0x89, 0x46, 0x8a, 0xcf, 0xb4, 0x36, 0xcb, 0x59, 0x84, 0x56, 0xf0, 0x38,
+                0x95, 0x5d, 0xc6, 0xb4, 0x07, 0xec, 0x33, 0x00, 0xa5, 0xcf, 0xcd, 0xc8, 0x45, 0x47,
+                0xe3, 0xef, 0xe9, 0xfc, 0xa1, 0x7e, 0xd2, 0xc2, 0x74, 0xf0, 0x03, 0x0b, 0x63, 0xcc,
+                0x42, 0xe2, 0x38, 0x94, 0xa5, 0xf2, 0x53, 0x66, 0xcb, 0xc3, 0xbf, 0xcb, 0x77, 0x2d,
+                0x04, 0x17, 0xf6, 0x24, 0x4b, 0x2f, 0xd8, 0x17, 0xc4, 0xc6, 0x79, 0x06, 0xc3, 0x38,
+                0x4d, 0x69, 0xd7, 0x93, 0xef, 0xca, 0x6e, 0x5d, 0x6a, 0xf2, 0x5e, 0x4e, 0xbc, 0x0f,
+                0x53, 0x56, 0xeb, 0x74, 0x28, 0x85, 0x19, 0xe8, 0xf4, 0x49, 0x38, 0xeb, 0xf9, 0xb2,
+                0x5b, 0xe5, 0x85, 0xe1, 0x35, 0x1f, 0x62, 0x59, 0x6c, 0x31, 0x79, 0xca, 0xe4, 0x5e,
+                0x75, 0x49, 0xd7, 0xfb, 0xb5, 0x91, 0x3b, 0xe9, 0xc3, 0xba, 0xa5, 0x7c, 0xab, 0x7c,
+                0xd4, 0xb5, 0x67, 0x12, 0x8d, 0x1b, 0xa5, 0x20, 0x31, 0xd7, 0xd5, 0xa5, 0xbd, 0x69,
+                0xde, 0x61, 0x4a, 0xbb, 0x8c, 0xa3, 0x8a, 0x94, 0x51, 0xcd, 0x1b, 0xad, 0xd9, 0x71,
+                0xb3, 0xf1, 0xb0, 0xb5, 0x0c, 0x7f, 0x21, 0xbf, 0xc4, 0x23, 0x04, 0xa4, 0xa5, 0x3e,
+                0x0d, 0x55, 0x92, 0x0d, 0xa0, 0x53, 0x27, 0x14, 0x79, 0x13, 0x45, 0xfb, 0x07, 0x4c,
+                0x66, 0xc4, 0xb7, 0xc9, 0x89, 0x28, 0x30, 0xf9, 0x62, 0x09, 0xb8, 0x1c, 0x26, 0xd1,
+                0x74, 0xf8, 0xa9, 0x33, 0xc3, 0x77, 0x9d, 0x97, 0x88, 0x55, 0x3f, 0x6e, 0xeb, 0x21,
+                0xf7, 0xdb, 0x57, 0x78, 0xf4, 0xf8, 0x17, 0x4c, 0xb4, 0x6f, 0x71, 0xfd, 0xdc, 0x4b,
+                0xe4, 0xd8, 0x70, 0x3e, 0xbf, 0xbc, 0xd2, 0xa7, 0x72, 0x89, 0xee, 0xfa, 0x72, 0x76,
+                0x56, 0x74, 0xdb, 0xf0, 0x43, 0xd4, 0x25, 0x8c, 0xcc, 0x4a, 0x2f, 0x16, 0x5c, 0x02,
+                0xdc, 0xdb, 0x57, 0x2a, 0x70, 0x9d, 0x58, 0x45, 0x83, 0xe9, 0xde, 0x07, 0x8f, 0x1b,
+                0x6c, 0x0c, 0x67, 0xf2, 0x8f, 0x17, 0xae, 0x52, 0x30, 0x19, 0x83, 0xf7, 0x9c, 0x28,
+                0x83, 0x95, 0xa3, 0x99, 0x63, 0x65, 0xa2, 0x0c, 0x22, 0x9e,
+            ],
+            ock: [
+                0x2f, 0x88, 0x37, 0x27, 0xb5, 0x4d, 0x06, 0x25, 0xcf, 0xdc, 0x19, 0x5a, 0xce, 0x10,
+                0xca, 0xc0, 0x26, 0x8a, 0xba, 0x3d, 0xe2, 0x8a, 0xd6, 0x08, 0x88, 0x06, 0x50, 0x6d,
+                0x69, 0xc4, 0xdd, 0x8e,
+            ],
+            op: [
+                0x7a, 0xfc, 0xa0, 0x5d, 0x04, 0x2c, 0x84, 0x3e, 0xec, 0xdc, 0x37, 0x24, 0x10, 0x52,
+                0xc4, 0x6f, 0x93, 0xd4, 0xaf, 0xd5, 0xc9, 0xb0, 0x4d, 0x2b, 0x26, 0x4e, 0x81, 0x0f,
+                0x25, 0xc8, 0xd6, 0xae, 0xcb, 0xfc, 0x51, 0x10, 0xff, 0x2f, 0xe9, 0xc5, 0xd5, 0x9e,
+                0xef, 0x08, 0xbd, 0xf6, 0xf8, 0x57, 0xe7, 0x1a, 0xab, 0x45, 0x0e, 0x6c, 0xd6, 0x13,
+                0xf5, 0x3b, 0x57, 0xc3, 0x45, 0xa9, 0x87, 0x2f,
+            ],
+            c_out: [
+                0x99, 0x96, 0x90, 0xd4, 0xcd, 0xd9, 0xe7, 0x6b, 0x07, 0x2c, 0x3c, 0x4c, 0x41, 0xbf,
+                0xc7, 0x9a, 0xaa, 0xc6, 0x7f, 0xdc, 0x0f, 0x41, 0xe8, 0x0e, 0x95, 0x48, 0x80, 0x0e,
+                0xef, 0xbc, 0x95, 0x74, 0xf1, 0x5d, 0x64, 0xa6, 0x9e, 0x44, 0x47, 0xc4, 0x5b, 0x07,
+                0x0c, 0x6c, 0x9f, 0x50, 0x0a, 0xdd, 0xef, 0x6f, 0x57, 0x14, 0xa5, 0x76, 0x22, 0x1f,
+                0x3f, 0xbc, 0x61, 0x22, 0x8d, 0x95, 0xc3, 0xac, 0xe4, 0x21, 0x4b, 0xb6, 0xcf, 0x5b,
+                0xd9, 0x69, 0x84, 0xd7, 0x78, 0x96, 0x0d, 0xe9, 0x0c, 0x02,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x8c, 0x45, 0x43, 0xe1, 0x1f, 0x9f, 0x30, 0x7e, 0xc9, 0x04, 0x31, 0x61, 0x29, 0x46,
+                0xfb, 0x01, 0x81, 0xb3, 0x6e, 0x1b, 0x52, 0xdb, 0x43, 0x1e, 0x6d, 0xf9, 0x38, 0x8c,
+                0xac, 0xd3, 0x08, 0xe8, 0x99, 0xd9, 0x3f, 0x70, 0xad, 0x2a, 0xea, 0xec, 0x99, 0x5e,
+                0xcc, 0xe1, 0x80, 0x1c, 0x61, 0x56, 0xe2, 0x3e, 0xc4, 0x1b, 0x1a, 0xe1, 0xcd, 0x2f,
+                0xd6, 0xe3, 0x9b, 0x69, 0x98, 0x2f, 0x46, 0x33,
+            ],
+            ovk: [
+                0x01, 0x76, 0xae, 0x33, 0x93, 0x25, 0xd5, 0xa5, 0x88, 0xda, 0x57, 0x96, 0xfa, 0xae,
+                0x5b, 0xab, 0x7c, 0x82, 0x97, 0x7c, 0x0f, 0xf7, 0x97, 0x09, 0x3e, 0x2c, 0x1f, 0x3a,
+                0xe8, 0x55, 0xf6, 0x5a,
+            ],
+            default_d: [
+                0x4e, 0x42, 0x6d, 0xf1, 0xad, 0x32, 0x48, 0x94, 0xbc, 0xa2, 0xc1,
+            ],
+            default_pk_d: [
+                0x84, 0xda, 0x49, 0x6b, 0x16, 0x0a, 0x81, 0x72, 0xc4, 0x8d, 0x76, 0xb4, 0xfb, 0x08,
+                0xbc, 0xab, 0xf4, 0x0f, 0xf1, 0xe4, 0x2c, 0x48, 0x66, 0x77, 0x57, 0x4f, 0x9e, 0xf8,
+                0x36, 0x34, 0xb0, 0x23,
+            ],
+            v: 3775288302605163507,
+            rseed: [
+                0x49, 0x56, 0xbb, 0xb1, 0x95, 0xa4, 0xfa, 0x66, 0xdc, 0x9c, 0xd5, 0x42, 0xc7, 0x6b,
+                0x91, 0x50, 0xc8, 0x4b, 0xf8, 0x90, 0x78, 0x99, 0x42, 0xf5, 0x5c, 0x20, 0x0b, 0x77,
+                0x3e, 0xcd, 0xd7, 0x99,
+            ],
+            asset: [
+                0xa6, 0x33, 0x05, 0x44, 0xe5, 0x46, 0x39, 0xb5, 0x41, 0x87, 0x01, 0xff, 0x4c, 0xc4,
+                0x5a, 0x31, 0xf6, 0x2e, 0xdd, 0x84, 0x3d, 0xbb, 0xdc, 0x5a, 0xa7, 0x27, 0xab, 0x79,
+                0xb4, 0x42, 0x68, 0x3c,
+            ],
+            memo: [
+                0xff, 0x2c, 0xff, 0x3e, 0xca, 0x24, 0xde, 0x3e, 0x09, 0x84, 0xe1, 0x0e, 0x68, 0xae,
+                0x38, 0x75, 0x34, 0xb9, 0x6c, 0xde, 0x37, 0x92, 0xf1, 0x35, 0xbf, 0x5f, 0x68, 0x78,
+                0x7d, 0x37, 0x0c, 0xa8, 0xc4, 0xc4, 0x07, 0x4d, 0xc5, 0xd6, 0x01, 0xae, 0x90, 0x49,
+                0x54, 0x37, 0xc3, 0xc2, 0xd4, 0x8a, 0x3d, 0x96, 0x66, 0x83, 0xac, 0x05, 0x16, 0x0b,
+                0x7a, 0x84, 0xea, 0xa7, 0xaa, 0xb7, 0x40, 0x09, 0xe5, 0x7a, 0x85, 0xf7, 0xbf, 0x68,
+                0xa2, 0xe4, 0x82, 0x00, 0x0f, 0x82, 0x9c, 0x54, 0x50, 0x73, 0xa1, 0x5d, 0x5c, 0xd0,
+                0xfc, 0xc5, 0x74, 0x39, 0xa4, 0x35, 0x0e, 0xaf, 0x09, 0x8d, 0xfb, 0x82, 0xa0, 0x85,
+                0xea, 0x8a, 0x4a, 0xf6, 0xfa, 0x83, 0x81, 0xf0, 0x65, 0x88, 0x19, 0xea, 0xb4, 0x83,
+                0xf6, 0x5b, 0x32, 0x5d, 0x5a, 0xed, 0xa1, 0x52, 0x32, 0xcf, 0xad, 0xec, 0x75, 0xab,
+                0x18, 0x66, 0xe4, 0xc0, 0x15, 0x5a, 0x9c, 0x74, 0xa7, 0xa5, 0x7c, 0xcf, 0x34, 0xc4,
+                0x83, 0xac, 0x7d, 0xa1, 0x58, 0x8a, 0x1b, 0x6b, 0x99, 0x41, 0xf1, 0x10, 0x40, 0xf9,
+                0x4c, 0xf7, 0x8f, 0xad, 0x89, 0xbf, 0x11, 0xfe, 0xd6, 0x9a, 0xa0, 0xd8, 0x31, 0x05,
+                0xad, 0xac, 0xdd, 0x4e, 0x5f, 0x04, 0xa6, 0x24, 0x24, 0x02, 0x3c, 0x9b, 0x9e, 0x33,
+                0xc4, 0xfb, 0x7f, 0x12, 0xbd, 0xf2, 0x1f, 0x07, 0xf2, 0x65, 0xc5, 0x37, 0xd5, 0x1c,
+                0x65, 0x51, 0xf4, 0x61, 0x7b, 0x91, 0x5d, 0x21, 0x99, 0x18, 0x39, 0xc3, 0xd0, 0xd3,
+                0x63, 0x93, 0xd6, 0x46, 0xe0, 0xa8, 0xa4, 0x15, 0x09, 0x21, 0x7d, 0x0e, 0x7d, 0x2c,
+                0xa1, 0xa0, 0xa0, 0xd6, 0x77, 0xa3, 0xea, 0xca, 0x23, 0xed, 0xeb, 0x07, 0xb7, 0x4e,
+                0x65, 0x2a, 0x0b, 0xc5, 0x0c, 0x6c, 0x08, 0x3a, 0x55, 0xd6, 0xc7, 0x30, 0x6e, 0x74,
+                0x08, 0x6f, 0x47, 0x68, 0x93, 0x3a, 0xa2, 0x48, 0x73, 0x68, 0x18, 0x67, 0xa7, 0x89,
+                0x3d, 0x77, 0xcb, 0x7f, 0x29, 0xb8, 0xc8, 0x47, 0xc5, 0x83, 0xf2, 0xd0, 0x71, 0xa6,
+                0x86, 0x61, 0x6e, 0x20, 0x67, 0x19, 0xf7, 0x61, 0xae, 0x39, 0xc1, 0x10, 0x44, 0x2e,
+                0x06, 0x16, 0x3d, 0x2b, 0x84, 0x59, 0x03, 0x60, 0x69, 0x5d, 0x4e, 0x19, 0x84, 0x9e,
+                0x63, 0x4f, 0x24, 0xd9, 0xad, 0x39, 0x6c, 0x19, 0xff, 0x83, 0xce, 0x74, 0xf4, 0x6e,
+                0x64, 0x5f, 0x93, 0x2e, 0x14, 0x1a, 0x41, 0x19, 0x59, 0x36, 0xc8, 0x5d, 0x51, 0x44,
+                0x14, 0xf1, 0x12, 0xe6, 0x0b, 0x1a, 0x25, 0x37, 0xc3, 0x8d, 0x6d, 0xc6, 0xc4, 0x63,
+                0x83, 0x05, 0xc9, 0xbd, 0x6c, 0x62, 0xe3, 0x66, 0xbc, 0x63, 0x12, 0x3e, 0x3e, 0x6d,
+                0xd3, 0x6e, 0xed, 0xd3, 0x13, 0x6f, 0xce, 0x8d, 0xee, 0xca, 0x2a, 0xa0, 0x9a, 0x32,
+                0x98, 0xa3, 0x9d, 0x83, 0x85, 0x9e, 0xfc, 0x9b, 0x2b, 0x69, 0xcf, 0x9a, 0x7d, 0xee,
+                0x08, 0xa9, 0x8e, 0x4b, 0xe5, 0x58, 0xac, 0x79, 0x12, 0xfd, 0xcb, 0x42, 0x20, 0x90,
+                0x75, 0x42, 0x02, 0x60, 0xf7, 0xca, 0xd0, 0xf2, 0xc0, 0x1f, 0x2a, 0xfe, 0x33, 0x07,
+                0x3f, 0x26, 0x24, 0x9d, 0x94, 0x4f, 0x7a, 0x50, 0xdd, 0x84, 0x83, 0x9b, 0xc3, 0xea,
+                0x7f, 0xde, 0xe4, 0xed, 0x71, 0x44, 0x9c, 0xf0, 0x75, 0x33, 0xd2, 0x6e, 0x1e, 0x27,
+                0xa3, 0xef, 0xb0, 0x32, 0xc3, 0xa3, 0xb3, 0x4b, 0xd3, 0x09, 0x26, 0x22, 0xd2, 0x06,
+                0x2a, 0xe5, 0x36, 0xef, 0x51, 0x49, 0xc4, 0x9b, 0x5b, 0xc9, 0x47, 0x5e, 0xaf, 0xab,
+                0x6e, 0x67, 0x57, 0x61, 0x00, 0x8b, 0x0d, 0xad, 0xde, 0xec, 0xaa, 0x60, 0x44, 0x70,
+                0xbb, 0xe0, 0xfa, 0xda, 0x25, 0x5d, 0x29, 0x0e, 0x92, 0xb1, 0x90, 0xc2, 0xc2, 0xd8,
+                0xc2, 0xde, 0xe5, 0x45, 0x5d, 0x1f, 0xa9, 0xa9,
+            ],
+            cv_net: [
+                0xde, 0x2b, 0xfc, 0x89, 0x5b, 0xa8, 0xb5, 0x43, 0x03, 0x93, 0x43, 0x4e, 0x20, 0x92,
+                0xce, 0xe7, 0x81, 0xe4, 0x00, 0x28, 0x5c, 0xc6, 0x66, 0xbc, 0x6c, 0x41, 0x89, 0xdb,
+                0x2d, 0xda, 0x71, 0x92,
+            ],
+            rho: [
+                0xea, 0x1d, 0x9d, 0x26, 0x5e, 0xf4, 0x8a, 0x18, 0x97, 0x89, 0x70, 0xb1, 0x76, 0x7b,
+                0xe0, 0xe8, 0x14, 0x11, 0x94, 0x7e, 0x9e, 0x69, 0xb7, 0x19, 0xfa, 0xb7, 0x41, 0x72,
+                0x1d, 0x40, 0x9b, 0x33,
+            ],
+            cmx: [
+                0x9e, 0x3d, 0x61, 0x35, 0x6b, 0x0d, 0x88, 0x95, 0x9e, 0x3f, 0x0f, 0xcc, 0x4a, 0x93,
+                0x2e, 0x93, 0x2e, 0xac, 0xbc, 0x80, 0x1d, 0x48, 0xc0, 0x19, 0x5b, 0x9c, 0x8b, 0xd1,
+                0x05, 0x5a, 0x8e, 0x2e,
+            ],
+            esk: [
+                0x1b, 0x52, 0x63, 0x2d, 0x2a, 0x8d, 0x58, 0xd1, 0x63, 0x57, 0xa9, 0x19, 0xa2, 0x06,
+                0x31, 0xe2, 0x91, 0x14, 0xc8, 0x60, 0x07, 0xa2, 0xb1, 0x8b, 0x25, 0xec, 0xff, 0x47,
+                0x72, 0x16, 0x8c, 0x05,
+            ],
+            ephemeral_key: [
+                0xc1, 0xce, 0x25, 0xfb, 0x89, 0xe5, 0xca, 0x89, 0x97, 0xf9, 0xb4, 0xbb, 0x0e, 0x1e,
+                0xfb, 0xcc, 0x1a, 0x8c, 0xbf, 0x44, 0xec, 0xfd, 0x33, 0x2c, 0x6c, 0x5c, 0x17, 0x3b,
+                0xb1, 0x1f, 0xb5, 0x87,
+            ],
+            shared_secret: [
+                0x2e, 0xe5, 0x69, 0xce, 0xb3, 0xfd, 0xb8, 0x67, 0xa5, 0xd8, 0x4c, 0x92, 0x68, 0x24,
+                0xef, 0x54, 0x9f, 0x2d, 0xd2, 0x8f, 0x8b, 0x04, 0x8d, 0x67, 0xd0, 0x28, 0x81, 0x7d,
+                0xbf, 0xf5, 0xd2, 0xb1,
+            ],
+            k_enc: [
+                0x41, 0x4d, 0x80, 0x67, 0xc9, 0xfe, 0xbd, 0x5e, 0xbc, 0xd9, 0xae, 0x8c, 0x05, 0x99,
+                0x4e, 0x3b, 0x06, 0x85, 0xc8, 0x86, 0x6f, 0x88, 0x95, 0x94, 0xc3, 0x74, 0xb3, 0x75,
+                0xac, 0x2c, 0x6d, 0x24,
+            ],
+            p_enc: [
+                0x03, 0x4e, 0x42, 0x6d, 0xf1, 0xad, 0x32, 0x48, 0x94, 0xbc, 0xa2, 0xc1, 0xf3, 0xdb,
+                0x77, 0x79, 0xb5, 0x84, 0x64, 0x34, 0x49, 0x56, 0xbb, 0xb1, 0x95, 0xa4, 0xfa, 0x66,
+                0xdc, 0x9c, 0xd5, 0x42, 0xc7, 0x6b, 0x91, 0x50, 0xc8, 0x4b, 0xf8, 0x90, 0x78, 0x99,
+                0x42, 0xf5, 0x5c, 0x20, 0x0b, 0x77, 0x3e, 0xcd, 0xd7, 0x99, 0xa6, 0x33, 0x05, 0x44,
+                0xe5, 0x46, 0x39, 0xb5, 0x41, 0x87, 0x01, 0xff, 0x4c, 0xc4, 0x5a, 0x31, 0xf6, 0x2e,
+                0xdd, 0x84, 0x3d, 0xbb, 0xdc, 0x5a, 0xa7, 0x27, 0xab, 0x79, 0xb4, 0x42, 0x68, 0x3c,
+                0xff, 0x2c, 0xff, 0x3e, 0xca, 0x24, 0xde, 0x3e, 0x09, 0x84, 0xe1, 0x0e, 0x68, 0xae,
+                0x38, 0x75, 0x34, 0xb9, 0x6c, 0xde, 0x37, 0x92, 0xf1, 0x35, 0xbf, 0x5f, 0x68, 0x78,
+                0x7d, 0x37, 0x0c, 0xa8, 0xc4, 0xc4, 0x07, 0x4d, 0xc5, 0xd6, 0x01, 0xae, 0x90, 0x49,
+                0x54, 0x37, 0xc3, 0xc2, 0xd4, 0x8a, 0x3d, 0x96, 0x66, 0x83, 0xac, 0x05, 0x16, 0x0b,
+                0x7a, 0x84, 0xea, 0xa7, 0xaa, 0xb7, 0x40, 0x09, 0xe5, 0x7a, 0x85, 0xf7, 0xbf, 0x68,
+                0xa2, 0xe4, 0x82, 0x00, 0x0f, 0x82, 0x9c, 0x54, 0x50, 0x73, 0xa1, 0x5d, 0x5c, 0xd0,
+                0xfc, 0xc5, 0x74, 0x39, 0xa4, 0x35, 0x0e, 0xaf, 0x09, 0x8d, 0xfb, 0x82, 0xa0, 0x85,
+                0xea, 0x8a, 0x4a, 0xf6, 0xfa, 0x83, 0x81, 0xf0, 0x65, 0x88, 0x19, 0xea, 0xb4, 0x83,
+                0xf6, 0x5b, 0x32, 0x5d, 0x5a, 0xed, 0xa1, 0x52, 0x32, 0xcf, 0xad, 0xec, 0x75, 0xab,
+                0x18, 0x66, 0xe4, 0xc0, 0x15, 0x5a, 0x9c, 0x74, 0xa7, 0xa5, 0x7c, 0xcf, 0x34, 0xc4,
+                0x83, 0xac, 0x7d, 0xa1, 0x58, 0x8a, 0x1b, 0x6b, 0x99, 0x41, 0xf1, 0x10, 0x40, 0xf9,
+                0x4c, 0xf7, 0x8f, 0xad, 0x89, 0xbf, 0x11, 0xfe, 0xd6, 0x9a, 0xa0, 0xd8, 0x31, 0x05,
+                0xad, 0xac, 0xdd, 0x4e, 0x5f, 0x04, 0xa6, 0x24, 0x24, 0x02, 0x3c, 0x9b, 0x9e, 0x33,
+                0xc4, 0xfb, 0x7f, 0x12, 0xbd, 0xf2, 0x1f, 0x07, 0xf2, 0x65, 0xc5, 0x37, 0xd5, 0x1c,
+                0x65, 0x51, 0xf4, 0x61, 0x7b, 0x91, 0x5d, 0x21, 0x99, 0x18, 0x39, 0xc3, 0xd0, 0xd3,
+                0x63, 0x93, 0xd6, 0x46, 0xe0, 0xa8, 0xa4, 0x15, 0x09, 0x21, 0x7d, 0x0e, 0x7d, 0x2c,
+                0xa1, 0xa0, 0xa0, 0xd6, 0x77, 0xa3, 0xea, 0xca, 0x23, 0xed, 0xeb, 0x07, 0xb7, 0x4e,
+                0x65, 0x2a, 0x0b, 0xc5, 0x0c, 0x6c, 0x08, 0x3a, 0x55, 0xd6, 0xc7, 0x30, 0x6e, 0x74,
+                0x08, 0x6f, 0x47, 0x68, 0x93, 0x3a, 0xa2, 0x48, 0x73, 0x68, 0x18, 0x67, 0xa7, 0x89,
+                0x3d, 0x77, 0xcb, 0x7f, 0x29, 0xb8, 0xc8, 0x47, 0xc5, 0x83, 0xf2, 0xd0, 0x71, 0xa6,
+                0x86, 0x61, 0x6e, 0x20, 0x67, 0x19, 0xf7, 0x61, 0xae, 0x39, 0xc1, 0x10, 0x44, 0x2e,
+                0x06, 0x16, 0x3d, 0x2b, 0x84, 0x59, 0x03, 0x60, 0x69, 0x5d, 0x4e, 0x19, 0x84, 0x9e,
+                0x63, 0x4f, 0x24, 0xd9, 0xad, 0x39, 0x6c, 0x19, 0xff, 0x83, 0xce, 0x74, 0xf4, 0x6e,
+                0x64, 0x5f, 0x93, 0x2e, 0x14, 0x1a, 0x41, 0x19, 0x59, 0x36, 0xc8, 0x5d, 0x51, 0x44,
+                0x14, 0xf1, 0x12, 0xe6, 0x0b, 0x1a, 0x25, 0x37, 0xc3, 0x8d, 0x6d, 0xc6, 0xc4, 0x63,
+                0x83, 0x05, 0xc9, 0xbd, 0x6c, 0x62, 0xe3, 0x66, 0xbc, 0x63, 0x12, 0x3e, 0x3e, 0x6d,
+                0xd3, 0x6e, 0xed, 0xd3, 0x13, 0x6f, 0xce, 0x8d, 0xee, 0xca, 0x2a, 0xa0, 0x9a, 0x32,
+                0x98, 0xa3, 0x9d, 0x83, 0x85, 0x9e, 0xfc, 0x9b, 0x2b, 0x69, 0xcf, 0x9a, 0x7d, 0xee,
+                0x08, 0xa9, 0x8e, 0x4b, 0xe5, 0x58, 0xac, 0x79, 0x12, 0xfd, 0xcb, 0x42, 0x20, 0x90,
+                0x75, 0x42, 0x02, 0x60, 0xf7, 0xca, 0xd0, 0xf2, 0xc0, 0x1f, 0x2a, 0xfe, 0x33, 0x07,
+                0x3f, 0x26, 0x24, 0x9d, 0x94, 0x4f, 0x7a, 0x50, 0xdd, 0x84, 0x83, 0x9b, 0xc3, 0xea,
+                0x7f, 0xde, 0xe4, 0xed, 0x71, 0x44, 0x9c, 0xf0, 0x75, 0x33, 0xd2, 0x6e, 0x1e, 0x27,
+                0xa3, 0xef, 0xb0, 0x32, 0xc3, 0xa3, 0xb3, 0x4b, 0xd3, 0x09, 0x26, 0x22, 0xd2, 0x06,
+                0x2a, 0xe5, 0x36, 0xef, 0x51, 0x49, 0xc4, 0x9b, 0x5b, 0xc9, 0x47, 0x5e, 0xaf, 0xab,
+                0x6e, 0x67, 0x57, 0x61, 0x00, 0x8b, 0x0d, 0xad, 0xde, 0xec, 0xaa, 0x60, 0x44, 0x70,
+                0xbb, 0xe0, 0xfa, 0xda, 0x25, 0x5d, 0x29, 0x0e, 0x92, 0xb1, 0x90, 0xc2, 0xc2, 0xd8,
+                0xc2, 0xde, 0xe5, 0x45, 0x5d, 0x1f, 0xa9, 0xa9,
+            ],
+            c_enc: [
+                0xbc, 0x8a, 0x16, 0xfd, 0x57, 0xbc, 0x03, 0x60, 0x59, 0xe5, 0x4d, 0xc2, 0xbc, 0xfa,
+                0xad, 0x9c, 0xc1, 0xfa, 0xe8, 0xcb, 0x2b, 0xe2, 0xa0, 0xc8, 0x5e, 0x81, 0x6c, 0x67,
+                0xfd, 0xcd, 0x0b, 0x93, 0xe6, 0xa1, 0xed, 0xc8, 0x3b, 0xfa, 0xc4, 0x1e, 0xb4, 0x19,
+                0x1c, 0x56, 0x4b, 0xac, 0x58, 0x01, 0x62, 0x92, 0x2d, 0x88, 0x25, 0x30, 0x28, 0xeb,
+                0x88, 0xed, 0x46, 0xbf, 0x24, 0x2d, 0x82, 0x28, 0x6c, 0xb0, 0xa5, 0x66, 0xce, 0x01,
+                0x18, 0x09, 0x4c, 0x90, 0x8f, 0xc2, 0x68, 0xb3, 0x2b, 0xcb, 0xdc, 0x4c, 0x22, 0x82,
+                0xc5, 0x24, 0x2a, 0x65, 0x15, 0x48, 0x8b, 0x83, 0x3d, 0x29, 0x8e, 0x49, 0xda, 0x33,
+                0x3a, 0xdd, 0x96, 0xc9, 0x9b, 0x98, 0xac, 0x06, 0x7f, 0x21, 0x41, 0x28, 0x9a, 0xcd,
+                0x89, 0x49, 0x64, 0xfc, 0xf8, 0x94, 0xc9, 0x26, 0xf1, 0x81, 0xb1, 0x19, 0x85, 0x68,
+                0xb1, 0xdd, 0x6f, 0x5e, 0xd1, 0x22, 0xdc, 0x70, 0x44, 0xad, 0x96, 0x76, 0xa7, 0xc5,
+                0xae, 0x8e, 0xa9, 0x0f, 0x64, 0xbc, 0x59, 0x09, 0x36, 0xe0, 0xdf, 0x53, 0x1c, 0x1b,
+                0x94, 0xb7, 0x35, 0xcd, 0x7b, 0x18, 0x73, 0xc8, 0x51, 0x6f, 0xea, 0x83, 0x64, 0x91,
+                0x40, 0xbc, 0xbb, 0x9b, 0x42, 0xea, 0x6c, 0xb7, 0xaf, 0x67, 0xdc, 0x2d, 0xdb, 0xb4,
+                0x7a, 0xb2, 0x25, 0xe7, 0x98, 0x29, 0xcd, 0xaf, 0x77, 0x04, 0xfb, 0x56, 0x5b, 0x43,
+                0x91, 0x76, 0xf3, 0x35, 0xe4, 0x2b, 0x64, 0xc1, 0x6d, 0xdf, 0xe0, 0x88, 0x45, 0x38,
+                0xbf, 0x43, 0x33, 0xe3, 0x2c, 0xa1, 0xe6, 0x27, 0x41, 0xc3, 0xe7, 0x4c, 0x8f, 0xaa,
+                0xde, 0x0d, 0x89, 0xfa, 0x10, 0x30, 0xcd, 0x8e, 0xfd, 0x20, 0x22, 0x3e, 0x41, 0xc3,
+                0xfc, 0xca, 0xaa, 0xe7, 0x76, 0xe6, 0x8e, 0xe8, 0x40, 0x56, 0x6f, 0x4d, 0x13, 0xc1,
+                0xc9, 0xd5, 0xcb, 0xbe, 0xcf, 0xa7, 0x49, 0x9d, 0x43, 0x12, 0x7c, 0xe8, 0xfd, 0x83,
+                0xdb, 0x6e, 0x89, 0x67, 0x90, 0x32, 0x25, 0x24, 0x87, 0x21, 0x40, 0x0d, 0x5e, 0x3e,
+                0xc0, 0xc1, 0x8e, 0x10, 0xf5, 0xe6, 0x6e, 0x10, 0x17, 0x0c, 0xb3, 0x74, 0x48, 0x22,
+                0x4a, 0xde, 0x39, 0x9f, 0x1d, 0x74, 0xa2, 0x16, 0x7d, 0x9f, 0xdb, 0xfe, 0x36, 0xe1,
+                0x28, 0xe4, 0x8c, 0x01, 0x62, 0x61, 0x16, 0xc1, 0xa2, 0xdf, 0x3c, 0xb0, 0x23, 0xd8,
+                0x0a, 0xed, 0x9b, 0xfc, 0x02, 0x71, 0xb8, 0x1f, 0xf9, 0x79, 0x81, 0x01, 0x6f, 0xff,
+                0x19, 0x61, 0x08, 0x88, 0x8b, 0xcb, 0xca, 0x84, 0x5b, 0x5d, 0x97, 0x1b, 0xd5, 0x4f,
+                0x49, 0x7d, 0x3f, 0x3a, 0x09, 0x29, 0x9e, 0x56, 0x50, 0xd3, 0x26, 0xd8, 0x9b, 0x9a,
+                0x5e, 0xff, 0x3e, 0xbd, 0x27, 0x39, 0x34, 0xc4, 0x9f, 0x81, 0x46, 0x7e, 0xb8, 0x4f,
+                0x56, 0x98, 0x90, 0xcf, 0x89, 0x05, 0xb7, 0x4c, 0xd3, 0xed, 0xa6, 0x3c, 0x53, 0x88,
+                0xd5, 0x51, 0x5e, 0x3f, 0xd8, 0x1c, 0x70, 0xc1, 0x5e, 0x2a, 0x98, 0x2d, 0x59, 0x0e,
+                0x87, 0xb8, 0x64, 0x45, 0x4b, 0xcd, 0xf5, 0xf8, 0x4d, 0x9f, 0x11, 0xcb, 0x9c, 0xf2,
+                0xb5, 0xde, 0x3c, 0x5e, 0x0e, 0x2a, 0x6c, 0x48, 0x16, 0x61, 0x64, 0x96, 0x6f, 0xb9,
+                0x0d, 0xac, 0xf8, 0x67, 0x4f, 0x9f, 0x1a, 0x34, 0xd2, 0xcd, 0xc7, 0xc9, 0x48, 0xab,
+                0x99, 0xc3, 0x58, 0xa1, 0x95, 0x47, 0x0a, 0xdd, 0x06, 0x5e, 0xaf, 0x79, 0x24, 0xfa,
+                0xed, 0x63, 0x27, 0xa6, 0x10, 0xf5, 0x2e, 0xd5, 0xd3, 0xa8, 0x7e, 0x11, 0xb5, 0x97,
+                0x4f, 0xa0, 0x60, 0x45, 0xa4, 0x08, 0x95, 0xcd, 0xad, 0x60, 0x1c, 0xae, 0x01, 0xed,
+                0xda, 0x17, 0x52, 0x81, 0x62, 0xd7, 0x21, 0x24, 0xf2, 0x05, 0x6b, 0x9a, 0xb8, 0xc0,
+                0xc0, 0xf5, 0xc6, 0xdd, 0xaa, 0x0f, 0x5e, 0x33, 0xfb, 0x04, 0x23, 0x0b, 0x61, 0x1b,
+                0xff, 0xd8, 0xbd, 0xdc, 0x63, 0x4c, 0x79, 0x60, 0xa3, 0xd4, 0xe6, 0x8f, 0x21, 0xe7,
+                0x83, 0x04, 0xe4, 0xc4, 0xd2, 0xdc, 0xd6, 0xa1, 0x9c, 0xfc, 0x04, 0x57, 0x97, 0x09,
+                0xf0, 0x33, 0xf1, 0x95, 0x78, 0xae, 0x7f, 0x0b, 0xc6, 0x46, 0x32, 0xa6, 0xd7, 0xda,
+                0x40, 0xdc, 0x0c, 0x38, 0x1d, 0xd4, 0x49, 0xe1, 0xa0, 0xb0, 0xe7, 0xf8, 0xc5, 0xfe,
+                0x88, 0xaa, 0x93, 0x4e, 0x16, 0xc8, 0xf1, 0xdb, 0xef, 0x72, 0x88, 0x34, 0xcf, 0x25,
+                0x30, 0xe3, 0x3f, 0xb9, 0x27, 0xe9, 0x96, 0xce, 0x48, 0x89, 0xf9, 0xf6, 0xf4, 0x42,
+                0x1c, 0x60, 0x78, 0xb0, 0x8d, 0x72, 0x2d, 0xc4, 0x4a, 0xb7,
+            ],
+            ock: [
+                0x9c, 0xba, 0xd2, 0xf3, 0x8b, 0xf8, 0x8f, 0x39, 0x47, 0xce, 0xf6, 0x4d, 0xe7, 0xa6,
+                0xf4, 0x3e, 0x4c, 0xbb, 0x41, 0xe6, 0xe0, 0x37, 0xf1, 0x42, 0x01, 0xae, 0xe8, 0xab,
+                0xfd, 0xf8, 0xa2, 0x35,
+            ],
+            op: [
+                0x84, 0xda, 0x49, 0x6b, 0x16, 0x0a, 0x81, 0x72, 0xc4, 0x8d, 0x76, 0xb4, 0xfb, 0x08,
+                0xbc, 0xab, 0xf4, 0x0f, 0xf1, 0xe4, 0x2c, 0x48, 0x66, 0x77, 0x57, 0x4f, 0x9e, 0xf8,
+                0x36, 0x34, 0xb0, 0x23, 0x1b, 0x52, 0x63, 0x2d, 0x2a, 0x8d, 0x58, 0xd1, 0x63, 0x57,
+                0xa9, 0x19, 0xa2, 0x06, 0x31, 0xe2, 0x91, 0x14, 0xc8, 0x60, 0x07, 0xa2, 0xb1, 0x8b,
+                0x25, 0xec, 0xff, 0x47, 0x72, 0x16, 0x8c, 0x05,
+            ],
+            c_out: [
+                0xf6, 0x25, 0xcd, 0x3d, 0x19, 0x97, 0xb0, 0xd3, 0xf2, 0x29, 0x5a, 0xac, 0xc0, 0x3a,
+                0xe0, 0xc9, 0x47, 0x28, 0xb3, 0x3c, 0xc4, 0xf1, 0x6f, 0xd4, 0x28, 0xd6, 0x5f, 0x3c,
+                0x78, 0x5e, 0x8c, 0x0b, 0xb4, 0x66, 0xc1, 0x33, 0xd4, 0x83, 0xdf, 0xc5, 0xb1, 0xb3,
+                0x15, 0x1d, 0xa2, 0xd5, 0xf2, 0x4a, 0x2b, 0x32, 0x0d, 0x8e, 0x9c, 0xd3, 0x41, 0x5c,
+                0x25, 0xb6, 0xf9, 0x76, 0x1f, 0x42, 0x70, 0x04, 0xce, 0xe5, 0x4f, 0x75, 0xf1, 0x25,
+                0xbc, 0x50, 0x5e, 0xf6, 0x26, 0xef, 0xc9, 0xdd, 0x63, 0x66,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x47, 0x30, 0x68, 0xbf, 0x68, 0xe5, 0x0b, 0xe3, 0x85, 0x7d, 0xec, 0xb2, 0xef, 0xd5,
+                0xde, 0x20, 0xea, 0xc8, 0x1b, 0x37, 0x5b, 0xd0, 0xbb, 0xe8, 0x36, 0x86, 0x6e, 0x99,
+                0x36, 0x3b, 0x37, 0x50, 0x9d, 0x53, 0x8f, 0xcc, 0xa9, 0x33, 0x37, 0xad, 0xbc, 0x24,
+                0x81, 0xe2, 0x70, 0x26, 0x18, 0x4c, 0x3f, 0x4f, 0x48, 0xcc, 0x5d, 0x5a, 0x0e, 0x4a,
+                0x4c, 0xfa, 0x4d, 0x6a, 0x24, 0x7f, 0x2e, 0x39,
+            ],
+            ovk: [
+                0x25, 0xb4, 0xc2, 0x6e, 0xb0, 0x3f, 0x71, 0x66, 0x46, 0x61, 0x9a, 0xf0, 0x24, 0x56,
+                0xae, 0x69, 0x59, 0x62, 0xfe, 0x5e, 0x93, 0x1a, 0x63, 0xb5, 0xc7, 0x90, 0x52, 0xec,
+                0xd3, 0x33, 0xe1, 0x84,
+            ],
+            default_d: [
+                0x61, 0x5f, 0x53, 0x89, 0x1a, 0x18, 0xe0, 0x52, 0x17, 0x2d, 0x81,
+            ],
+            default_pk_d: [
+                0x04, 0x47, 0x12, 0x42, 0xe1, 0xf4, 0x2b, 0xf0, 0x81, 0xf0, 0x8e, 0x9d, 0x71, 0xfe,
+                0x4f, 0x3a, 0x65, 0x91, 0xa7, 0xc0, 0x1e, 0xe2, 0xcf, 0x35, 0x30, 0x2f, 0x38, 0xd3,
+                0x34, 0xeb, 0x90, 0x2c,
+            ],
+            v: 15119422206032203650,
+            rseed: [
+                0x45, 0x60, 0x3a, 0x53, 0x46, 0x2c, 0x60, 0xe1, 0xf6, 0xcb, 0x0c, 0x9c, 0xa0, 0x39,
+                0x0c, 0x48, 0x82, 0x24, 0xc3, 0x13, 0x26, 0x9f, 0xcd, 0x59, 0xfc, 0xb6, 0x11, 0xfb,
+                0x2d, 0x9b, 0x4c, 0x8f,
+            ],
+            asset: [
+                0x61, 0x16, 0xcf, 0xec, 0x26, 0x47, 0xcc, 0xaa, 0xe1, 0xc7, 0x4b, 0x41, 0x6f, 0x3e,
+                0x6a, 0xe8, 0xf7, 0xcc, 0x60, 0xea, 0xaf, 0x7b, 0x6a, 0x59, 0x0d, 0x51, 0x54, 0x41,
+                0x38, 0xe1, 0x73, 0x29,
+            ],
+            memo: [
+                0xff, 0xa6, 0x01, 0xbb, 0x1c, 0xb8, 0xd0, 0x7d, 0x79, 0x7b, 0xf5, 0xde, 0x52, 0xbc,
+                0xee, 0xb0, 0x23, 0x01, 0xc8, 0x96, 0x2a, 0xc1, 0xfc, 0x04, 0x91, 0xdc, 0x81, 0xaf,
+                0xfd, 0x6c, 0x1e, 0xbf, 0x89, 0xa1, 0x3d, 0x6f, 0x29, 0x0e, 0xda, 0x5d, 0x5c, 0xef,
+                0x38, 0x22, 0x15, 0xc5, 0xe9, 0x51, 0xd7, 0x13, 0x05, 0xef, 0x33, 0xd9, 0x73, 0x71,
+                0x26, 0xd0, 0xe6, 0x62, 0x90, 0x5f, 0x12, 0x50, 0x92, 0x6f, 0x6a, 0x22, 0x99, 0x90,
+                0xe3, 0x8f, 0x69, 0xad, 0x9a, 0x91, 0x92, 0xb3, 0x02, 0xf2, 0x6b, 0xdd, 0xa4, 0x65,
+                0xd9, 0x0b, 0x94, 0xb1, 0x2c, 0x57, 0xfa, 0x3f, 0xd6, 0x93, 0x00, 0x83, 0xf1, 0x84,
+                0x43, 0x8d, 0x8a, 0x88, 0x9d, 0x3f, 0x5e, 0xce, 0xa2, 0xc6, 0xd2, 0x3d, 0x67, 0x36,
+                0xf2, 0xa0, 0xf1, 0x8e, 0x26, 0xf4, 0xfa, 0x45, 0xd1, 0xbe, 0x8f, 0x3d, 0xc4, 0xa7,
+                0x07, 0x13, 0x7e, 0x95, 0xd2, 0xad, 0x59, 0x4f, 0x6c, 0x03, 0xd2, 0x49, 0x23, 0x06,
+                0x7a, 0xe4, 0x7f, 0xd6, 0x42, 0x5e, 0xfb, 0x9c, 0x1d, 0x50, 0x4e, 0x6f, 0xd5, 0x57,
+                0x53, 0x40, 0x94, 0x56, 0x01, 0xfe, 0x80, 0x6f, 0x57, 0x56, 0xac, 0xb5, 0x62, 0xf1,
+                0x3c, 0x0c, 0xa1, 0xd8, 0x03, 0xa1, 0x95, 0xc2, 0xeb, 0xb2, 0xef, 0x02, 0xac, 0x33,
+                0xe6, 0xa8, 0x8d, 0xea, 0x07, 0x5b, 0xa9, 0x96, 0xd3, 0xc3, 0x36, 0x64, 0x8e, 0x86,
+                0x94, 0xd3, 0xa1, 0x9d, 0x3d, 0xca, 0x53, 0x1b, 0xeb, 0x50, 0xd4, 0x32, 0x7c, 0x5c,
+                0x0c, 0x23, 0xcb, 0x7c, 0xfd, 0xb0, 0x8c, 0xa7, 0xcf, 0x2c, 0xac, 0x6b, 0xc1, 0x39,
+                0xd0, 0x74, 0x14, 0x73, 0xd3, 0x76, 0x02, 0x9c, 0xb4, 0xab, 0x6b, 0xf0, 0x54, 0x55,
+                0x7c, 0xe2, 0x94, 0xc7, 0x28, 0xa4, 0x68, 0x7d, 0x57, 0xec, 0x89, 0x09, 0xff, 0x51,
+                0xa4, 0xd0, 0x2f, 0x9d, 0xcd, 0x11, 0x19, 0x3d, 0x7d, 0x1c, 0x9f, 0xda, 0xe6, 0xa1,
+                0x73, 0x96, 0xa1, 0xbf, 0x57, 0xa9, 0x94, 0x93, 0x4f, 0x5e, 0x7a, 0x59, 0xf0, 0x45,
+                0xde, 0xbe, 0xaf, 0xf6, 0x2e, 0xf3, 0x26, 0xb9, 0x47, 0xf2, 0xa8, 0xb4, 0x95, 0x55,
+                0xe4, 0xd9, 0x9b, 0x3b, 0xf5, 0xc8, 0x1f, 0xf9, 0xfe, 0x31, 0x4e, 0x04, 0x7a, 0xf1,
+                0x52, 0x50, 0x8f, 0x57, 0x01, 0x5c, 0xa4, 0x02, 0xc6, 0x7d, 0x92, 0x5c, 0x99, 0xac,
+                0xea, 0x3e, 0xe8, 0xcc, 0x4b, 0x00, 0x8c, 0x5c, 0xb4, 0x39, 0x66, 0xe7, 0x14, 0xef,
+                0x48, 0x0f, 0xd0, 0x5e, 0x07, 0xc7, 0xb2, 0xdd, 0xa9, 0xaa, 0x39, 0x66, 0x11, 0x3e,
+                0xaa, 0x29, 0x3d, 0x3f, 0x62, 0x2b, 0x30, 0x9d, 0x64, 0x80, 0x3c, 0xe1, 0xe6, 0x37,
+                0x8b, 0x6a, 0xac, 0x4f, 0xab, 0x52, 0x7c, 0x43, 0xcd, 0x45, 0xed, 0x0a, 0x3c, 0x1a,
+                0x4b, 0x9f, 0xb1, 0x8d, 0xcc, 0xcf, 0xcd, 0xb6, 0xac, 0x0c, 0x24, 0x21, 0x63, 0x9c,
+                0xda, 0x00, 0x75, 0xa2, 0x0d, 0xc5, 0x11, 0x1b, 0x8d, 0x3d, 0x31, 0x99, 0x49, 0x5b,
+                0xd9, 0x13, 0x3d, 0xba, 0xb9, 0x45, 0x41, 0x41, 0x0e, 0x4f, 0xba, 0x92, 0xc7, 0xb6,
+                0x06, 0xa5, 0xcb, 0x12, 0x2f, 0x14, 0x0c, 0xf1, 0xa3, 0x59, 0x6f, 0x27, 0x88, 0xf3,
+                0xc8, 0xb9, 0x26, 0x60, 0xf1, 0x4c, 0xb6, 0x5a, 0xf5, 0xdd, 0x23, 0xdf, 0xdb, 0xac,
+                0x13, 0x71, 0xec, 0xf4, 0xb3, 0x37, 0x12, 0xfe, 0xd2, 0x29, 0x2c, 0x44, 0xf7, 0x08,
+                0x34, 0xcf, 0x96, 0xc0, 0x5d, 0x58, 0x82, 0x7e, 0x69, 0xbf, 0xc2, 0xe6, 0x96, 0xfa,
+                0x08, 0x74, 0x86, 0x9c, 0x02, 0xf3, 0xdc, 0xa1, 0x1c, 0x3b, 0x90, 0xcb, 0x21, 0x4e,
+                0x68, 0xbc, 0x1c, 0xae, 0x03, 0x9d, 0x7a, 0x14, 0x6c, 0xdc, 0x1d, 0x60, 0x9d, 0x7a,
+                0x6b, 0x3f, 0xd5, 0xd4, 0x61, 0xb0, 0x95, 0x1c,
+            ],
+            cv_net: [
+                0x45, 0x37, 0x85, 0x3e, 0x18, 0xac, 0x2c, 0xe9, 0x37, 0x79, 0x8c, 0x9b, 0xce, 0xa9,
+                0x80, 0x2d, 0x65, 0x00, 0x74, 0xdb, 0xd7, 0xe0, 0x6a, 0x48, 0x98, 0x03, 0x15, 0x30,
+                0x78, 0xe9, 0x97, 0x0b,
+            ],
+            rho: [
+                0x9a, 0xd0, 0x7f, 0x1c, 0x28, 0x7b, 0xdd, 0x53, 0x4f, 0x6f, 0x7e, 0xae, 0x08, 0xf7,
+                0x85, 0x72, 0xa3, 0x05, 0xfa, 0x3b, 0x70, 0x68, 0xa3, 0x78, 0x38, 0x27, 0xaf, 0xe2,
+                0x14, 0x7a, 0x27, 0x10,
+            ],
+            cmx: [
+                0xf2, 0x04, 0x22, 0x51, 0xa0, 0x59, 0xa2, 0xf5, 0x8a, 0xb8, 0xe9, 0x0b, 0x52, 0x64,
+                0xd0, 0xa4, 0x3f, 0x96, 0xd7, 0x7e, 0xdd, 0x54, 0xf8, 0x0f, 0xf4, 0x9d, 0x43, 0x86,
+                0x81, 0x4d, 0x73, 0x2e,
+            ],
+            esk: [
+                0xb5, 0x9a, 0x18, 0x4d, 0x24, 0xe6, 0x1b, 0x9f, 0x9d, 0x37, 0x1d, 0xa4, 0xb1, 0x44,
+                0x01, 0x72, 0x02, 0x9a, 0x2e, 0xbc, 0x0a, 0x2a, 0xbe, 0xb8, 0xaf, 0x2b, 0xd1, 0xa0,
+                0x8c, 0x67, 0xd9, 0x3f,
+            ],
+            ephemeral_key: [
+                0x46, 0x73, 0x1f, 0xff, 0xc5, 0x9a, 0xf4, 0xc1, 0x28, 0x82, 0xbc, 0xca, 0xea, 0xa7,
+                0xb8, 0xed, 0x39, 0x0b, 0x14, 0x66, 0x72, 0xe1, 0x36, 0x51, 0xc3, 0x2e, 0x57, 0x80,
+                0x62, 0x68, 0x65, 0xa7,
+            ],
+            shared_secret: [
+                0x9d, 0x56, 0xbd, 0x96, 0x00, 0x39, 0x62, 0x5e, 0x11, 0x7d, 0x7b, 0xfe, 0xd4, 0x3a,
+                0x57, 0x3b, 0x11, 0x51, 0x7f, 0xfa, 0x76, 0x14, 0xea, 0x2d, 0xa7, 0x7e, 0xdf, 0x62,
+                0x7f, 0x6f, 0x13, 0xaa,
+            ],
+            k_enc: [
+                0x04, 0x2f, 0x92, 0x82, 0x13, 0x44, 0xde, 0x97, 0x7c, 0xee, 0x89, 0x9e, 0xd2, 0x1b,
+                0xc8, 0x48, 0xf5, 0xc4, 0xfe, 0xdc, 0x39, 0xf2, 0xdf, 0xed, 0xad, 0x62, 0xcc, 0x7a,
+                0x92, 0x7f, 0x74, 0xfd,
+            ],
+            p_enc: [
+                0x03, 0x61, 0x5f, 0x53, 0x89, 0x1a, 0x18, 0xe0, 0x52, 0x17, 0x2d, 0x81, 0x82, 0xcf,
+                0xb3, 0xe7, 0x63, 0xfa, 0xd2, 0xd1, 0x45, 0x60, 0x3a, 0x53, 0x46, 0x2c, 0x60, 0xe1,
+                0xf6, 0xcb, 0x0c, 0x9c, 0xa0, 0x39, 0x0c, 0x48, 0x82, 0x24, 0xc3, 0x13, 0x26, 0x9f,
+                0xcd, 0x59, 0xfc, 0xb6, 0x11, 0xfb, 0x2d, 0x9b, 0x4c, 0x8f, 0x61, 0x16, 0xcf, 0xec,
+                0x26, 0x47, 0xcc, 0xaa, 0xe1, 0xc7, 0x4b, 0x41, 0x6f, 0x3e, 0x6a, 0xe8, 0xf7, 0xcc,
+                0x60, 0xea, 0xaf, 0x7b, 0x6a, 0x59, 0x0d, 0x51, 0x54, 0x41, 0x38, 0xe1, 0x73, 0x29,
+                0xff, 0xa6, 0x01, 0xbb, 0x1c, 0xb8, 0xd0, 0x7d, 0x79, 0x7b, 0xf5, 0xde, 0x52, 0xbc,
+                0xee, 0xb0, 0x23, 0x01, 0xc8, 0x96, 0x2a, 0xc1, 0xfc, 0x04, 0x91, 0xdc, 0x81, 0xaf,
+                0xfd, 0x6c, 0x1e, 0xbf, 0x89, 0xa1, 0x3d, 0x6f, 0x29, 0x0e, 0xda, 0x5d, 0x5c, 0xef,
+                0x38, 0x22, 0x15, 0xc5, 0xe9, 0x51, 0xd7, 0x13, 0x05, 0xef, 0x33, 0xd9, 0x73, 0x71,
+                0x26, 0xd0, 0xe6, 0x62, 0x90, 0x5f, 0x12, 0x50, 0x92, 0x6f, 0x6a, 0x22, 0x99, 0x90,
+                0xe3, 0x8f, 0x69, 0xad, 0x9a, 0x91, 0x92, 0xb3, 0x02, 0xf2, 0x6b, 0xdd, 0xa4, 0x65,
+                0xd9, 0x0b, 0x94, 0xb1, 0x2c, 0x57, 0xfa, 0x3f, 0xd6, 0x93, 0x00, 0x83, 0xf1, 0x84,
+                0x43, 0x8d, 0x8a, 0x88, 0x9d, 0x3f, 0x5e, 0xce, 0xa2, 0xc6, 0xd2, 0x3d, 0x67, 0x36,
+                0xf2, 0xa0, 0xf1, 0x8e, 0x26, 0xf4, 0xfa, 0x45, 0xd1, 0xbe, 0x8f, 0x3d, 0xc4, 0xa7,
+                0x07, 0x13, 0x7e, 0x95, 0xd2, 0xad, 0x59, 0x4f, 0x6c, 0x03, 0xd2, 0x49, 0x23, 0x06,
+                0x7a, 0xe4, 0x7f, 0xd6, 0x42, 0x5e, 0xfb, 0x9c, 0x1d, 0x50, 0x4e, 0x6f, 0xd5, 0x57,
+                0x53, 0x40, 0x94, 0x56, 0x01, 0xfe, 0x80, 0x6f, 0x57, 0x56, 0xac, 0xb5, 0x62, 0xf1,
+                0x3c, 0x0c, 0xa1, 0xd8, 0x03, 0xa1, 0x95, 0xc2, 0xeb, 0xb2, 0xef, 0x02, 0xac, 0x33,
+                0xe6, 0xa8, 0x8d, 0xea, 0x07, 0x5b, 0xa9, 0x96, 0xd3, 0xc3, 0x36, 0x64, 0x8e, 0x86,
+                0x94, 0xd3, 0xa1, 0x9d, 0x3d, 0xca, 0x53, 0x1b, 0xeb, 0x50, 0xd4, 0x32, 0x7c, 0x5c,
+                0x0c, 0x23, 0xcb, 0x7c, 0xfd, 0xb0, 0x8c, 0xa7, 0xcf, 0x2c, 0xac, 0x6b, 0xc1, 0x39,
+                0xd0, 0x74, 0x14, 0x73, 0xd3, 0x76, 0x02, 0x9c, 0xb4, 0xab, 0x6b, 0xf0, 0x54, 0x55,
+                0x7c, 0xe2, 0x94, 0xc7, 0x28, 0xa4, 0x68, 0x7d, 0x57, 0xec, 0x89, 0x09, 0xff, 0x51,
+                0xa4, 0xd0, 0x2f, 0x9d, 0xcd, 0x11, 0x19, 0x3d, 0x7d, 0x1c, 0x9f, 0xda, 0xe6, 0xa1,
+                0x73, 0x96, 0xa1, 0xbf, 0x57, 0xa9, 0x94, 0x93, 0x4f, 0x5e, 0x7a, 0x59, 0xf0, 0x45,
+                0xde, 0xbe, 0xaf, 0xf6, 0x2e, 0xf3, 0x26, 0xb9, 0x47, 0xf2, 0xa8, 0xb4, 0x95, 0x55,
+                0xe4, 0xd9, 0x9b, 0x3b, 0xf5, 0xc8, 0x1f, 0xf9, 0xfe, 0x31, 0x4e, 0x04, 0x7a, 0xf1,
+                0x52, 0x50, 0x8f, 0x57, 0x01, 0x5c, 0xa4, 0x02, 0xc6, 0x7d, 0x92, 0x5c, 0x99, 0xac,
+                0xea, 0x3e, 0xe8, 0xcc, 0x4b, 0x00, 0x8c, 0x5c, 0xb4, 0x39, 0x66, 0xe7, 0x14, 0xef,
+                0x48, 0x0f, 0xd0, 0x5e, 0x07, 0xc7, 0xb2, 0xdd, 0xa9, 0xaa, 0x39, 0x66, 0x11, 0x3e,
+                0xaa, 0x29, 0x3d, 0x3f, 0x62, 0x2b, 0x30, 0x9d, 0x64, 0x80, 0x3c, 0xe1, 0xe6, 0x37,
+                0x8b, 0x6a, 0xac, 0x4f, 0xab, 0x52, 0x7c, 0x43, 0xcd, 0x45, 0xed, 0x0a, 0x3c, 0x1a,
+                0x4b, 0x9f, 0xb1, 0x8d, 0xcc, 0xcf, 0xcd, 0xb6, 0xac, 0x0c, 0x24, 0x21, 0x63, 0x9c,
+                0xda, 0x00, 0x75, 0xa2, 0x0d, 0xc5, 0x11, 0x1b, 0x8d, 0x3d, 0x31, 0x99, 0x49, 0x5b,
+                0xd9, 0x13, 0x3d, 0xba, 0xb9, 0x45, 0x41, 0x41, 0x0e, 0x4f, 0xba, 0x92, 0xc7, 0xb6,
+                0x06, 0xa5, 0xcb, 0x12, 0x2f, 0x14, 0x0c, 0xf1, 0xa3, 0x59, 0x6f, 0x27, 0x88, 0xf3,
+                0xc8, 0xb9, 0x26, 0x60, 0xf1, 0x4c, 0xb6, 0x5a, 0xf5, 0xdd, 0x23, 0xdf, 0xdb, 0xac,
+                0x13, 0x71, 0xec, 0xf4, 0xb3, 0x37, 0x12, 0xfe, 0xd2, 0x29, 0x2c, 0x44, 0xf7, 0x08,
+                0x34, 0xcf, 0x96, 0xc0, 0x5d, 0x58, 0x82, 0x7e, 0x69, 0xbf, 0xc2, 0xe6, 0x96, 0xfa,
+                0x08, 0x74, 0x86, 0x9c, 0x02, 0xf3, 0xdc, 0xa1, 0x1c, 0x3b, 0x90, 0xcb, 0x21, 0x4e,
+                0x68, 0xbc, 0x1c, 0xae, 0x03, 0x9d, 0x7a, 0x14, 0x6c, 0xdc, 0x1d, 0x60, 0x9d, 0x7a,
+                0x6b, 0x3f, 0xd5, 0xd4, 0x61, 0xb0, 0x95, 0x1c,
+            ],
+            c_enc: [
+                0x16, 0x76, 0x72, 0x3a, 0x18, 0xff, 0x58, 0x77, 0x70, 0x15, 0x8d, 0x6b, 0x85, 0x09,
+                0x3c, 0x49, 0x20, 0x16, 0xf8, 0x7e, 0xc3, 0xfa, 0xe8, 0xb0, 0xb4, 0x7c, 0xd9, 0x29,
+                0x8f, 0xa2, 0x07, 0xc4, 0xb6, 0x09, 0xc6, 0x92, 0xdd, 0xb9, 0x10, 0x19, 0x72, 0xc9,
+                0x4c, 0x71, 0x87, 0x84, 0x85, 0x42, 0x1e, 0xfb, 0x70, 0x1c, 0xf5, 0x15, 0xa2, 0x3f,
+                0xbf, 0x36, 0xfe, 0x93, 0x54, 0x0d, 0x82, 0xd6, 0x9a, 0x72, 0x62, 0x4e, 0x25, 0x4f,
+                0xe3, 0xa0, 0x11, 0xc5, 0xdb, 0xdb, 0xd2, 0xbd, 0xff, 0xb8, 0x83, 0x8a, 0xf3, 0x7d,
+                0x03, 0xce, 0x69, 0x12, 0x6b, 0x2f, 0x68, 0x21, 0x25, 0xb7, 0xa9, 0xb2, 0xa3, 0xee,
+                0x11, 0x8a, 0xe5, 0xad, 0xb4, 0x60, 0xa4, 0x68, 0x7c, 0x24, 0x30, 0x18, 0x7b, 0xfd,
+                0x0f, 0x6c, 0x2a, 0x3d, 0x5d, 0x74, 0x30, 0x1c, 0xbd, 0x8f, 0xd0, 0x26, 0xc8, 0x64,
+                0x4f, 0xbf, 0xa2, 0x65, 0x69, 0x88, 0xe9, 0x58, 0x59, 0x0b, 0x81, 0x6a, 0x1e, 0x64,
+                0x0e, 0x46, 0x71, 0x0e, 0x46, 0xfa, 0x15, 0x94, 0xff, 0x2a, 0x61, 0xd6, 0xf6, 0xe7,
+                0xb4, 0xa9, 0xf6, 0xe0, 0xde, 0x68, 0x3d, 0x95, 0xe5, 0x9d, 0x43, 0x57, 0xf7, 0x9a,
+                0xc4, 0x93, 0x86, 0x6d, 0xab, 0x06, 0x57, 0x76, 0xc0, 0xb1, 0x43, 0x6b, 0x8e, 0x04,
+                0x47, 0x68, 0x43, 0xc2, 0x8b, 0x48, 0x45, 0xea, 0xff, 0x17, 0x83, 0xa8, 0x50, 0xc2,
+                0x4a, 0x90, 0x65, 0xc3, 0x36, 0x51, 0xc4, 0xb3, 0xdd, 0x19, 0x92, 0xf4, 0xf2, 0x08,
+                0xb8, 0x51, 0xbf, 0xff, 0xe9, 0xb7, 0xbb, 0x7a, 0xad, 0x76, 0x7c, 0x23, 0x60, 0xb0,
+                0x5c, 0x11, 0x23, 0x09, 0x66, 0xda, 0x55, 0x7e, 0x31, 0x3a, 0xe6, 0x1c, 0x95, 0x42,
+                0x97, 0x66, 0x10, 0x6b, 0x4b, 0x1b, 0x35, 0x47, 0x64, 0xe4, 0xe1, 0xe4, 0xdf, 0x90,
+                0xc1, 0x2d, 0x24, 0x37, 0x9d, 0x67, 0xba, 0xc6, 0x66, 0x97, 0xaf, 0x23, 0x44, 0x97,
+                0xf2, 0xd6, 0xf9, 0xa6, 0x12, 0x85, 0x0d, 0xd7, 0x1d, 0x1c, 0x98, 0xce, 0x65, 0xd8,
+                0x50, 0x7f, 0xa3, 0x46, 0x35, 0x83, 0x12, 0x39, 0xe2, 0x10, 0xf7, 0xdb, 0xb3, 0x05,
+                0x04, 0x2d, 0x47, 0x50, 0xd9, 0x5a, 0xdf, 0xff, 0xc9, 0x8d, 0xeb, 0x0f, 0x17, 0x13,
+                0xbc, 0x01, 0xaf, 0x5d, 0xb5, 0x99, 0x29, 0x89, 0x76, 0xab, 0xba, 0xdb, 0x0f, 0x4d,
+                0xed, 0x1a, 0x2f, 0xe4, 0xcf, 0x90, 0x60, 0x0e, 0x0d, 0x28, 0xd3, 0x07, 0xc6, 0x41,
+                0xf7, 0x52, 0x3c, 0x16, 0x66, 0x40, 0x1d, 0x78, 0x6f, 0xd2, 0x4a, 0xe1, 0x68, 0x0f,
+                0xe9, 0x26, 0x70, 0x4c, 0xb6, 0xe2, 0xaf, 0x80, 0x1a, 0x0d, 0x82, 0x75, 0x9d, 0xd8,
+                0x7a, 0x8c, 0xd8, 0x7b, 0x85, 0xbb, 0x07, 0x51, 0xa7, 0x08, 0xc9, 0xf4, 0xa7, 0xd3,
+                0x24, 0xe5, 0xc9, 0x3a, 0xd2, 0x2b, 0x86, 0x43, 0xdf, 0xfa, 0x5f, 0x50, 0x79, 0xfc,
+                0x6f, 0x01, 0x6d, 0x94, 0x3c, 0x99, 0x09, 0x27, 0x5c, 0x96, 0xf5, 0xfe, 0x7b, 0x56,
+                0x33, 0x3c, 0x24, 0x01, 0x99, 0x73, 0xd9, 0x4f, 0x06, 0xeb, 0xf6, 0xc0, 0xf6, 0xef,
+                0xdd, 0x42, 0xea, 0xb0, 0x63, 0x49, 0xd5, 0xe8, 0xb9, 0x60, 0xba, 0x8c, 0x68, 0xee,
+                0xfd, 0x44, 0x49, 0x99, 0xf6, 0xfa, 0x3d, 0x6a, 0x3a, 0xe3, 0x1a, 0xe8, 0x54, 0x6e,
+                0xdc, 0x62, 0x78, 0x25, 0x63, 0x7e, 0x1e, 0x86, 0x39, 0x8d, 0x0e, 0xd3, 0xd8, 0x8b,
+                0xfa, 0xea, 0x8b, 0x4b, 0x08, 0x50, 0xd8, 0xa8, 0x28, 0x6e, 0xa9, 0xf3, 0xd1, 0x3f,
+                0xa8, 0xf4, 0x16, 0x53, 0x45, 0x1b, 0x97, 0xb3, 0x8b, 0x06, 0x3a, 0x5f, 0xc6, 0xdb,
+                0xe4, 0xe9, 0x19, 0x94, 0x87, 0xc9, 0x73, 0xef, 0x8f, 0x2c, 0x26, 0x3f, 0x85, 0x05,
+                0xf4, 0xc3, 0xbe, 0xc9, 0xd1, 0x79, 0xbb, 0xd6, 0x5d, 0x1e, 0xdc, 0x58, 0x95, 0xa1,
+                0x6c, 0xc7, 0x98, 0x6b, 0xcf, 0xc4, 0xba, 0xe8, 0x7e, 0xc0, 0xb2, 0x9b, 0xf1, 0xb3,
+                0x97, 0x61, 0x5c, 0x95, 0x13, 0xfa, 0x52, 0xeb, 0xe1, 0xe9, 0xfc, 0xfb, 0xf1, 0x92,
+                0xed, 0x49, 0x26, 0x27, 0x27, 0xa0, 0x8a, 0xd3, 0xc2, 0x95, 0x5b, 0x3d, 0xf2, 0xee,
+                0xad, 0x30, 0x24, 0x3e, 0x32, 0xb2, 0x54, 0x1e, 0x8f, 0x9f, 0xce, 0x6c, 0xa5, 0xe7,
+                0x0f, 0xf3, 0xa5, 0xe9, 0x35, 0x2b, 0xb8, 0x93, 0xe3, 0xdc, 0xa2, 0x74, 0xa1, 0x11,
+                0xbb, 0xd6, 0x9c, 0x2b, 0x4c, 0x2e, 0xc9, 0x49, 0x81, 0x3d, 0xb7, 0x8c, 0x5e, 0x16,
+                0xbc, 0x7a, 0xf6, 0x72, 0xb2, 0x0d, 0x7a, 0x16, 0xec, 0x48,
+            ],
+            ock: [
+                0x97, 0x9b, 0x31, 0x5d, 0x3e, 0x1f, 0x5c, 0xa1, 0x8a, 0x92, 0x86, 0xd9, 0x2c, 0xc8,
+                0x8e, 0x63, 0x62, 0x4b, 0x39, 0x9b, 0x29, 0x19, 0xbf, 0x4e, 0x67, 0xda, 0x7c, 0xd3,
+                0x94, 0xf4, 0x5c, 0x49,
+            ],
+            op: [
+                0x04, 0x47, 0x12, 0x42, 0xe1, 0xf4, 0x2b, 0xf0, 0x81, 0xf0, 0x8e, 0x9d, 0x71, 0xfe,
+                0x4f, 0x3a, 0x65, 0x91, 0xa7, 0xc0, 0x1e, 0xe2, 0xcf, 0x35, 0x30, 0x2f, 0x38, 0xd3,
+                0x34, 0xeb, 0x90, 0x2c, 0xb5, 0x9a, 0x18, 0x4d, 0x24, 0xe6, 0x1b, 0x9f, 0x9d, 0x37,
+                0x1d, 0xa4, 0xb1, 0x44, 0x01, 0x72, 0x02, 0x9a, 0x2e, 0xbc, 0x0a, 0x2a, 0xbe, 0xb8,
+                0xaf, 0x2b, 0xd1, 0xa0, 0x8c, 0x67, 0xd9, 0x3f,
+            ],
+            c_out: [
+                0x83, 0xf7, 0xa1, 0xda, 0x72, 0x4d, 0xd1, 0x54, 0xe7, 0xd9, 0x47, 0xc0, 0xfc, 0x83,
+                0x42, 0x87, 0xf3, 0x3c, 0xd4, 0xb3, 0x4a, 0xfa, 0xc0, 0xda, 0x55, 0xe4, 0x37, 0xaf,
+                0xae, 0x67, 0xa9, 0x9c, 0xbd, 0x89, 0x75, 0xc9, 0x54, 0xcf, 0x41, 0xaa, 0x1e, 0x9a,
+                0x8f, 0x99, 0x98, 0x3d, 0x58, 0x6f, 0x5e, 0x35, 0x37, 0xda, 0xb7, 0x2a, 0xe1, 0x82,
+                0x7a, 0xa5, 0xdf, 0xc9, 0xdd, 0xad, 0x06, 0x26, 0x78, 0x84, 0x6f, 0xf8, 0x09, 0x3d,
+                0xfd, 0x15, 0xf6, 0x3d, 0x47, 0xe5, 0xa3, 0xbb, 0x74, 0x39,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xfc, 0x8c, 0x64, 0x1c, 0x0b, 0x28, 0xbe, 0xbf, 0x85, 0x24, 0x25, 0xae, 0x95, 0x5f,
+                0xe6, 0x40, 0x1c, 0xfd, 0x9e, 0x60, 0x63, 0xf2, 0x50, 0x11, 0x3d, 0xa0, 0xb5, 0x8b,
+                0x2a, 0x0f, 0x49, 0xb9, 0x12, 0x0b, 0x89, 0x9f, 0x08, 0x10, 0x6b, 0x30, 0x86, 0xb2,
+                0xf4, 0x11, 0x63, 0x6f, 0x50, 0xab, 0x48, 0x7c, 0xfb, 0x28, 0x81, 0x89, 0x77, 0x8f,
+                0xe4, 0xe5, 0xa1, 0x91, 0x8b, 0x98, 0xd5, 0x0a,
+            ],
+            ovk: [
+                0xbe, 0xd1, 0x7d, 0xf5, 0xf8, 0x88, 0xc8, 0xca, 0x14, 0x67, 0xae, 0x17, 0xdb, 0xbc,
+                0xde, 0x31, 0xc1, 0x10, 0x5c, 0xb5, 0xbd, 0xa8, 0x8a, 0xc6, 0xc6, 0x27, 0x00, 0x2c,
+                0xe2, 0x1c, 0x02, 0x14,
+            ],
+            default_d: [
+                0xd2, 0xf7, 0x5f, 0x7c, 0xe7, 0x1b, 0xa4, 0xa7, 0xab, 0x69, 0xb8,
+            ],
+            default_pk_d: [
+                0x49, 0x19, 0x01, 0x2e, 0x40, 0x43, 0x82, 0xeb, 0xee, 0x8e, 0x60, 0xe9, 0xd4, 0xf1,
+                0x30, 0x79, 0xc0, 0x8d, 0x9c, 0x6d, 0x50, 0xf9, 0x35, 0x86, 0x7d, 0x33, 0x01, 0xf6,
+                0x89, 0xcf, 0xf9, 0x1e,
+            ],
+            v: 7555450289479839818,
+            rseed: [
+                0x13, 0xeb, 0x7c, 0xea, 0xa5, 0xff, 0x12, 0x90, 0xb0, 0x3e, 0xc9, 0x1c, 0xe6, 0xdd,
+                0x28, 0x13, 0x0c, 0x3a, 0xb0, 0xb2, 0x3b, 0x60, 0x2b, 0xd5, 0xbe, 0x5d, 0xc2, 0x60,
+                0x03, 0xaa, 0xe0, 0x4b,
+            ],
+            asset: [
+                0x29, 0x8a, 0xc0, 0xaf, 0xdc, 0x52, 0x87, 0xd7, 0xad, 0x12, 0x4c, 0xd9, 0x40, 0x5a,
+                0x62, 0xcd, 0x1c, 0xa0, 0x8b, 0x28, 0x2e, 0xfe, 0xf7, 0xf9, 0x28, 0xdf, 0x76, 0xe2,
+                0x82, 0x1a, 0x41, 0x84,
+            ],
+            memo: [
+                0xff, 0x33, 0xd7, 0xbd, 0x25, 0x90, 0xe9, 0x0c, 0x8c, 0x38, 0x8e, 0xa7, 0x95, 0x51,
+                0x22, 0xdb, 0xac, 0xa6, 0x7b, 0x30, 0x39, 0x5a, 0x92, 0x8b, 0x57, 0xb8, 0x57, 0x51,
+                0x23, 0x20, 0x5a, 0xe1, 0x91, 0x52, 0xe4, 0x1e, 0x00, 0x29, 0x31, 0xb4, 0x57, 0x46,
+                0x19, 0x8e, 0x5d, 0xd9, 0x57, 0x1a, 0x56, 0xa7, 0xe0, 0xd4, 0x23, 0xff, 0x27, 0x98,
+                0x9d, 0x3e, 0xb4, 0x17, 0xec, 0xd3, 0xc3, 0x09, 0x3f, 0xb8, 0x2c, 0x56, 0x58, 0xe2,
+                0x96, 0x24, 0xc5, 0x32, 0x19, 0xa6, 0x0c, 0xd0, 0xa8, 0xc4, 0xda, 0x36, 0x7e, 0x29,
+                0xa7, 0x17, 0x79, 0xa7, 0x30, 0x32, 0x98, 0x5a, 0x3d, 0x1f, 0xd0, 0x3d, 0xd4, 0xd0,
+                0x6e, 0x05, 0x56, 0x6f, 0x3b, 0x84, 0x36, 0x7c, 0xf0, 0xfa, 0xee, 0x9b, 0xc3, 0xbd,
+                0x7a, 0x3a, 0x60, 0x6a, 0x9f, 0xdb, 0x84, 0x9c, 0x5d, 0x82, 0xd0, 0xa6, 0x19, 0x23,
+                0xc2, 0xe5, 0xd8, 0xaa, 0x63, 0xa8, 0xa5, 0x0c, 0x38, 0xbd, 0x03, 0x87, 0x72, 0xc4,
+                0x14, 0x3d, 0x8b, 0x7a, 0xcf, 0xd7, 0x4e, 0x72, 0xc0, 0x4d, 0x89, 0x24, 0x8d, 0xff,
+                0x20, 0xfe, 0x8d, 0xc5, 0xec, 0x21, 0x49, 0x05, 0x4e, 0xa2, 0x41, 0x64, 0xe8, 0x5f,
+                0x67, 0x44, 0xad, 0x0c, 0xac, 0xf1, 0xa8, 0xb7, 0x01, 0x26, 0xf4, 0x82, 0xc0, 0x92,
+                0xed, 0x9f, 0x61, 0x27, 0xd2, 0x05, 0x0d, 0x12, 0xe8, 0x78, 0xa7, 0x96, 0x53, 0xa1,
+                0xe8, 0x4d, 0xae, 0xc3, 0xeb, 0xe6, 0x2d, 0x5f, 0x6c, 0x4a, 0xbe, 0x5c, 0xe9, 0x0a,
+                0x7f, 0xe2, 0xe5, 0x2a, 0x8d, 0x78, 0x46, 0xe8, 0xed, 0xf2, 0xf2, 0xbc, 0xe0, 0x5a,
+                0x03, 0x7c, 0x82, 0x6f, 0x22, 0xca, 0xad, 0x12, 0x61, 0x46, 0x7d, 0xcf, 0xb7, 0xd6,
+                0xb6, 0x13, 0x3d, 0xc2, 0x1e, 0x80, 0x96, 0xc7, 0xe9, 0xf8, 0xe9, 0xe1, 0x0c, 0x1e,
+                0x3f, 0xac, 0x40, 0x58, 0xb6, 0x82, 0xc6, 0x8e, 0x54, 0xfa, 0xca, 0xe0, 0xf9, 0xc2,
+                0xdd, 0x4d, 0x64, 0xd9, 0x04, 0x61, 0x52, 0xb4, 0x76, 0x23, 0x32, 0x93, 0x9f, 0x17,
+                0xe6, 0xaa, 0xf7, 0xd8, 0xb9, 0xd3, 0x58, 0xe2, 0x21, 0x8d, 0x4e, 0x0d, 0x69, 0xa4,
+                0xf1, 0x19, 0xe1, 0xc6, 0x4e, 0xec, 0x4c, 0x8b, 0x53, 0x28, 0x09, 0x70, 0x71, 0x31,
+                0xf0, 0x1f, 0x55, 0xc7, 0xad, 0x04, 0xcf, 0xb6, 0x3f, 0x7c, 0x4a, 0x3d, 0x0a, 0x2b,
+                0x0f, 0xfb, 0x0b, 0x05, 0xa6, 0xbe, 0x05, 0x5b, 0x8c, 0x94, 0xca, 0x80, 0xbb, 0x0a,
+                0x1d, 0x13, 0xcd, 0x4c, 0xd6, 0x9a, 0xb9, 0x83, 0x04, 0xae, 0x25, 0x15, 0xd5, 0xf7,
+                0x69, 0x9d, 0x4a, 0xbe, 0xe5, 0xc2, 0x0b, 0xe6, 0x09, 0xd8, 0x73, 0x51, 0x10, 0x12,
+                0xf2, 0x34, 0xbd, 0x85, 0xa7, 0xef, 0xf5, 0xfb, 0x63, 0x4c, 0xff, 0x26, 0x58, 0xba,
+                0x65, 0x16, 0x04, 0x85, 0x63, 0x09, 0x5e, 0xce, 0xfb, 0x30, 0x15, 0xee, 0x3f, 0x03,
+                0xca, 0x52, 0xa1, 0x77, 0xf2, 0x61, 0xec, 0xdc, 0x26, 0xbc, 0x08, 0x9d, 0x34, 0xc6,
+                0x40, 0x48, 0x46, 0xe9, 0xc6, 0x47, 0xfc, 0xfe, 0x98, 0xcc, 0x6a, 0xcd, 0xbb, 0x46,
+                0x4f, 0x64, 0x27, 0x8a, 0xd8, 0xce, 0x9d, 0x1a, 0xe0, 0xd4, 0x15, 0xbc, 0x0c, 0x05,
+                0x24, 0x5f, 0xdd, 0xaf, 0x4e, 0xbc, 0x8d, 0xc7, 0x03, 0xa8, 0x5c, 0xb2, 0x70, 0xf7,
+                0x96, 0xad, 0x2d, 0x93, 0x7e, 0x2a, 0xc0, 0xd5, 0xe0, 0xa3, 0x48, 0x21, 0x75, 0x80,
+                0x00, 0xaa, 0x59, 0xc9, 0xd4, 0x65, 0x24, 0x85, 0x29, 0x4e, 0xe0, 0xab, 0x29, 0x69,
+                0x6b, 0x21, 0x43, 0x0f, 0xa5, 0x4d, 0xcf, 0xbf, 0x2b, 0x9c, 0x49, 0xd1, 0x42, 0x06,
+                0x42, 0x09, 0xee, 0xee, 0xd4, 0xd4, 0x71, 0xff, 0xc0, 0x17, 0xd4, 0xe2, 0x0a, 0x79,
+                0x6b, 0x09, 0x27, 0x80, 0x4c, 0x06, 0x1b, 0x9f,
+            ],
+            cv_net: [
+                0x71, 0x00, 0xa7, 0x52, 0x93, 0xf4, 0xae, 0xfd, 0x89, 0xa1, 0x66, 0xa5, 0xf8, 0x4d,
+                0x34, 0xda, 0xf4, 0xe5, 0x98, 0x34, 0xcd, 0x65, 0xd7, 0x9f, 0xfc, 0x41, 0xdd, 0xf0,
+                0x68, 0x2d, 0xc2, 0xab,
+            ],
+            rho: [
+                0x31, 0x70, 0x5e, 0xfb, 0xf8, 0x0c, 0x7a, 0x7a, 0xb7, 0x81, 0xdf, 0x53, 0x77, 0xf8,
+                0x4d, 0x4b, 0x32, 0x36, 0xdb, 0x1f, 0x32, 0xac, 0xa7, 0x94, 0x5c, 0xf2, 0x6e, 0xc8,
+                0xb9, 0xd0, 0xb7, 0x32,
+            ],
+            cmx: [
+                0xe1, 0xc7, 0x67, 0xf3, 0x30, 0x15, 0xb5, 0xe2, 0x4a, 0x9a, 0xa5, 0x8b, 0x64, 0x7b,
+                0x6b, 0x61, 0x32, 0x3c, 0xd3, 0x47, 0xe7, 0x21, 0x4c, 0x29, 0x1d, 0x09, 0x95, 0xc0,
+                0xf5, 0xa6, 0x93, 0x2f,
+            ],
+            esk: [
+                0xc0, 0xdb, 0x43, 0x69, 0x10, 0x03, 0x45, 0x7d, 0x61, 0xfb, 0x58, 0x93, 0x20, 0x26,
+                0xf9, 0xdd, 0x2c, 0x35, 0xb9, 0x05, 0x7f, 0xad, 0x50, 0xd8, 0x44, 0x72, 0x83, 0xf9,
+                0x4e, 0xd5, 0x95, 0x3d,
+            ],
+            ephemeral_key: [
+                0xce, 0x67, 0x94, 0x31, 0x5f, 0x46, 0x2d, 0xed, 0xf3, 0xc5, 0x77, 0x4a, 0xac, 0x7f,
+                0x3c, 0x7b, 0x70, 0xba, 0x7d, 0x72, 0x43, 0xbb, 0x0c, 0xc3, 0xb0, 0x67, 0xdc, 0x28,
+                0x38, 0xf1, 0x11, 0xa3,
+            ],
+            shared_secret: [
+                0xea, 0x22, 0x6b, 0x69, 0xec, 0x2d, 0x9f, 0xcf, 0x91, 0x9c, 0xe5, 0x70, 0x06, 0x09,
+                0x89, 0x94, 0xf7, 0x14, 0xb3, 0x9c, 0x34, 0x61, 0x52, 0xbc, 0x11, 0x51, 0xa0, 0xc6,
+                0x9e, 0xe0, 0x04, 0x06,
+            ],
+            k_enc: [
+                0xb4, 0x56, 0x1b, 0xdb, 0xe0, 0xea, 0x44, 0x20, 0x75, 0xe7, 0xe6, 0x6f, 0xb3, 0xc0,
+                0xfa, 0xd3, 0xaf, 0xc2, 0x85, 0x6e, 0xf4, 0xf3, 0x61, 0xb4, 0xac, 0x33, 0xaa, 0xe0,
+                0x15, 0x52, 0xfd, 0x49,
+            ],
+            p_enc: [
+                0x03, 0xd2, 0xf7, 0x5f, 0x7c, 0xe7, 0x1b, 0xa4, 0xa7, 0xab, 0x69, 0xb8, 0x4a, 0x70,
+                0x91, 0xfe, 0x01, 0x5a, 0xda, 0x68, 0x13, 0xeb, 0x7c, 0xea, 0xa5, 0xff, 0x12, 0x90,
+                0xb0, 0x3e, 0xc9, 0x1c, 0xe6, 0xdd, 0x28, 0x13, 0x0c, 0x3a, 0xb0, 0xb2, 0x3b, 0x60,
+                0x2b, 0xd5, 0xbe, 0x5d, 0xc2, 0x60, 0x03, 0xaa, 0xe0, 0x4b, 0x29, 0x8a, 0xc0, 0xaf,
+                0xdc, 0x52, 0x87, 0xd7, 0xad, 0x12, 0x4c, 0xd9, 0x40, 0x5a, 0x62, 0xcd, 0x1c, 0xa0,
+                0x8b, 0x28, 0x2e, 0xfe, 0xf7, 0xf9, 0x28, 0xdf, 0x76, 0xe2, 0x82, 0x1a, 0x41, 0x84,
+                0xff, 0x33, 0xd7, 0xbd, 0x25, 0x90, 0xe9, 0x0c, 0x8c, 0x38, 0x8e, 0xa7, 0x95, 0x51,
+                0x22, 0xdb, 0xac, 0xa6, 0x7b, 0x30, 0x39, 0x5a, 0x92, 0x8b, 0x57, 0xb8, 0x57, 0x51,
+                0x23, 0x20, 0x5a, 0xe1, 0x91, 0x52, 0xe4, 0x1e, 0x00, 0x29, 0x31, 0xb4, 0x57, 0x46,
+                0x19, 0x8e, 0x5d, 0xd9, 0x57, 0x1a, 0x56, 0xa7, 0xe0, 0xd4, 0x23, 0xff, 0x27, 0x98,
+                0x9d, 0x3e, 0xb4, 0x17, 0xec, 0xd3, 0xc3, 0x09, 0x3f, 0xb8, 0x2c, 0x56, 0x58, 0xe2,
+                0x96, 0x24, 0xc5, 0x32, 0x19, 0xa6, 0x0c, 0xd0, 0xa8, 0xc4, 0xda, 0x36, 0x7e, 0x29,
+                0xa7, 0x17, 0x79, 0xa7, 0x30, 0x32, 0x98, 0x5a, 0x3d, 0x1f, 0xd0, 0x3d, 0xd4, 0xd0,
+                0x6e, 0x05, 0x56, 0x6f, 0x3b, 0x84, 0x36, 0x7c, 0xf0, 0xfa, 0xee, 0x9b, 0xc3, 0xbd,
+                0x7a, 0x3a, 0x60, 0x6a, 0x9f, 0xdb, 0x84, 0x9c, 0x5d, 0x82, 0xd0, 0xa6, 0x19, 0x23,
+                0xc2, 0xe5, 0xd8, 0xaa, 0x63, 0xa8, 0xa5, 0x0c, 0x38, 0xbd, 0x03, 0x87, 0x72, 0xc4,
+                0x14, 0x3d, 0x8b, 0x7a, 0xcf, 0xd7, 0x4e, 0x72, 0xc0, 0x4d, 0x89, 0x24, 0x8d, 0xff,
+                0x20, 0xfe, 0x8d, 0xc5, 0xec, 0x21, 0x49, 0x05, 0x4e, 0xa2, 0x41, 0x64, 0xe8, 0x5f,
+                0x67, 0x44, 0xad, 0x0c, 0xac, 0xf1, 0xa8, 0xb7, 0x01, 0x26, 0xf4, 0x82, 0xc0, 0x92,
+                0xed, 0x9f, 0x61, 0x27, 0xd2, 0x05, 0x0d, 0x12, 0xe8, 0x78, 0xa7, 0x96, 0x53, 0xa1,
+                0xe8, 0x4d, 0xae, 0xc3, 0xeb, 0xe6, 0x2d, 0x5f, 0x6c, 0x4a, 0xbe, 0x5c, 0xe9, 0x0a,
+                0x7f, 0xe2, 0xe5, 0x2a, 0x8d, 0x78, 0x46, 0xe8, 0xed, 0xf2, 0xf2, 0xbc, 0xe0, 0x5a,
+                0x03, 0x7c, 0x82, 0x6f, 0x22, 0xca, 0xad, 0x12, 0x61, 0x46, 0x7d, 0xcf, 0xb7, 0xd6,
+                0xb6, 0x13, 0x3d, 0xc2, 0x1e, 0x80, 0x96, 0xc7, 0xe9, 0xf8, 0xe9, 0xe1, 0x0c, 0x1e,
+                0x3f, 0xac, 0x40, 0x58, 0xb6, 0x82, 0xc6, 0x8e, 0x54, 0xfa, 0xca, 0xe0, 0xf9, 0xc2,
+                0xdd, 0x4d, 0x64, 0xd9, 0x04, 0x61, 0x52, 0xb4, 0x76, 0x23, 0x32, 0x93, 0x9f, 0x17,
+                0xe6, 0xaa, 0xf7, 0xd8, 0xb9, 0xd3, 0x58, 0xe2, 0x21, 0x8d, 0x4e, 0x0d, 0x69, 0xa4,
+                0xf1, 0x19, 0xe1, 0xc6, 0x4e, 0xec, 0x4c, 0x8b, 0x53, 0x28, 0x09, 0x70, 0x71, 0x31,
+                0xf0, 0x1f, 0x55, 0xc7, 0xad, 0x04, 0xcf, 0xb6, 0x3f, 0x7c, 0x4a, 0x3d, 0x0a, 0x2b,
+                0x0f, 0xfb, 0x0b, 0x05, 0xa6, 0xbe, 0x05, 0x5b, 0x8c, 0x94, 0xca, 0x80, 0xbb, 0x0a,
+                0x1d, 0x13, 0xcd, 0x4c, 0xd6, 0x9a, 0xb9, 0x83, 0x04, 0xae, 0x25, 0x15, 0xd5, 0xf7,
+                0x69, 0x9d, 0x4a, 0xbe, 0xe5, 0xc2, 0x0b, 0xe6, 0x09, 0xd8, 0x73, 0x51, 0x10, 0x12,
+                0xf2, 0x34, 0xbd, 0x85, 0xa7, 0xef, 0xf5, 0xfb, 0x63, 0x4c, 0xff, 0x26, 0x58, 0xba,
+                0x65, 0x16, 0x04, 0x85, 0x63, 0x09, 0x5e, 0xce, 0xfb, 0x30, 0x15, 0xee, 0x3f, 0x03,
+                0xca, 0x52, 0xa1, 0x77, 0xf2, 0x61, 0xec, 0xdc, 0x26, 0xbc, 0x08, 0x9d, 0x34, 0xc6,
+                0x40, 0x48, 0x46, 0xe9, 0xc6, 0x47, 0xfc, 0xfe, 0x98, 0xcc, 0x6a, 0xcd, 0xbb, 0x46,
+                0x4f, 0x64, 0x27, 0x8a, 0xd8, 0xce, 0x9d, 0x1a, 0xe0, 0xd4, 0x15, 0xbc, 0x0c, 0x05,
+                0x24, 0x5f, 0xdd, 0xaf, 0x4e, 0xbc, 0x8d, 0xc7, 0x03, 0xa8, 0x5c, 0xb2, 0x70, 0xf7,
+                0x96, 0xad, 0x2d, 0x93, 0x7e, 0x2a, 0xc0, 0xd5, 0xe0, 0xa3, 0x48, 0x21, 0x75, 0x80,
+                0x00, 0xaa, 0x59, 0xc9, 0xd4, 0x65, 0x24, 0x85, 0x29, 0x4e, 0xe0, 0xab, 0x29, 0x69,
+                0x6b, 0x21, 0x43, 0x0f, 0xa5, 0x4d, 0xcf, 0xbf, 0x2b, 0x9c, 0x49, 0xd1, 0x42, 0x06,
+                0x42, 0x09, 0xee, 0xee, 0xd4, 0xd4, 0x71, 0xff, 0xc0, 0x17, 0xd4, 0xe2, 0x0a, 0x79,
+                0x6b, 0x09, 0x27, 0x80, 0x4c, 0x06, 0x1b, 0x9f,
+            ],
+            c_enc: [
+                0x59, 0x9a, 0x4d, 0x9f, 0x53, 0x3c, 0x46, 0xa9, 0x6f, 0x92, 0xaf, 0x8c, 0x08, 0xae,
+                0x59, 0x71, 0x10, 0x23, 0x0e, 0xb8, 0x41, 0xc2, 0xf7, 0xc9, 0xd4, 0xf1, 0x45, 0x87,
+                0x76, 0x36, 0xc8, 0x9d, 0xd8, 0xf3, 0x84, 0xa9, 0x40, 0xdc, 0x89, 0x72, 0x55, 0x53,
+                0x57, 0xbc, 0x07, 0x48, 0x2a, 0x0a, 0x32, 0x3d, 0x87, 0xae, 0x10, 0xeb, 0x99, 0x82,
+                0x5a, 0xe4, 0xe0, 0x06, 0x0e, 0x25, 0x6c, 0x3c, 0x3b, 0xeb, 0xa3, 0x2f, 0xa2, 0xb2,
+                0xd2, 0x7f, 0x04, 0x6f, 0x7a, 0x93, 0x6d, 0xf8, 0xa9, 0x61, 0xc8, 0x18, 0x4e, 0xe3,
+                0xc6, 0x8e, 0xbc, 0xe9, 0x80, 0x64, 0x45, 0xb4, 0x3e, 0x66, 0x67, 0x19, 0x95, 0xa2,
+                0x43, 0x7a, 0x7f, 0x70, 0x91, 0x47, 0x14, 0x8a, 0x76, 0x03, 0x6d, 0x25, 0x5e, 0xba,
+                0xc4, 0xd0, 0xd8, 0x34, 0x82, 0x93, 0x23, 0x9a, 0x78, 0x64, 0xe7, 0x9b, 0xef, 0xf7,
+                0x6f, 0x61, 0x50, 0xe0, 0xc4, 0xf4, 0x7a, 0x85, 0x26, 0xe3, 0xed, 0x06, 0x75, 0xfa,
+                0xc6, 0xac, 0xcc, 0x30, 0xa4, 0xd6, 0x73, 0xca, 0x80, 0x85, 0x95, 0x96, 0xfe, 0xc9,
+                0xcd, 0x6a, 0x93, 0xfb, 0xa0, 0xe8, 0x9e, 0xf5, 0x3f, 0x3e, 0x26, 0x74, 0xd3, 0x2a,
+                0x4b, 0x43, 0xf9, 0xa4, 0x38, 0x7d, 0xce, 0x33, 0xac, 0xa1, 0xe4, 0xff, 0xdc, 0x6d,
+                0x2d, 0x31, 0x89, 0xc6, 0x23, 0xca, 0x56, 0x4d, 0x03, 0xac, 0x5b, 0x35, 0xb1, 0xa7,
+                0x47, 0xff, 0x44, 0x6b, 0xc2, 0x5e, 0xd2, 0x2d, 0x09, 0x68, 0x2c, 0xef, 0x3a, 0x30,
+                0xff, 0xa5, 0xc4, 0x0e, 0x27, 0x70, 0xf1, 0x84, 0x98, 0xb1, 0x2f, 0x86, 0x8b, 0xa9,
+                0x2a, 0x13, 0xaa, 0x4f, 0xa2, 0x14, 0xb0, 0x62, 0xe3, 0x64, 0x9c, 0xf9, 0xc8, 0x5e,
+                0x7a, 0x8a, 0x55, 0xf5, 0xf3, 0xdd, 0x68, 0x84, 0x2a, 0xea, 0x7c, 0x92, 0x79, 0x2a,
+                0x52, 0x60, 0x0f, 0x86, 0x6c, 0x34, 0xa1, 0x0c, 0x51, 0x14, 0x13, 0x62, 0x02, 0x24,
+                0xfb, 0x85, 0xaf, 0xc6, 0x06, 0xdd, 0x4f, 0x7b, 0x2f, 0x76, 0xbe, 0x76, 0x0c, 0xa1,
+                0x94, 0xb6, 0xd4, 0x88, 0x2e, 0x5a, 0x4a, 0x76, 0x3d, 0x75, 0x0d, 0xb7, 0xe1, 0x68,
+                0xa4, 0x18, 0x11, 0x92, 0x35, 0xda, 0xf9, 0xcb, 0x1b, 0xdb, 0x07, 0xff, 0x46, 0x83,
+                0x3a, 0x87, 0xa3, 0x92, 0x6b, 0x14, 0xa5, 0x26, 0x4f, 0x10, 0x4f, 0x7f, 0x89, 0xf7,
+                0x6f, 0x10, 0x10, 0x8f, 0x2b, 0x6e, 0xa5, 0x05, 0xd4, 0xf0, 0xd2, 0x6d, 0x58, 0x31,
+                0x1c, 0xc7, 0x21, 0x9c, 0x6b, 0xc4, 0x38, 0xd0, 0xe1, 0xb3, 0x17, 0x60, 0x18, 0x73,
+                0x9e, 0x6f, 0x75, 0xd0, 0x73, 0x59, 0xf5, 0xe8, 0x95, 0x7e, 0x12, 0xc3, 0x03, 0xaa,
+                0x52, 0x9b, 0x11, 0xa1, 0x81, 0x66, 0x25, 0xa1, 0x20, 0xf3, 0x6d, 0xcd, 0xdd, 0xff,
+                0x9c, 0x65, 0xbc, 0xac, 0x8f, 0x10, 0x67, 0xc7, 0xfe, 0x88, 0xf6, 0x44, 0x85, 0x94,
+                0xcf, 0x1d, 0xff, 0x8e, 0x29, 0x00, 0xae, 0x84, 0xd2, 0xa7, 0xc8, 0x1b, 0x90, 0x6d,
+                0xd0, 0xbc, 0x86, 0x96, 0xe3, 0x70, 0x98, 0x07, 0x4b, 0x75, 0xd8, 0x38, 0xd8, 0xab,
+                0xdc, 0x90, 0x46, 0x08, 0x2b, 0xe4, 0xa6, 0x09, 0x95, 0xc4, 0xf4, 0xed, 0x80, 0xe2,
+                0xd7, 0x87, 0x38, 0x25, 0x77, 0x3b, 0xa6, 0x3e, 0xe4, 0xcb, 0x97, 0x36, 0x9a, 0x50,
+                0x70, 0xb5, 0x72, 0x5c, 0x5f, 0xeb, 0x32, 0x62, 0x45, 0x87, 0x80, 0x1e, 0x5a, 0xc0,
+                0x30, 0xe6, 0x45, 0xbd, 0xf2, 0xe5, 0x86, 0xcf, 0x98, 0x66, 0xea, 0xfb, 0x76, 0xf5,
+                0x59, 0x76, 0xa3, 0x3d, 0x62, 0xae, 0xdc, 0x76, 0x27, 0x78, 0x3b, 0x48, 0x48, 0x93,
+                0x61, 0xf9, 0x9c, 0xae, 0xb1, 0xb1, 0x9c, 0x55, 0x22, 0x58, 0x9f, 0xd2, 0x1d, 0x51,
+                0x45, 0x49, 0xd7, 0x4a, 0xb1, 0x92, 0x25, 0xed, 0x6e, 0x4c, 0x20, 0x3a, 0xdd, 0xfa,
+                0x55, 0xfc, 0x9e, 0xc9, 0x89, 0xb6, 0x69, 0x02, 0x3c, 0xf3, 0x05, 0xb4, 0x2b, 0x33,
+                0x0f, 0xc2, 0x30, 0x80, 0xab, 0xe4, 0x25, 0x01, 0xe5, 0x9c, 0x85, 0x1c, 0x54, 0xc7,
+                0x49, 0x66, 0xf6, 0x0b, 0xe9, 0xdc, 0x56, 0x1a, 0x2d, 0x91, 0xf5, 0xd3, 0x2a, 0xdd,
+                0x19, 0xb8, 0x9a, 0xca, 0xbe, 0x92, 0x1b, 0x99, 0x25, 0x3a, 0xfe, 0xfb, 0x2f, 0xf6,
+                0x42, 0xd8, 0x6e, 0x65, 0x59, 0x51, 0x95, 0x8e, 0xfb, 0x82, 0xab, 0xe5, 0x84, 0x5d,
+                0xad, 0xf0, 0x13, 0x27, 0x03, 0x7e, 0xda, 0x01, 0xf9, 0x97, 0xd4, 0x19, 0x4f, 0x97,
+                0xb7, 0xd7, 0xef, 0xa4, 0xf4, 0xd0, 0x18, 0x2d, 0xa4, 0xc4,
+            ],
+            ock: [
+                0x55, 0x0e, 0xbf, 0x98, 0x83, 0x6c, 0xce, 0x43, 0x52, 0x25, 0xa1, 0x4b, 0xa6, 0x52,
+                0xa7, 0xd5, 0x58, 0xcf, 0x5f, 0x3f, 0x7a, 0xfb, 0x00, 0xb0, 0x24, 0x70, 0xe8, 0xe4,
+                0xd2, 0x6d, 0xb7, 0x9c,
+            ],
+            op: [
+                0x49, 0x19, 0x01, 0x2e, 0x40, 0x43, 0x82, 0xeb, 0xee, 0x8e, 0x60, 0xe9, 0xd4, 0xf1,
+                0x30, 0x79, 0xc0, 0x8d, 0x9c, 0x6d, 0x50, 0xf9, 0x35, 0x86, 0x7d, 0x33, 0x01, 0xf6,
+                0x89, 0xcf, 0xf9, 0x1e, 0xc0, 0xdb, 0x43, 0x69, 0x10, 0x03, 0x45, 0x7d, 0x61, 0xfb,
+                0x58, 0x93, 0x20, 0x26, 0xf9, 0xdd, 0x2c, 0x35, 0xb9, 0x05, 0x7f, 0xad, 0x50, 0xd8,
+                0x44, 0x72, 0x83, 0xf9, 0x4e, 0xd5, 0x95, 0x3d,
+            ],
+            c_out: [
+                0x9a, 0x01, 0xb7, 0x5e, 0x27, 0xea, 0x97, 0x51, 0x45, 0x5d, 0x54, 0xf2, 0xa5, 0x2b,
+                0x88, 0x4b, 0x45, 0x6a, 0x6f, 0xc3, 0xda, 0xdb, 0xec, 0x79, 0xbf, 0x4d, 0x10, 0xbe,
+                0x06, 0x7b, 0xef, 0x3e, 0xa2, 0xa5, 0xc0, 0x59, 0x81, 0xd4, 0x06, 0x05, 0x6a, 0x2f,
+                0xf6, 0x4c, 0xb4, 0xc6, 0xfd, 0x46, 0x7d, 0xa8, 0x0b, 0xa1, 0x17, 0x48, 0xe9, 0xe2,
+                0xae, 0x07, 0xb7, 0x62, 0xdf, 0x9d, 0x4a, 0x23, 0x58, 0x77, 0xf5, 0x8f, 0x43, 0x24,
+                0xd8, 0x00, 0x3c, 0x32, 0x4f, 0xd9, 0xc6, 0x39, 0xbc, 0xa6,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x53, 0x3d, 0xc3, 0xd4, 0x93, 0xf2, 0xb8, 0x7a, 0x03, 0x3d, 0xf5, 0x07, 0x05, 0xf2,
+                0x90, 0x54, 0x16, 0x38, 0xe9, 0x08, 0x7d, 0xcd, 0xbc, 0xfe, 0x52, 0x7e, 0x77, 0x5a,
+                0xaf, 0x09, 0x30, 0x29, 0xac, 0xec, 0x74, 0xdd, 0xe6, 0x02, 0xfc, 0x7c, 0x73, 0xcb,
+                0x38, 0x50, 0xbd, 0xfb, 0xf2, 0x61, 0x79, 0x4c, 0x9c, 0x29, 0x9d, 0x0b, 0x98, 0xee,
+                0x0f, 0x20, 0x71, 0xd6, 0xd4, 0xe3, 0x7b, 0x05,
+            ],
+            ovk: [
+                0x32, 0x4d, 0xce, 0x2a, 0x1e, 0xa1, 0xe4, 0x30, 0x4f, 0x49, 0xe4, 0x3a, 0xe0, 0x65,
+                0xe3, 0xfb, 0x19, 0x6f, 0x76, 0xd9, 0xb8, 0x79, 0xc7, 0x20, 0x08, 0x62, 0xea, 0xd1,
+                0x8d, 0xea, 0x5f, 0xb6,
+            ],
+            default_d: [
+                0x20, 0x8c, 0x6d, 0x90, 0x6c, 0xfa, 0x93, 0xf1, 0x2d, 0x6a, 0x7e,
+            ],
+            default_pk_d: [
+                0x64, 0xce, 0xac, 0xec, 0x3c, 0x2e, 0xa7, 0x9c, 0x4c, 0xd3, 0xe2, 0xf0, 0xfb, 0xb9,
+                0xe1, 0xd4, 0x39, 0x55, 0xae, 0x66, 0xd8, 0x93, 0x92, 0xbf, 0x48, 0xaf, 0xb6, 0xc4,
+                0xab, 0x00, 0xa0, 0x28,
+            ],
+            v: 12711846894898776584,
+            rseed: [
+                0x7b, 0xdc, 0x8b, 0xa3, 0xe4, 0xe3, 0xd1, 0xd9, 0x33, 0xbf, 0xb5, 0x80, 0xf5, 0xb3,
+                0xe8, 0x7a, 0x2a, 0x06, 0x51, 0x70, 0x51, 0x41, 0x0f, 0xe1, 0xb4, 0xff, 0x1e, 0xa0,
+                0xad, 0xe8, 0x24, 0xf3,
+            ],
+            asset: [
+                0xf9, 0x78, 0x1e, 0xbe, 0x31, 0x7a, 0x07, 0x10, 0xae, 0x54, 0x61, 0xe3, 0x4f, 0xe6,
+                0xf1, 0xb1, 0xaa, 0x9b, 0x4e, 0x67, 0xb1, 0x49, 0x10, 0x98, 0x48, 0x02, 0xc2, 0xa7,
+                0xe3, 0x81, 0x93, 0xbc,
+            ],
+            memo: [
+                0xff, 0x38, 0x51, 0x54, 0x56, 0xa5, 0x7c, 0x7a, 0x91, 0x6a, 0x74, 0x38, 0x8e, 0xe8,
+                0xf1, 0x28, 0x1f, 0x9a, 0xde, 0x0a, 0xe2, 0xa2, 0x61, 0x3a, 0x06, 0x12, 0xc4, 0x69,
+                0xdf, 0x79, 0x2b, 0x8d, 0xf4, 0xca, 0xe4, 0xfc, 0x25, 0xc1, 0xca, 0xdb, 0xa9, 0x5a,
+                0x80, 0x7c, 0xe6, 0x1e, 0x5a, 0x53, 0x03, 0xfa, 0xaf, 0x9e, 0x14, 0x65, 0x39, 0x96,
+                0xb5, 0xa8, 0xad, 0xc3, 0x4f, 0xd4, 0x75, 0xef, 0x14, 0x99, 0x09, 0x4b, 0xab, 0xaf,
+                0x1f, 0x3f, 0x07, 0xda, 0x9a, 0x39, 0x0b, 0x1d, 0x9f, 0xc9, 0xa0, 0x83, 0x27, 0x98,
+                0x7a, 0xdf, 0xe9, 0x56, 0x48, 0x63, 0xfb, 0xdf, 0xa8, 0xf6, 0xb4, 0x6a, 0x88, 0x41,
+                0x58, 0x30, 0x99, 0xaf, 0xb7, 0x87, 0x01, 0x18, 0xfa, 0xce, 0x76, 0x34, 0x7e, 0x40,
+                0xb6, 0xfd, 0x8c, 0xd1, 0x55, 0x82, 0xae, 0x8e, 0x23, 0xbe, 0x9a, 0x02, 0x19, 0xbc,
+                0x3e, 0x4e, 0x45, 0x46, 0xa3, 0x0d, 0x3b, 0xbb, 0xbd, 0x16, 0x86, 0x08, 0x68, 0x76,
+                0xbe, 0x0e, 0x4c, 0x85, 0x9b, 0xe7, 0x1f, 0xb5, 0x8f, 0x4f, 0xab, 0x3d, 0x28, 0xc0,
+                0xb4, 0xf7, 0xe7, 0x5a, 0xd1, 0xed, 0xb7, 0xf8, 0x89, 0x46, 0xfb, 0x40, 0xcf, 0xa5,
+                0x78, 0x6a, 0x0f, 0xcb, 0xa1, 0x30, 0x3c, 0x83, 0x47, 0xec, 0xee, 0x93, 0xd4, 0x6d,
+                0x14, 0x0b, 0xb5, 0xf6, 0x95, 0x31, 0xd6, 0x66, 0x54, 0x8b, 0x10, 0x9c, 0xe7, 0x64,
+                0xbe, 0xad, 0x7c, 0x87, 0xbd, 0x4c, 0x87, 0x64, 0x94, 0xde, 0x82, 0xdb, 0x6e, 0x50,
+                0x73, 0xa6, 0xc9, 0x4f, 0x7c, 0x09, 0x9a, 0x40, 0xd7, 0xa3, 0x1c, 0x4a, 0x04, 0xb6,
+                0x9c, 0x9f, 0xcc, 0xf3, 0xc7, 0xdd, 0x56, 0xf5, 0x54, 0x47, 0x76, 0xc5, 0x3b, 0x4d,
+                0xf7, 0x95, 0x39, 0x81, 0xd5, 0x5a, 0x96, 0xa6, 0xdc, 0xff, 0x99, 0x04, 0xa9, 0x08,
+                0x42, 0xe5, 0xba, 0xfe, 0xc8, 0x84, 0x0c, 0x2d, 0x25, 0x5b, 0xf5, 0xad, 0x61, 0xc4,
+                0x60, 0xf9, 0x8f, 0xeb, 0x82, 0xa1, 0x0f, 0xa1, 0xc0, 0x99, 0xf6, 0x27, 0x76, 0x79,
+                0x82, 0x36, 0xc5, 0xca, 0x7f, 0x1e, 0x46, 0xeb, 0xdb, 0x2b, 0x14, 0x4d, 0x87, 0x13,
+                0xe5, 0x6c, 0x77, 0x2f, 0x2c, 0x3b, 0x86, 0x0e, 0xa5, 0xb0, 0x3a, 0x88, 0x54, 0xbc,
+                0x6e, 0x65, 0x90, 0xd6, 0x3c, 0xc0, 0xea, 0x54, 0xf1, 0x0b, 0x73, 0xba, 0x24, 0x1b,
+                0xf7, 0x4b, 0x63, 0x55, 0x51, 0xa2, 0xaa, 0xca, 0x96, 0x87, 0xac, 0x52, 0x69, 0xfd,
+                0x36, 0x8b, 0x26, 0xd7, 0x0a, 0x73, 0x7f, 0x26, 0x76, 0x85, 0x99, 0x8a, 0x3f, 0x7d,
+                0x26, 0x37, 0x91, 0x49, 0x09, 0xc7, 0x46, 0x49, 0x5d, 0x24, 0xc4, 0x98, 0x63, 0x5e,
+                0xf9, 0x7a, 0xc6, 0x6a, 0x40, 0x08, 0x94, 0xc0, 0x9f, 0x73, 0x48, 0x8e, 0xb7, 0xcf,
+                0x33, 0xf6, 0xda, 0xd1, 0x66, 0x6a, 0x05, 0xf9, 0x1a, 0xd7, 0x75, 0x79, 0x65, 0xc2,
+                0x99, 0x36, 0xe7, 0xfa, 0x48, 0xd7, 0x7e, 0x89, 0xee, 0x09, 0x62, 0xf5, 0x8c, 0x05,
+                0x1d, 0x11, 0xd0, 0x55, 0xfc, 0xe2, 0x04, 0xa5, 0x62, 0xde, 0x68, 0x08, 0x8a, 0x1b,
+                0x26, 0x48, 0xb8, 0x17, 0x4c, 0xbc, 0xfc, 0x8b, 0x5b, 0x5c, 0xd0, 0x77, 0x11, 0x5a,
+                0xfd, 0xe1, 0x84, 0x05, 0x05, 0x4e, 0x5d, 0xa9, 0xa0, 0x43, 0x10, 0x34, 0x2c, 0x5d,
+                0x3b, 0x52, 0x6e, 0x0b, 0x02, 0xc5, 0xca, 0x17, 0x22, 0xba, 0xde, 0xee, 0x23, 0xd1,
+                0x45, 0xe8, 0xeb, 0x22, 0x13, 0xfc, 0x4a, 0xf1, 0xe4, 0x50, 0xe4, 0xd5, 0x21, 0x7c,
+                0x66, 0x17, 0x00, 0x8c, 0x78, 0xf4, 0xfb, 0x11, 0x12, 0xf4, 0x02, 0x8a, 0x70, 0x4f,
+                0xc5, 0xa9, 0x38, 0x2c, 0x6b, 0x03, 0xe7, 0xd8, 0x08, 0x5e, 0x90, 0x6c, 0xf8, 0x4c,
+                0xa2, 0xc1, 0x20, 0x7c, 0x87, 0xa2, 0xbc, 0xe2,
+            ],
+            cv_net: [
+                0x5d, 0xd1, 0x3d, 0xcf, 0x9a, 0xf3, 0x52, 0xf5, 0xfe, 0x0b, 0x2b, 0xcb, 0xd0, 0xdb,
+                0xd7, 0xda, 0xfb, 0xbe, 0x53, 0xb0, 0xa9, 0x6b, 0x08, 0x1c, 0x90, 0xba, 0xde, 0xd9,
+                0xbe, 0x4b, 0x4f, 0x87,
+            ],
+            rho: [
+                0x56, 0xbc, 0x48, 0x21, 0xa5, 0x3d, 0x5e, 0x9e, 0x6d, 0x7a, 0x04, 0x44, 0x44, 0x45,
+                0x4f, 0xfb, 0xc2, 0x36, 0x9c, 0xb1, 0x48, 0xeb, 0x76, 0xf1, 0xed, 0xf1, 0xb5, 0xc7,
+                0x41, 0x84, 0x28, 0x2a,
+            ],
+            cmx: [
+                0xd7, 0x60, 0xac, 0xdb, 0xca, 0xda, 0xd1, 0x88, 0x08, 0x4f, 0xe4, 0x1a, 0x5c, 0x03,
+                0xc2, 0xc8, 0xce, 0x34, 0xe1, 0x5f, 0x9d, 0xf4, 0x7b, 0x86, 0x9c, 0x44, 0xc7, 0x21,
+                0x13, 0xa4, 0x0c, 0x3d,
+            ],
+            esk: [
+                0x9b, 0x32, 0x77, 0x19, 0x3b, 0x63, 0x60, 0x8e, 0x6a, 0x3d, 0xdf, 0x7c, 0xe2, 0xd2,
+                0x33, 0x58, 0x4e, 0x66, 0x17, 0xd6, 0xf6, 0xa2, 0x1c, 0xdc, 0x86, 0x48, 0x56, 0x2c,
+                0xbd, 0x86, 0x3f, 0x09,
+            ],
+            ephemeral_key: [
+                0x5a, 0x48, 0x58, 0x15, 0xc4, 0xa7, 0x47, 0x06, 0xe9, 0xde, 0x87, 0xfa, 0x60, 0xa2,
+                0x81, 0x6f, 0x89, 0x0b, 0xe3, 0xdb, 0x54, 0xeb, 0x3f, 0x4b, 0xaf, 0x37, 0xdb, 0xc9,
+                0xbd, 0xe5, 0xfe, 0x9d,
+            ],
+            shared_secret: [
+                0x96, 0x8d, 0xf2, 0xe8, 0x5d, 0x7b, 0xd1, 0x08, 0xf5, 0x72, 0x12, 0x53, 0x93, 0x76,
+                0xaf, 0x25, 0x83, 0x2e, 0xf4, 0xdb, 0xd6, 0x40, 0x2a, 0x41, 0x4d, 0x73, 0xc5, 0x6b,
+                0xee, 0xe4, 0xf2, 0xa8,
+            ],
+            k_enc: [
+                0xf7, 0x73, 0x91, 0x24, 0x3f, 0xdb, 0x35, 0xb2, 0x26, 0x94, 0xdb, 0x91, 0xde, 0xbd,
+                0x78, 0x55, 0x79, 0x3c, 0xa7, 0x1e, 0x82, 0xbd, 0xc2, 0xee, 0x74, 0xc9, 0xb7, 0xb6,
+                0x97, 0xc0, 0x24, 0x71,
+            ],
+            p_enc: [
+                0x03, 0x20, 0x8c, 0x6d, 0x90, 0x6c, 0xfa, 0x93, 0xf1, 0x2d, 0x6a, 0x7e, 0x08, 0x0a,
+                0x98, 0x91, 0x66, 0x8d, 0x69, 0xb0, 0x7b, 0xdc, 0x8b, 0xa3, 0xe4, 0xe3, 0xd1, 0xd9,
+                0x33, 0xbf, 0xb5, 0x80, 0xf5, 0xb3, 0xe8, 0x7a, 0x2a, 0x06, 0x51, 0x70, 0x51, 0x41,
+                0x0f, 0xe1, 0xb4, 0xff, 0x1e, 0xa0, 0xad, 0xe8, 0x24, 0xf3, 0xf9, 0x78, 0x1e, 0xbe,
+                0x31, 0x7a, 0x07, 0x10, 0xae, 0x54, 0x61, 0xe3, 0x4f, 0xe6, 0xf1, 0xb1, 0xaa, 0x9b,
+                0x4e, 0x67, 0xb1, 0x49, 0x10, 0x98, 0x48, 0x02, 0xc2, 0xa7, 0xe3, 0x81, 0x93, 0xbc,
+                0xff, 0x38, 0x51, 0x54, 0x56, 0xa5, 0x7c, 0x7a, 0x91, 0x6a, 0x74, 0x38, 0x8e, 0xe8,
+                0xf1, 0x28, 0x1f, 0x9a, 0xde, 0x0a, 0xe2, 0xa2, 0x61, 0x3a, 0x06, 0x12, 0xc4, 0x69,
+                0xdf, 0x79, 0x2b, 0x8d, 0xf4, 0xca, 0xe4, 0xfc, 0x25, 0xc1, 0xca, 0xdb, 0xa9, 0x5a,
+                0x80, 0x7c, 0xe6, 0x1e, 0x5a, 0x53, 0x03, 0xfa, 0xaf, 0x9e, 0x14, 0x65, 0x39, 0x96,
+                0xb5, 0xa8, 0xad, 0xc3, 0x4f, 0xd4, 0x75, 0xef, 0x14, 0x99, 0x09, 0x4b, 0xab, 0xaf,
+                0x1f, 0x3f, 0x07, 0xda, 0x9a, 0x39, 0x0b, 0x1d, 0x9f, 0xc9, 0xa0, 0x83, 0x27, 0x98,
+                0x7a, 0xdf, 0xe9, 0x56, 0x48, 0x63, 0xfb, 0xdf, 0xa8, 0xf6, 0xb4, 0x6a, 0x88, 0x41,
+                0x58, 0x30, 0x99, 0xaf, 0xb7, 0x87, 0x01, 0x18, 0xfa, 0xce, 0x76, 0x34, 0x7e, 0x40,
+                0xb6, 0xfd, 0x8c, 0xd1, 0x55, 0x82, 0xae, 0x8e, 0x23, 0xbe, 0x9a, 0x02, 0x19, 0xbc,
+                0x3e, 0x4e, 0x45, 0x46, 0xa3, 0x0d, 0x3b, 0xbb, 0xbd, 0x16, 0x86, 0x08, 0x68, 0x76,
+                0xbe, 0x0e, 0x4c, 0x85, 0x9b, 0xe7, 0x1f, 0xb5, 0x8f, 0x4f, 0xab, 0x3d, 0x28, 0xc0,
+                0xb4, 0xf7, 0xe7, 0x5a, 0xd1, 0xed, 0xb7, 0xf8, 0x89, 0x46, 0xfb, 0x40, 0xcf, 0xa5,
+                0x78, 0x6a, 0x0f, 0xcb, 0xa1, 0x30, 0x3c, 0x83, 0x47, 0xec, 0xee, 0x93, 0xd4, 0x6d,
+                0x14, 0x0b, 0xb5, 0xf6, 0x95, 0x31, 0xd6, 0x66, 0x54, 0x8b, 0x10, 0x9c, 0xe7, 0x64,
+                0xbe, 0xad, 0x7c, 0x87, 0xbd, 0x4c, 0x87, 0x64, 0x94, 0xde, 0x82, 0xdb, 0x6e, 0x50,
+                0x73, 0xa6, 0xc9, 0x4f, 0x7c, 0x09, 0x9a, 0x40, 0xd7, 0xa3, 0x1c, 0x4a, 0x04, 0xb6,
+                0x9c, 0x9f, 0xcc, 0xf3, 0xc7, 0xdd, 0x56, 0xf5, 0x54, 0x47, 0x76, 0xc5, 0x3b, 0x4d,
+                0xf7, 0x95, 0x39, 0x81, 0xd5, 0x5a, 0x96, 0xa6, 0xdc, 0xff, 0x99, 0x04, 0xa9, 0x08,
+                0x42, 0xe5, 0xba, 0xfe, 0xc8, 0x84, 0x0c, 0x2d, 0x25, 0x5b, 0xf5, 0xad, 0x61, 0xc4,
+                0x60, 0xf9, 0x8f, 0xeb, 0x82, 0xa1, 0x0f, 0xa1, 0xc0, 0x99, 0xf6, 0x27, 0x76, 0x79,
+                0x82, 0x36, 0xc5, 0xca, 0x7f, 0x1e, 0x46, 0xeb, 0xdb, 0x2b, 0x14, 0x4d, 0x87, 0x13,
+                0xe5, 0x6c, 0x77, 0x2f, 0x2c, 0x3b, 0x86, 0x0e, 0xa5, 0xb0, 0x3a, 0x88, 0x54, 0xbc,
+                0x6e, 0x65, 0x90, 0xd6, 0x3c, 0xc0, 0xea, 0x54, 0xf1, 0x0b, 0x73, 0xba, 0x24, 0x1b,
+                0xf7, 0x4b, 0x63, 0x55, 0x51, 0xa2, 0xaa, 0xca, 0x96, 0x87, 0xac, 0x52, 0x69, 0xfd,
+                0x36, 0x8b, 0x26, 0xd7, 0x0a, 0x73, 0x7f, 0x26, 0x76, 0x85, 0x99, 0x8a, 0x3f, 0x7d,
+                0x26, 0x37, 0x91, 0x49, 0x09, 0xc7, 0x46, 0x49, 0x5d, 0x24, 0xc4, 0x98, 0x63, 0x5e,
+                0xf9, 0x7a, 0xc6, 0x6a, 0x40, 0x08, 0x94, 0xc0, 0x9f, 0x73, 0x48, 0x8e, 0xb7, 0xcf,
+                0x33, 0xf6, 0xda, 0xd1, 0x66, 0x6a, 0x05, 0xf9, 0x1a, 0xd7, 0x75, 0x79, 0x65, 0xc2,
+                0x99, 0x36, 0xe7, 0xfa, 0x48, 0xd7, 0x7e, 0x89, 0xee, 0x09, 0x62, 0xf5, 0x8c, 0x05,
+                0x1d, 0x11, 0xd0, 0x55, 0xfc, 0xe2, 0x04, 0xa5, 0x62, 0xde, 0x68, 0x08, 0x8a, 0x1b,
+                0x26, 0x48, 0xb8, 0x17, 0x4c, 0xbc, 0xfc, 0x8b, 0x5b, 0x5c, 0xd0, 0x77, 0x11, 0x5a,
+                0xfd, 0xe1, 0x84, 0x05, 0x05, 0x4e, 0x5d, 0xa9, 0xa0, 0x43, 0x10, 0x34, 0x2c, 0x5d,
+                0x3b, 0x52, 0x6e, 0x0b, 0x02, 0xc5, 0xca, 0x17, 0x22, 0xba, 0xde, 0xee, 0x23, 0xd1,
+                0x45, 0xe8, 0xeb, 0x22, 0x13, 0xfc, 0x4a, 0xf1, 0xe4, 0x50, 0xe4, 0xd5, 0x21, 0x7c,
+                0x66, 0x17, 0x00, 0x8c, 0x78, 0xf4, 0xfb, 0x11, 0x12, 0xf4, 0x02, 0x8a, 0x70, 0x4f,
+                0xc5, 0xa9, 0x38, 0x2c, 0x6b, 0x03, 0xe7, 0xd8, 0x08, 0x5e, 0x90, 0x6c, 0xf8, 0x4c,
+                0xa2, 0xc1, 0x20, 0x7c, 0x87, 0xa2, 0xbc, 0xe2,
+            ],
+            c_enc: [
+                0xf9, 0x09, 0x97, 0x73, 0x8b, 0x14, 0xd8, 0xa8, 0x4e, 0x32, 0x74, 0xbb, 0x70, 0x76,
+                0x31, 0x15, 0xb7, 0x2e, 0x0a, 0x3d, 0xde, 0x8e, 0xa4, 0x70, 0x91, 0x1f, 0xb4, 0x58,
+                0x70, 0xb0, 0x14, 0x8e, 0x7d, 0x37, 0x2b, 0xf2, 0x26, 0x8b, 0x3e, 0xe8, 0xda, 0xe5,
+                0xfd, 0xe5, 0xea, 0x9b, 0x61, 0x59, 0x8e, 0xf1, 0x1b, 0x73, 0x14, 0x4f, 0x75, 0x53,
+                0xb2, 0x13, 0xa0, 0x4c, 0x85, 0xf2, 0x5c, 0x54, 0x6c, 0x8a, 0x38, 0xa6, 0x0e, 0x50,
+                0x86, 0x08, 0xb9, 0xca, 0x59, 0x3b, 0x94, 0xd8, 0x68, 0x8d, 0x6e, 0xff, 0xa5, 0x36,
+                0x04, 0xd4, 0xdb, 0xc0, 0xf3, 0x45, 0x03, 0xaa, 0xe4, 0x6f, 0x3c, 0x8a, 0x8d, 0x2e,
+                0x46, 0xa8, 0x1f, 0x09, 0x12, 0x6c, 0x45, 0x36, 0xfd, 0x02, 0x58, 0xf5, 0x97, 0x40,
+                0xad, 0x0d, 0xb8, 0x02, 0xcc, 0x02, 0x42, 0x53, 0x4d, 0xdf, 0x52, 0xa6, 0xbf, 0x6a,
+                0x03, 0x4d, 0xe6, 0x26, 0xf0, 0x18, 0x84, 0x4a, 0xdc, 0xb2, 0x6d, 0xcd, 0xc2, 0x85,
+                0x16, 0x37, 0x16, 0xdd, 0x54, 0x65, 0x1c, 0x88, 0x73, 0x53, 0xf1, 0xff, 0xef, 0xa0,
+                0x37, 0x71, 0x2a, 0xc0, 0xdf, 0x3a, 0x92, 0x98, 0x19, 0x06, 0x87, 0x54, 0x9d, 0x79,
+                0xc6, 0xa3, 0x60, 0x0c, 0xc1, 0xc7, 0x29, 0xa3, 0x93, 0xd4, 0x4f, 0xec, 0xe5, 0x7f,
+                0xd4, 0xcb, 0x0c, 0x0f, 0xb0, 0xc7, 0x86, 0x1b, 0x92, 0x5b, 0x94, 0xcd, 0x6a, 0x26,
+                0x90, 0xf0, 0x02, 0xc4, 0x3a, 0x16, 0x6e, 0x56, 0x77, 0x72, 0x9f, 0x35, 0x52, 0xae,
+                0xe0, 0xf2, 0xc1, 0x95, 0xaa, 0x91, 0xb2, 0xdd, 0xe3, 0x65, 0xdd, 0x14, 0xf2, 0xf0,
+                0x7b, 0x3c, 0x38, 0x34, 0x7f, 0x6c, 0x0d, 0xab, 0x82, 0x84, 0x1e, 0xba, 0xde, 0x1e,
+                0xf8, 0x13, 0xf2, 0xcd, 0x88, 0x5b, 0x57, 0x84, 0x37, 0x44, 0x45, 0x24, 0x93, 0x6a,
+                0x65, 0x46, 0xc4, 0x55, 0xd6, 0xc9, 0x2e, 0x6d, 0x3d, 0xc5, 0x38, 0xb6, 0xcd, 0x9f,
+                0x6d, 0x4c, 0xc0, 0xd7, 0x4d, 0x7b, 0xc2, 0x46, 0x7e, 0x21, 0x5b, 0xe8, 0xc3, 0xd4,
+                0xff, 0x91, 0x8a, 0x2d, 0x98, 0x71, 0x00, 0xff, 0x34, 0x02, 0x4c, 0x88, 0x62, 0x79,
+                0xd6, 0x4c, 0xaf, 0xdf, 0xd9, 0x0f, 0x1c, 0x04, 0xc4, 0x6b, 0xc9, 0xd5, 0xe9, 0xe2,
+                0xaf, 0xd0, 0x3a, 0xb7, 0x55, 0xe4, 0x0f, 0x08, 0x7e, 0xb5, 0x1e, 0xe3, 0xd1, 0x02,
+                0xb6, 0xb0, 0x69, 0xb6, 0x50, 0xf5, 0xd8, 0x55, 0x03, 0x35, 0x47, 0x1b, 0x24, 0x46,
+                0x5d, 0x93, 0x4d, 0x63, 0x34, 0x39, 0xb1, 0x08, 0xd9, 0x04, 0x2b, 0x37, 0xf9, 0xf7,
+                0x2e, 0x74, 0xfd, 0x6b, 0xa0, 0x01, 0x58, 0x5b, 0x08, 0x62, 0xdb, 0x99, 0x4a, 0x5e,
+                0xc1, 0x2d, 0xc9, 0x1e, 0x01, 0x48, 0x6a, 0x8d, 0xc6, 0x8a, 0xb9, 0xa3, 0x41, 0x93,
+                0x52, 0x61, 0x73, 0xec, 0xc0, 0xd1, 0x55, 0xb5, 0xcd, 0xd6, 0xbc, 0x07, 0xe6, 0x3e,
+                0x41, 0xaf, 0x9e, 0x52, 0x4c, 0xd3, 0xe6, 0x55, 0x5d, 0x38, 0xb4, 0x6d, 0xb2, 0xd9,
+                0x9e, 0x5b, 0xa4, 0xa4, 0x95, 0xff, 0x30, 0xfe, 0xf2, 0x54, 0xc9, 0xfe, 0x7b, 0x79,
+                0x0c, 0xe5, 0x6a, 0x40, 0xf4, 0x00, 0x27, 0xbb, 0x62, 0x05, 0x86, 0x38, 0xc4, 0x94,
+                0x17, 0x7b, 0x7f, 0x5c, 0x8f, 0x29, 0x44, 0x9e, 0x9e, 0xc3, 0xbd, 0xb3, 0xab, 0x04,
+                0x16, 0x0d, 0x96, 0xd0, 0xd4, 0x04, 0x79, 0x5d, 0x54, 0x28, 0x40, 0x82, 0xb6, 0x35,
+                0x7d, 0x58, 0x1d, 0xc2, 0x64, 0x81, 0x13, 0x67, 0xbb, 0xb1, 0x31, 0x9a, 0x31, 0xf7,
+                0x66, 0x4a, 0x4e, 0xca, 0x93, 0x2a, 0xbb, 0xd7, 0x33, 0xa7, 0x1a, 0x31, 0xaf, 0x23,
+                0x11, 0xc4, 0x9a, 0xc9, 0xaf, 0x22, 0xf8, 0x16, 0x7b, 0x25, 0x51, 0xac, 0xf5, 0x73,
+                0xd9, 0x1b, 0x40, 0x98, 0xc4, 0xde, 0xa8, 0xa9, 0x79, 0x9d, 0x9d, 0x54, 0x52, 0x0c,
+                0xc6, 0x3e, 0x55, 0x71, 0x8a, 0x24, 0x85, 0xbf, 0x6f, 0x63, 0x16, 0x30, 0x7c, 0xea,
+                0x21, 0x5e, 0x22, 0x22, 0x8d, 0x45, 0x34, 0x9a, 0x03, 0x50, 0x31, 0xa4, 0xcb, 0x67,
+                0x7b, 0x52, 0x3a, 0x3a, 0x51, 0x25, 0x2c, 0x6c, 0x61, 0xd0, 0xe2, 0x43, 0x2b, 0x94,
+                0xac, 0x9c, 0x0d, 0xb5, 0x0d, 0xbc, 0xb9, 0xa2, 0xaf, 0x76, 0xb9, 0xf9, 0x11, 0x0a,
+                0xd6, 0xcc, 0x2e, 0x7d, 0xe6, 0x49, 0x3a, 0x8e, 0x3c, 0xd1, 0xab, 0xf0, 0x6f, 0x4a,
+                0x2d, 0x47, 0x5e, 0xc7, 0x60, 0xeb, 0x7c, 0x36, 0xbb, 0xb1, 0x27, 0x50, 0x61, 0x10,
+                0x2d, 0xb3, 0x35, 0x6e, 0x11, 0x4d, 0xbc, 0xa3, 0xc5, 0xd8,
+            ],
+            ock: [
+                0x53, 0x29, 0x6e, 0xed, 0x43, 0xb4, 0xeb, 0x30, 0xa4, 0x3d, 0x88, 0x90, 0x2f, 0x74,
+                0x04, 0x26, 0x62, 0x1d, 0x85, 0x21, 0x3a, 0x36, 0xc5, 0x20, 0xa1, 0x84, 0xa4, 0x3a,
+                0xfb, 0xd4, 0x89, 0x6d,
+            ],
+            op: [
+                0x64, 0xce, 0xac, 0xec, 0x3c, 0x2e, 0xa7, 0x9c, 0x4c, 0xd3, 0xe2, 0xf0, 0xfb, 0xb9,
+                0xe1, 0xd4, 0x39, 0x55, 0xae, 0x66, 0xd8, 0x93, 0x92, 0xbf, 0x48, 0xaf, 0xb6, 0xc4,
+                0xab, 0x00, 0xa0, 0x28, 0x9b, 0x32, 0x77, 0x19, 0x3b, 0x63, 0x60, 0x8e, 0x6a, 0x3d,
+                0xdf, 0x7c, 0xe2, 0xd2, 0x33, 0x58, 0x4e, 0x66, 0x17, 0xd6, 0xf6, 0xa2, 0x1c, 0xdc,
+                0x86, 0x48, 0x56, 0x2c, 0xbd, 0x86, 0x3f, 0x09,
+            ],
+            c_out: [
+                0x38, 0xee, 0x14, 0xef, 0xb0, 0x63, 0x94, 0x64, 0x44, 0x6f, 0x5f, 0xb8, 0x79, 0x5d,
+                0x23, 0xf8, 0x8c, 0xf5, 0x65, 0x37, 0xe6, 0x4e, 0x1a, 0x46, 0x63, 0x17, 0xb3, 0x6f,
+                0x22, 0x2e, 0x00, 0x5b, 0x92, 0x4c, 0xc9, 0x10, 0xd6, 0x29, 0x06, 0x6e, 0x05, 0x07,
+                0xcb, 0x91, 0x2b, 0x0b, 0xc1, 0xd3, 0x16, 0xc2, 0x00, 0xb1, 0xa9, 0x56, 0x49, 0xc0,
+                0xc5, 0x30, 0xb4, 0xf3, 0xd0, 0x43, 0x06, 0x8e, 0xf6, 0xf4, 0x2d, 0xcb, 0xef, 0xd0,
+                0x2a, 0x34, 0x80, 0xe3, 0x2a, 0xa4, 0x5e, 0x33, 0xce, 0x25,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x77, 0x5c, 0x7f, 0x5c, 0xab, 0x43, 0x86, 0x88, 0x64, 0x3d, 0xdd, 0x15, 0x8d, 0xda,
+                0xed, 0xf9, 0xa0, 0xea, 0xef, 0x61, 0x4b, 0x54, 0x90, 0x60, 0xf1, 0xe4, 0xd7, 0xcc,
+                0x3e, 0x7e, 0x8b, 0x64, 0x49, 0x9a, 0x81, 0x8a, 0x6d, 0x0e, 0x33, 0x57, 0x68, 0x6e,
+                0x65, 0xbc, 0x27, 0x4e, 0x3f, 0x7d, 0x45, 0x5b, 0x91, 0x1f, 0x13, 0x9f, 0x19, 0xf0,
+                0x81, 0x61, 0x57, 0x51, 0x91, 0x3e, 0xb4, 0x12,
+            ],
+            ovk: [
+                0x45, 0xe1, 0x59, 0x6c, 0xbf, 0x46, 0x70, 0xb7, 0xe0, 0x5d, 0xfd, 0xaf, 0xbb, 0x0c,
+                0xf3, 0xdd, 0xee, 0x28, 0xd7, 0x6a, 0x82, 0x42, 0x8e, 0x8a, 0xba, 0x43, 0x64, 0xe8,
+                0x4b, 0xac, 0x37, 0x92,
+            ],
+            default_d: [
+                0x2d, 0x0e, 0x22, 0xbe, 0xb8, 0x62, 0xfe, 0x52, 0xc1, 0x4c, 0xf5,
+            ],
+            default_pk_d: [
+                0x9a, 0xe4, 0x94, 0xa9, 0xfc, 0xff, 0x9b, 0x74, 0x49, 0x14, 0x53, 0x31, 0x04, 0x4f,
+                0x9a, 0x02, 0x53, 0xe5, 0x24, 0xa0, 0x2c, 0x77, 0x95, 0xe9, 0x8f, 0x83, 0xec, 0x7d,
+                0x96, 0xdc, 0xe6, 0xb7,
+            ],
+            v: 10238534295395242511,
+            rseed: [
+                0xad, 0x8c, 0x7d, 0x94, 0x37, 0xe2, 0x0e, 0x2a, 0x1f, 0x20, 0xe8, 0x18, 0xf9, 0x05,
+                0x7c, 0x5a, 0xba, 0xaa, 0x2e, 0x5c, 0x15, 0xb9, 0x49, 0x45, 0xcd, 0x42, 0x4c, 0x28,
+                0xa5, 0xfa, 0x38, 0x5d,
+            ],
+            asset: [
+                0x76, 0xba, 0x24, 0x3f, 0x28, 0x42, 0xb7, 0xb5, 0xfc, 0x74, 0x6a, 0xe5, 0x1b, 0x0b,
+                0xc4, 0xbd, 0x4f, 0xc9, 0xfd, 0x83, 0x35, 0x65, 0xea, 0x85, 0x2b, 0x92, 0xb2, 0x24,
+                0xf6, 0x99, 0x03, 0x18,
+            ],
+            memo: [
+                0xff, 0xad, 0xfe, 0x49, 0x07, 0xb2, 0x74, 0xd8, 0x42, 0x70, 0x7d, 0xb3, 0x69, 0x7a,
+                0x5a, 0xe6, 0xc8, 0xf5, 0x42, 0xe5, 0xec, 0xc0, 0x7f, 0xe4, 0x73, 0x50, 0xd1, 0x01,
+                0x46, 0x70, 0x21, 0x2e, 0xfe, 0x81, 0xfb, 0x7c, 0x73, 0xe8, 0x45, 0x0d, 0xf8, 0x14,
+                0xef, 0x62, 0x32, 0xf7, 0x49, 0x0f, 0x63, 0xcc, 0xf0, 0x74, 0x80, 0xf8, 0x84, 0xa6,
+                0x6e, 0xaf, 0xfc, 0x28, 0xfe, 0xa4, 0x48, 0xd7, 0xb4, 0x01, 0xcd, 0xae, 0x10, 0xe7,
+                0xc0, 0xc7, 0xf9, 0xa7, 0xb1, 0x53, 0x31, 0x96, 0x9f, 0xc8, 0xcb, 0x36, 0x39, 0x67,
+                0x73, 0xde, 0x19, 0x19, 0x31, 0xc7, 0x50, 0xf6, 0xce, 0x5c, 0xaa, 0xf2, 0x97, 0x68,
+                0xeb, 0xb2, 0x7d, 0xac, 0xc7, 0x38, 0x05, 0x6a, 0x81, 0x25, 0xb4, 0x77, 0x2b, 0xf8,
+                0x7a, 0xe1, 0x0a, 0x8a, 0x30, 0x9b, 0x9b, 0xd6, 0x55, 0x04, 0x3c, 0xfc, 0x31, 0x59,
+                0x49, 0x43, 0x68, 0xc5, 0xab, 0x8c, 0xad, 0xb7, 0xf6, 0x71, 0xe9, 0x62, 0x6b, 0xd2,
+                0x63, 0xe3, 0x11, 0x81, 0xa6, 0x04, 0xb5, 0x06, 0xa0, 0x3b, 0x43, 0x9a, 0x7f, 0xfe,
+                0x43, 0x55, 0x89, 0x24, 0x77, 0xe2, 0xbd, 0xf3, 0x38, 0xc6, 0x2c, 0x39, 0x22, 0xf7,
+                0xd3, 0xc9, 0xa5, 0x6c, 0x71, 0x03, 0xd9, 0x11, 0x94, 0x8a, 0x84, 0xb5, 0xae, 0x2d,
+                0xbb, 0x16, 0xa3, 0x76, 0x1a, 0xdd, 0x05, 0x3a, 0x0f, 0x96, 0x7e, 0x6b, 0x5b, 0xc9,
+                0x42, 0x11, 0xb6, 0x54, 0x71, 0x53, 0x26, 0x7c, 0x6e, 0xe1, 0xca, 0xd0, 0xd9, 0x74,
+                0xa7, 0x10, 0x88, 0x58, 0x37, 0x35, 0xe4, 0xf6, 0x3d, 0x33, 0x15, 0x6d, 0xad, 0xd5,
+                0x4c, 0x2f, 0xaf, 0x89, 0x11, 0x4a, 0x12, 0x7b, 0x97, 0xb9, 0x4c, 0xc2, 0xa2, 0x2e,
+                0xf3, 0x03, 0xf4, 0x59, 0xd0, 0x4f, 0xc0, 0xb5, 0x3a, 0xce, 0x59, 0x18, 0xd4, 0x7f,
+                0xf3, 0x3a, 0x55, 0x8b, 0xd7, 0x1a, 0x75, 0xf3, 0x55, 0xfb, 0xd0, 0x6b, 0xbc, 0xcf,
+                0x4e, 0x02, 0xc3, 0xc0, 0xa4, 0xb6, 0x3d, 0x0c, 0xc9, 0x49, 0x80, 0x1d, 0x63, 0xa6,
+                0x4c, 0xb2, 0xd3, 0x23, 0x73, 0xb2, 0xc7, 0xb2, 0x74, 0xab, 0x2d, 0xb4, 0x68, 0x21,
+                0x42, 0xc8, 0xb2, 0x1d, 0x84, 0xc4, 0x81, 0xf5, 0xef, 0x21, 0xe4, 0xb5, 0xe3, 0x60,
+                0x34, 0x51, 0xbf, 0x94, 0x77, 0x4d, 0x0e, 0xf4, 0x7f, 0x63, 0xfa, 0x6a, 0xbb, 0x78,
+                0xd2, 0x1c, 0x19, 0x3c, 0xbe, 0x65, 0xb6, 0x95, 0xfe, 0x67, 0x42, 0x3c, 0x1e, 0x2d,
+                0x31, 0x2e, 0x27, 0x76, 0xfa, 0x24, 0xec, 0xe8, 0x46, 0x83, 0xe7, 0x48, 0x76, 0xc5,
+                0x5e, 0xa0, 0x36, 0x9e, 0x4e, 0xa0, 0xe8, 0x64, 0x94, 0xe0, 0x0d, 0xde, 0x23, 0x6a,
+                0x16, 0x89, 0x73, 0x1f, 0x0a, 0x5d, 0x82, 0x03, 0xaf, 0xde, 0x5c, 0x42, 0x36, 0x40,
+                0xb8, 0x1e, 0x4f, 0x63, 0x1c, 0x98, 0x1c, 0x11, 0xa2, 0xe1, 0xd1, 0x84, 0xc6, 0x7c,
+                0x52, 0x8d, 0xf9, 0x2d, 0x53, 0xae, 0xc4, 0x4a, 0x40, 0xa4, 0xea, 0x2a, 0x13, 0x1b,
+                0x47, 0x33, 0xcf, 0xe4, 0x5c, 0x6b, 0x00, 0x12, 0xc3, 0xe9, 0xe2, 0x09, 0x75, 0xba,
+                0xae, 0xcb, 0x02, 0x32, 0xdf, 0x88, 0x0b, 0xd7, 0xd1, 0xde, 0x13, 0xe1, 0x34, 0x94,
+                0x62, 0xec, 0x8d, 0x5d, 0xf3, 0xe7, 0x80, 0xff, 0xa7, 0x2e, 0xba, 0x8a, 0x8d, 0xf7,
+                0xfc, 0xf3, 0x98, 0xec, 0x23, 0x05, 0x13, 0xca, 0x9d, 0x61, 0x23, 0xf8, 0xb9, 0xd8,
+                0x17, 0x85, 0x60, 0xda, 0xf9, 0x75, 0x11, 0x19, 0x55, 0xa2, 0xbc, 0xa3, 0x42, 0x3e,
+                0xee, 0xfc, 0x52, 0x7b, 0xe3, 0xa8, 0x54, 0x3e, 0xb9, 0x0a, 0x5e, 0xc0, 0x2f, 0x35,
+                0xa7, 0xc6, 0x4b, 0x7d, 0xd5, 0x9a, 0x72, 0xda, 0x00, 0x74, 0x63, 0x4e, 0x01, 0xd2,
+                0xab, 0xf3, 0x63, 0x7a, 0xdd, 0x77, 0xc7, 0x35,
+            ],
+            cv_net: [
+                0x43, 0x94, 0x47, 0xab, 0x14, 0x5a, 0x6f, 0x0e, 0x5a, 0x3b, 0x43, 0x63, 0x04, 0x4c,
+                0x73, 0x07, 0x93, 0xf4, 0x36, 0x33, 0x1f, 0xfe, 0x66, 0x30, 0xc7, 0xca, 0x2d, 0x9b,
+                0x23, 0x2a, 0xe1, 0x98,
+            ],
+            rho: [
+                0xd6, 0xff, 0xc4, 0x74, 0x88, 0xad, 0x05, 0x93, 0x89, 0x70, 0xc4, 0xb1, 0x56, 0xd0,
+                0x53, 0xb9, 0x3b, 0xcb, 0xb4, 0x37, 0x57, 0x1c, 0x62, 0xf3, 0x75, 0x60, 0x7e, 0x90,
+                0x4e, 0xb3, 0xa2, 0x08,
+            ],
+            cmx: [
+                0x8f, 0x56, 0xd1, 0x3f, 0xd9, 0xc8, 0x3e, 0xb7, 0x1b, 0x95, 0x87, 0x7a, 0x4f, 0x29,
+                0x39, 0x64, 0xbf, 0x3f, 0x73, 0x1d, 0x8d, 0xf2, 0x04, 0x32, 0x2c, 0xed, 0xcb, 0x38,
+                0x68, 0x21, 0x90, 0x3c,
+            ],
+            esk: [
+                0x24, 0x50, 0xae, 0xde, 0xb9, 0x7e, 0x62, 0xd7, 0x9c, 0xcb, 0x44, 0xb0, 0xb0, 0x4f,
+                0xe7, 0x93, 0x92, 0x5d, 0x49, 0xc4, 0xc0, 0x1f, 0x49, 0x2e, 0xa9, 0xec, 0x88, 0x17,
+                0x18, 0x65, 0x40, 0x33,
+            ],
+            ephemeral_key: [
+                0x51, 0x66, 0x26, 0x31, 0x6e, 0xea, 0x63, 0xa6, 0x45, 0xae, 0x56, 0x23, 0x81, 0x5a,
+                0x31, 0x74, 0xb3, 0xed, 0x36, 0x64, 0xc3, 0x3e, 0x6a, 0x51, 0x81, 0xa9, 0xf5, 0xb5,
+                0x42, 0x76, 0x7a, 0x2d,
+            ],
+            shared_secret: [
+                0xf6, 0x04, 0x23, 0x98, 0x7f, 0x0e, 0x67, 0x6d, 0x1a, 0x3b, 0xb6, 0xef, 0xe0, 0x39,
+                0x42, 0x1d, 0xbb, 0xc8, 0x24, 0xb6, 0x90, 0xc1, 0x94, 0xa4, 0x90, 0xe4, 0x17, 0x1d,
+                0xde, 0x21, 0x58, 0x19,
+            ],
+            k_enc: [
+                0x20, 0x98, 0x25, 0x7e, 0x2b, 0x9b, 0x7f, 0xc0, 0x62, 0x82, 0x38, 0x03, 0x38, 0x59,
+                0x7d, 0xcb, 0x62, 0x7d, 0xdf, 0x47, 0x3e, 0x83, 0xa7, 0x2e, 0x61, 0xb0, 0xf2, 0x2c,
+                0xcf, 0xaf, 0xbe, 0x4e,
+            ],
+            p_enc: [
+                0x03, 0x2d, 0x0e, 0x22, 0xbe, 0xb8, 0x62, 0xfe, 0x52, 0xc1, 0x4c, 0xf5, 0x0f, 0x12,
+                0xb0, 0x11, 0xb2, 0x94, 0x16, 0x8e, 0xad, 0x8c, 0x7d, 0x94, 0x37, 0xe2, 0x0e, 0x2a,
+                0x1f, 0x20, 0xe8, 0x18, 0xf9, 0x05, 0x7c, 0x5a, 0xba, 0xaa, 0x2e, 0x5c, 0x15, 0xb9,
+                0x49, 0x45, 0xcd, 0x42, 0x4c, 0x28, 0xa5, 0xfa, 0x38, 0x5d, 0x76, 0xba, 0x24, 0x3f,
+                0x28, 0x42, 0xb7, 0xb5, 0xfc, 0x74, 0x6a, 0xe5, 0x1b, 0x0b, 0xc4, 0xbd, 0x4f, 0xc9,
+                0xfd, 0x83, 0x35, 0x65, 0xea, 0x85, 0x2b, 0x92, 0xb2, 0x24, 0xf6, 0x99, 0x03, 0x18,
+                0xff, 0xad, 0xfe, 0x49, 0x07, 0xb2, 0x74, 0xd8, 0x42, 0x70, 0x7d, 0xb3, 0x69, 0x7a,
+                0x5a, 0xe6, 0xc8, 0xf5, 0x42, 0xe5, 0xec, 0xc0, 0x7f, 0xe4, 0x73, 0x50, 0xd1, 0x01,
+                0x46, 0x70, 0x21, 0x2e, 0xfe, 0x81, 0xfb, 0x7c, 0x73, 0xe8, 0x45, 0x0d, 0xf8, 0x14,
+                0xef, 0x62, 0x32, 0xf7, 0x49, 0x0f, 0x63, 0xcc, 0xf0, 0x74, 0x80, 0xf8, 0x84, 0xa6,
+                0x6e, 0xaf, 0xfc, 0x28, 0xfe, 0xa4, 0x48, 0xd7, 0xb4, 0x01, 0xcd, 0xae, 0x10, 0xe7,
+                0xc0, 0xc7, 0xf9, 0xa7, 0xb1, 0x53, 0x31, 0x96, 0x9f, 0xc8, 0xcb, 0x36, 0x39, 0x67,
+                0x73, 0xde, 0x19, 0x19, 0x31, 0xc7, 0x50, 0xf6, 0xce, 0x5c, 0xaa, 0xf2, 0x97, 0x68,
+                0xeb, 0xb2, 0x7d, 0xac, 0xc7, 0x38, 0x05, 0x6a, 0x81, 0x25, 0xb4, 0x77, 0x2b, 0xf8,
+                0x7a, 0xe1, 0x0a, 0x8a, 0x30, 0x9b, 0x9b, 0xd6, 0x55, 0x04, 0x3c, 0xfc, 0x31, 0x59,
+                0x49, 0x43, 0x68, 0xc5, 0xab, 0x8c, 0xad, 0xb7, 0xf6, 0x71, 0xe9, 0x62, 0x6b, 0xd2,
+                0x63, 0xe3, 0x11, 0x81, 0xa6, 0x04, 0xb5, 0x06, 0xa0, 0x3b, 0x43, 0x9a, 0x7f, 0xfe,
+                0x43, 0x55, 0x89, 0x24, 0x77, 0xe2, 0xbd, 0xf3, 0x38, 0xc6, 0x2c, 0x39, 0x22, 0xf7,
+                0xd3, 0xc9, 0xa5, 0x6c, 0x71, 0x03, 0xd9, 0x11, 0x94, 0x8a, 0x84, 0xb5, 0xae, 0x2d,
+                0xbb, 0x16, 0xa3, 0x76, 0x1a, 0xdd, 0x05, 0x3a, 0x0f, 0x96, 0x7e, 0x6b, 0x5b, 0xc9,
+                0x42, 0x11, 0xb6, 0x54, 0x71, 0x53, 0x26, 0x7c, 0x6e, 0xe1, 0xca, 0xd0, 0xd9, 0x74,
+                0xa7, 0x10, 0x88, 0x58, 0x37, 0x35, 0xe4, 0xf6, 0x3d, 0x33, 0x15, 0x6d, 0xad, 0xd5,
+                0x4c, 0x2f, 0xaf, 0x89, 0x11, 0x4a, 0x12, 0x7b, 0x97, 0xb9, 0x4c, 0xc2, 0xa2, 0x2e,
+                0xf3, 0x03, 0xf4, 0x59, 0xd0, 0x4f, 0xc0, 0xb5, 0x3a, 0xce, 0x59, 0x18, 0xd4, 0x7f,
+                0xf3, 0x3a, 0x55, 0x8b, 0xd7, 0x1a, 0x75, 0xf3, 0x55, 0xfb, 0xd0, 0x6b, 0xbc, 0xcf,
+                0x4e, 0x02, 0xc3, 0xc0, 0xa4, 0xb6, 0x3d, 0x0c, 0xc9, 0x49, 0x80, 0x1d, 0x63, 0xa6,
+                0x4c, 0xb2, 0xd3, 0x23, 0x73, 0xb2, 0xc7, 0xb2, 0x74, 0xab, 0x2d, 0xb4, 0x68, 0x21,
+                0x42, 0xc8, 0xb2, 0x1d, 0x84, 0xc4, 0x81, 0xf5, 0xef, 0x21, 0xe4, 0xb5, 0xe3, 0x60,
+                0x34, 0x51, 0xbf, 0x94, 0x77, 0x4d, 0x0e, 0xf4, 0x7f, 0x63, 0xfa, 0x6a, 0xbb, 0x78,
+                0xd2, 0x1c, 0x19, 0x3c, 0xbe, 0x65, 0xb6, 0x95, 0xfe, 0x67, 0x42, 0x3c, 0x1e, 0x2d,
+                0x31, 0x2e, 0x27, 0x76, 0xfa, 0x24, 0xec, 0xe8, 0x46, 0x83, 0xe7, 0x48, 0x76, 0xc5,
+                0x5e, 0xa0, 0x36, 0x9e, 0x4e, 0xa0, 0xe8, 0x64, 0x94, 0xe0, 0x0d, 0xde, 0x23, 0x6a,
+                0x16, 0x89, 0x73, 0x1f, 0x0a, 0x5d, 0x82, 0x03, 0xaf, 0xde, 0x5c, 0x42, 0x36, 0x40,
+                0xb8, 0x1e, 0x4f, 0x63, 0x1c, 0x98, 0x1c, 0x11, 0xa2, 0xe1, 0xd1, 0x84, 0xc6, 0x7c,
+                0x52, 0x8d, 0xf9, 0x2d, 0x53, 0xae, 0xc4, 0x4a, 0x40, 0xa4, 0xea, 0x2a, 0x13, 0x1b,
+                0x47, 0x33, 0xcf, 0xe4, 0x5c, 0x6b, 0x00, 0x12, 0xc3, 0xe9, 0xe2, 0x09, 0x75, 0xba,
+                0xae, 0xcb, 0x02, 0x32, 0xdf, 0x88, 0x0b, 0xd7, 0xd1, 0xde, 0x13, 0xe1, 0x34, 0x94,
+                0x62, 0xec, 0x8d, 0x5d, 0xf3, 0xe7, 0x80, 0xff, 0xa7, 0x2e, 0xba, 0x8a, 0x8d, 0xf7,
+                0xfc, 0xf3, 0x98, 0xec, 0x23, 0x05, 0x13, 0xca, 0x9d, 0x61, 0x23, 0xf8, 0xb9, 0xd8,
+                0x17, 0x85, 0x60, 0xda, 0xf9, 0x75, 0x11, 0x19, 0x55, 0xa2, 0xbc, 0xa3, 0x42, 0x3e,
+                0xee, 0xfc, 0x52, 0x7b, 0xe3, 0xa8, 0x54, 0x3e, 0xb9, 0x0a, 0x5e, 0xc0, 0x2f, 0x35,
+                0xa7, 0xc6, 0x4b, 0x7d, 0xd5, 0x9a, 0x72, 0xda, 0x00, 0x74, 0x63, 0x4e, 0x01, 0xd2,
+                0xab, 0xf3, 0x63, 0x7a, 0xdd, 0x77, 0xc7, 0x35,
+            ],
+            c_enc: [
+                0xa4, 0x01, 0xab, 0x60, 0x1f, 0x8d, 0x69, 0xd9, 0x38, 0x0c, 0x3d, 0xef, 0x1f, 0x1a,
+                0x34, 0xbe, 0x6c, 0xfa, 0x4d, 0x83, 0x8b, 0xf8, 0x7f, 0x00, 0xe3, 0x6b, 0xe6, 0xbe,
+                0x68, 0x60, 0xbe, 0xa8, 0x3d, 0xab, 0xdd, 0x00, 0xab, 0xe7, 0xe0, 0xd1, 0x21, 0x90,
+                0xfb, 0x54, 0xb0, 0xf2, 0xad, 0xcf, 0xef, 0x9e, 0xf4, 0x2b, 0xa2, 0x31, 0x77, 0x6a,
+                0xd3, 0xee, 0x09, 0x86, 0xdb, 0x3f, 0x4f, 0xc0, 0xa8, 0xa1, 0xc6, 0xa7, 0xfe, 0x54,
+                0xa6, 0x6b, 0xd7, 0x68, 0xa9, 0xde, 0xd2, 0x5b, 0xb1, 0x89, 0xd5, 0x87, 0x1c, 0xaf,
+                0x4d, 0xf8, 0x95, 0x6c, 0x2f, 0x30, 0x70, 0x15, 0x89, 0xa4, 0xdc, 0xdb, 0x68, 0x11,
+                0x6d, 0x0f, 0x50, 0x9b, 0x34, 0x1e, 0x8f, 0x25, 0x8e, 0x17, 0x38, 0xb5, 0x51, 0x9c,
+                0x99, 0xf1, 0xdb, 0xd0, 0x86, 0x31, 0x56, 0x2f, 0x90, 0xd1, 0x5e, 0x72, 0x8a, 0x85,
+                0x25, 0xa1, 0x1b, 0xfe, 0x53, 0x95, 0x24, 0x5d, 0x71, 0x79, 0xcf, 0x8e, 0x97, 0xa8,
+                0x3f, 0xaa, 0x4c, 0xf3, 0xb2, 0xa8, 0xb5, 0xef, 0x62, 0x13, 0xe3, 0x30, 0x89, 0xb4,
+                0xeb, 0x03, 0xe7, 0xc2, 0xf0, 0x12, 0x11, 0xfc, 0x53, 0xbc, 0x01, 0x16, 0x40, 0x05,
+                0x01, 0x5d, 0xbf, 0x33, 0xc6, 0x50, 0xa3, 0xf8, 0x33, 0xba, 0x67, 0x77, 0xcf, 0xf1,
+                0xd7, 0x38, 0xe2, 0x1c, 0x58, 0xdc, 0x05, 0xc3, 0xb4, 0xec, 0xb9, 0x7a, 0x6c, 0xe0,
+                0xb0, 0xc5, 0xee, 0x94, 0x4c, 0x24, 0xb3, 0x3b, 0xb0, 0xce, 0x32, 0xbe, 0x02, 0x3e,
+                0x21, 0x3f, 0xf7, 0xc9, 0xd4, 0x12, 0x4f, 0xc9, 0xdc, 0x4a, 0xa7, 0xca, 0x47, 0x13,
+                0x86, 0x48, 0xe2, 0xbb, 0x80, 0x7c, 0xea, 0x7a, 0x58, 0xe7, 0x67, 0xd3, 0x27, 0x07,
+                0x4a, 0xe5, 0xe3, 0x9c, 0x3c, 0x17, 0xb7, 0x7c, 0x09, 0x0a, 0xf9, 0x42, 0x5b, 0xc6,
+                0x40, 0xd2, 0x1d, 0xd6, 0x81, 0xa6, 0x37, 0x45, 0xe9, 0x02, 0x59, 0xe2, 0xd1, 0x09,
+                0x0c, 0x88, 0x48, 0x8e, 0x21, 0x48, 0xb9, 0xee, 0x24, 0x31, 0xc5, 0xae, 0xf5, 0x10,
+                0x95, 0xb3, 0x5a, 0x37, 0x7c, 0xfa, 0x76, 0x5d, 0x82, 0x24, 0x98, 0x83, 0x00, 0x04,
+                0x71, 0x79, 0xa5, 0x09, 0x40, 0x28, 0xbe, 0x52, 0x7d, 0x5d, 0xe1, 0xc2, 0x69, 0xff,
+                0x45, 0x2c, 0x0a, 0xaf, 0x5a, 0x47, 0x7e, 0x93, 0x90, 0xa0, 0xf0, 0xa8, 0x68, 0x11,
+                0x3c, 0x7c, 0xd1, 0x9e, 0x2e, 0xac, 0x54, 0x0d, 0xc6, 0x59, 0xda, 0x29, 0x60, 0x06,
+                0x77, 0x6e, 0xda, 0x0d, 0xf9, 0x81, 0xc4, 0x11, 0xc1, 0x50, 0x01, 0xa9, 0x8b, 0x6a,
+                0xd6, 0x58, 0xd9, 0xa6, 0x4c, 0x12, 0x6a, 0xbe, 0xfc, 0x73, 0x9a, 0xa1, 0xf4, 0x44,
+                0xbb, 0x83, 0xf3, 0xf1, 0x4d, 0x11, 0x3d, 0x02, 0x8f, 0xae, 0x10, 0xe4, 0xc5, 0xdb,
+                0xe7, 0x78, 0x51, 0x96, 0x83, 0xcd, 0xf4, 0xc2, 0xf4, 0x6c, 0x4a, 0x52, 0xae, 0x12,
+                0x09, 0xe1, 0x12, 0x7f, 0x9d, 0xc4, 0xed, 0x86, 0x7d, 0x8e, 0xda, 0x02, 0x4a, 0x68,
+                0x9f, 0x6b, 0x15, 0xb8, 0x05, 0x38, 0x03, 0x02, 0x44, 0x02, 0xa1, 0xce, 0x6f, 0x1c,
+                0x63, 0x6f, 0x2e, 0xfc, 0xf9, 0xd0, 0x60, 0x51, 0x5c, 0xd6, 0x14, 0x71, 0x8d, 0x51,
+                0x52, 0x7d, 0x26, 0x7a, 0xd8, 0x95, 0xfa, 0xd8, 0xec, 0xfb, 0x23, 0x51, 0xf8, 0x92,
+                0x45, 0x0d, 0xc8, 0x74, 0xe8, 0x74, 0x39, 0x2c, 0x91, 0xed, 0x3a, 0xf1, 0x18, 0x38,
+                0xc4, 0xb5, 0x48, 0x2e, 0x8c, 0x92, 0xeb, 0xc7, 0xa0, 0x08, 0x8e, 0x49, 0xd2, 0xb0,
+                0xb4, 0xa1, 0xbd, 0x33, 0x3b, 0x38, 0x7f, 0x49, 0xe3, 0x0f, 0xd2, 0x1a, 0x6e, 0xdc,
+                0x89, 0x94, 0x83, 0x4f, 0x28, 0xe9, 0xf2, 0x52, 0x9a, 0x7e, 0x27, 0x24, 0x21, 0x6d,
+                0x9e, 0x1a, 0xe5, 0xb4, 0x6e, 0xb1, 0x9a, 0x53, 0xea, 0x2b, 0x97, 0x99, 0x65, 0xf7,
+                0x5b, 0x83, 0xf6, 0x86, 0xed, 0xc0, 0x1d, 0x25, 0x7a, 0x06, 0x58, 0xd7, 0x4e, 0x25,
+                0xc0, 0xe1, 0xa8, 0xb0, 0x65, 0x60, 0x43, 0x1f, 0x85, 0x10, 0x5c, 0xf9, 0x8a, 0x1f,
+                0xfe, 0x28, 0x40, 0x8a, 0x64, 0xf4, 0xc0, 0x27, 0x8d, 0x36, 0xed, 0xea, 0x76, 0x40,
+                0xa2, 0x18, 0x26, 0xc3, 0xae, 0xba, 0xcb, 0x41, 0x4d, 0xa1, 0x8c, 0xc1, 0xd1, 0xe8,
+                0x64, 0xc1, 0x6e, 0x97, 0x71, 0x0d, 0x56, 0xe0, 0xa1, 0x0e, 0x2c, 0xae, 0x86, 0xcb,
+                0x27, 0x50, 0x14, 0x21, 0xdf, 0x52, 0xeb, 0x3c, 0x2f, 0x6e, 0x9d, 0x15, 0x59, 0xc1,
+                0xb9, 0x5e, 0x7f, 0x63, 0xcb, 0x5c, 0xfa, 0xf5, 0xca, 0xc1,
+            ],
+            ock: [
+                0x2a, 0x2e, 0x0d, 0x99, 0x69, 0xf0, 0x2e, 0xbd, 0xb6, 0xd9, 0xc8, 0xe7, 0xe6, 0xfd,
+                0xde, 0x20, 0x85, 0x12, 0x4b, 0x19, 0xad, 0x70, 0x90, 0xcc, 0x26, 0x15, 0x1d, 0x4d,
+                0xa4, 0x2a, 0x00, 0x3e,
+            ],
+            op: [
+                0x9a, 0xe4, 0x94, 0xa9, 0xfc, 0xff, 0x9b, 0x74, 0x49, 0x14, 0x53, 0x31, 0x04, 0x4f,
+                0x9a, 0x02, 0x53, 0xe5, 0x24, 0xa0, 0x2c, 0x77, 0x95, 0xe9, 0x8f, 0x83, 0xec, 0x7d,
+                0x96, 0xdc, 0xe6, 0xb7, 0x24, 0x50, 0xae, 0xde, 0xb9, 0x7e, 0x62, 0xd7, 0x9c, 0xcb,
+                0x44, 0xb0, 0xb0, 0x4f, 0xe7, 0x93, 0x92, 0x5d, 0x49, 0xc4, 0xc0, 0x1f, 0x49, 0x2e,
+                0xa9, 0xec, 0x88, 0x17, 0x18, 0x65, 0x40, 0x33,
+            ],
+            c_out: [
+                0x74, 0x6a, 0xae, 0x9d, 0xa6, 0x1c, 0x02, 0xae, 0xaa, 0x8b, 0xed, 0xbe, 0x2b, 0x6c,
+                0x84, 0x1b, 0xc4, 0x36, 0x17, 0x3c, 0x7c, 0x91, 0x13, 0x66, 0x3a, 0x39, 0xc1, 0x74,
+                0x69, 0x29, 0x0b, 0xd2, 0x19, 0xea, 0xdc, 0x4a, 0x97, 0x5a, 0xd0, 0x52, 0xd0, 0x5d,
+                0xc0, 0xa3, 0x08, 0xf3, 0x63, 0xf9, 0x22, 0x68, 0x2d, 0x75, 0x21, 0x9d, 0xaa, 0x33,
+                0x6f, 0x69, 0xb5, 0x9e, 0x86, 0x7c, 0x85, 0xd9, 0x37, 0x34, 0x4c, 0x19, 0xd3, 0x88,
+                0x01, 0x63, 0x19, 0xb3, 0xf6, 0x0f, 0x76, 0xd0, 0x28, 0x93,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0x9c, 0xe9, 0x20, 0x37, 0x6a, 0x6a, 0x54, 0x1e, 0x6a, 0xad, 0x66, 0x0e, 0xfa, 0x09,
+                0x8d, 0xc5, 0x4c, 0x18, 0xfc, 0xeb, 0x13, 0xd0, 0x99, 0x9f, 0xbc, 0xc7, 0xfd, 0x45,
+                0xa5, 0x7c, 0xcc, 0x10, 0xb8, 0xaa, 0x86, 0xc4, 0x54, 0x0d, 0x0a, 0x9f, 0xc6, 0x6d,
+                0xf8, 0x5d, 0xad, 0xd6, 0x21, 0x56, 0x36, 0x5e, 0x28, 0xa3, 0xe9, 0x80, 0xb9, 0x8d,
+                0x13, 0x1b, 0x50, 0x3a, 0xa0, 0x6a, 0x6c, 0x19,
+            ],
+            ovk: [
+                0xf8, 0x1a, 0xd6, 0x17, 0xfa, 0x26, 0xf0, 0xdf, 0xb8, 0x36, 0x55, 0xb8, 0xa2, 0x9a,
+                0x7f, 0x83, 0x42, 0x32, 0x42, 0x5e, 0x8c, 0x47, 0x45, 0x88, 0xf1, 0x8d, 0xd3, 0x26,
+                0xaa, 0x39, 0x6c, 0x3e,
+            ],
+            default_d: [
+                0xfb, 0x8e, 0xa2, 0xcc, 0x0a, 0xd2, 0x30, 0x91, 0x32, 0xfd, 0x11,
+            ],
+            default_pk_d: [
+                0xcc, 0x18, 0xe4, 0xb6, 0x5f, 0x89, 0x34, 0x06, 0x31, 0x5d, 0xb7, 0x1f, 0xac, 0x06,
+                0x5d, 0x71, 0xd0, 0xea, 0xba, 0x7c, 0xf3, 0xc2, 0xba, 0x94, 0x77, 0x12, 0x32, 0x75,
+                0x43, 0x4b, 0x1e, 0xb0,
+            ],
+            v: 2690686290017047047,
+            rseed: [
+                0x0b, 0x39, 0x05, 0xa4, 0xe3, 0xbd, 0x01, 0xc5, 0x4d, 0xf8, 0x64, 0x34, 0x43, 0xbe,
+                0x0f, 0x88, 0x90, 0x32, 0xea, 0x32, 0x5b, 0xf0, 0x71, 0x07, 0xfd, 0x41, 0xd6, 0x73,
+                0xee, 0xba, 0xe6, 0xfa,
+            ],
+            asset: [
+                0x64, 0xd0, 0x87, 0x40, 0x89, 0x86, 0xe7, 0x3d, 0x6e, 0x28, 0x4f, 0xea, 0x9a, 0x23,
+                0xc3, 0x93, 0x11, 0x78, 0x2f, 0x86, 0xca, 0xbf, 0xf9, 0x45, 0x5e, 0x4c, 0xf6, 0x99,
+                0xe5, 0xf5, 0xd4, 0xbc,
+            ],
+            memo: [
+                0xff, 0x63, 0x7b, 0x70, 0xcc, 0x0e, 0xd3, 0xf0, 0x09, 0x58, 0xdf, 0xb8, 0xdc, 0xf0,
+                0x0e, 0x85, 0xa1, 0xd0, 0xa6, 0xa8, 0x90, 0x81, 0x40, 0xc2, 0xf4, 0x34, 0xc2, 0xe2,
+                0x60, 0xef, 0xb0, 0xbc, 0xa2, 0x00, 0x35, 0x04, 0xc9, 0x99, 0x93, 0xa9, 0xe1, 0xc0,
+                0xff, 0x9c, 0xef, 0xe6, 0xa6, 0x65, 0xd7, 0x91, 0x42, 0x86, 0x90, 0xe4, 0x7e, 0xf8,
+                0xc1, 0x31, 0xa8, 0xe9, 0xbf, 0xb4, 0xc3, 0x08, 0x02, 0x35, 0x03, 0x2d, 0x73, 0x1b,
+                0x0d, 0x38, 0x41, 0x22, 0x5f, 0x1c, 0x11, 0xe2, 0xc2, 0x8e, 0xe8, 0x4d, 0x35, 0xf9,
+                0x22, 0x61, 0x00, 0x56, 0x59, 0x72, 0xeb, 0x26, 0x9d, 0x27, 0x8e, 0xf6, 0x49, 0x79,
+                0xbf, 0x65, 0x15, 0xed, 0x4a, 0x68, 0x40, 0xb0, 0x88, 0x3a, 0x9e, 0x6e, 0xf6, 0x4a,
+                0x0e, 0xfc, 0xae, 0x1c, 0xf2, 0x1d, 0xfe, 0x74, 0x85, 0x4e, 0x84, 0xc2, 0x74, 0x9f,
+                0xac, 0x03, 0x82, 0x52, 0x75, 0xc9, 0xb6, 0x30, 0x21, 0x84, 0xc7, 0x2d, 0xf4, 0xc4,
+                0xbb, 0x28, 0x62, 0xe4, 0xe8, 0xa7, 0xd9, 0xa4, 0xa2, 0x82, 0x86, 0x6f, 0x9a, 0x7b,
+                0x2c, 0xfc, 0x9a, 0x56, 0x31, 0x3d, 0xa0, 0xc4, 0x7a, 0x34, 0xb7, 0xb9, 0xcd, 0xa3,
+                0xac, 0xe8, 0x18, 0x5f, 0x07, 0xdf, 0x36, 0xe4, 0x48, 0xa7, 0x6a, 0xa4, 0x77, 0xf2,
+                0x24, 0xd8, 0x7a, 0x07, 0x4f, 0x43, 0xaf, 0x5d, 0x5f, 0x79, 0xb3, 0xab, 0x11, 0x28,
+                0xf0, 0x81, 0x91, 0x44, 0x7f, 0xa6, 0x46, 0xbf, 0xdd, 0xe5, 0xb5, 0x1e, 0x23, 0x3c,
+                0xa6, 0x15, 0x5d, 0x10, 0x15, 0x85, 0xbc, 0x2c, 0x40, 0x15, 0x8a, 0xc2, 0x10, 0x6e,
+                0x66, 0xa2, 0x6e, 0x46, 0x42, 0x33, 0x70, 0x63, 0x68, 0x76, 0xb4, 0x34, 0xa7, 0x4f,
+                0x8c, 0xe8, 0x06, 0x00, 0x50, 0xb0, 0x82, 0xa7, 0x9b, 0x61, 0xbb, 0x5d, 0x34, 0x4e,
+                0xb5, 0xa1, 0x15, 0x83, 0x26, 0xce, 0xd9, 0xa9, 0xd9, 0xf5, 0x4f, 0xb2, 0xfe, 0x8f,
+                0x9f, 0x05, 0xcd, 0x11, 0x1e, 0xe4, 0x6c, 0x47, 0x10, 0xf6, 0xf6, 0x3a, 0x62, 0x69,
+                0x45, 0x57, 0xef, 0x1b, 0x12, 0xc8, 0x80, 0x06, 0xb6, 0x78, 0x72, 0x50, 0x5f, 0x4e,
+                0x88, 0x3b, 0x58, 0x59, 0x07, 0x92, 0x9a, 0x2f, 0x3f, 0xdb, 0x0d, 0x8f, 0x79, 0x14,
+                0xc4, 0x2d, 0xde, 0x2d, 0x20, 0x00, 0xf5, 0xae, 0x02, 0xd4, 0x18, 0x21, 0xc8, 0xe1,
+                0xee, 0x01, 0x38, 0xeb, 0xcb, 0x72, 0x8d, 0x7c, 0x6c, 0x3c, 0x80, 0x02, 0x7e, 0x43,
+                0x75, 0x94, 0xc6, 0x70, 0xfd, 0x6f, 0x39, 0x08, 0x22, 0x2e, 0xe7, 0xa1, 0xb9, 0x17,
+                0xf8, 0x27, 0x1a, 0xbe, 0x66, 0x0e, 0x39, 0xe0, 0x51, 0xaa, 0xa6, 0xfc, 0xa1, 0x86,
+                0x22, 0x76, 0xe2, 0xba, 0xa0, 0xfe, 0x0b, 0x16, 0x2a, 0xeb, 0xcf, 0xe3, 0xd9, 0x34,
+                0x9c, 0x8d, 0x15, 0x4b, 0xb7, 0xee, 0x28, 0x21, 0x2c, 0x1b, 0xaa, 0x70, 0x5d, 0x82,
+                0x07, 0x0d, 0x70, 0x32, 0xf2, 0x69, 0x5d, 0x17, 0x96, 0x80, 0x9f, 0xab, 0x41, 0x24,
+                0x69, 0x26, 0xaf, 0x99, 0x2b, 0x6e, 0xee, 0x95, 0xa9, 0xa0, 0x6b, 0xc4, 0x56, 0x2c,
+                0x5f, 0x2f, 0x1b, 0x19, 0x54, 0x95, 0x00, 0x37, 0x2e, 0x7a, 0xd5, 0x79, 0xa6, 0xd6,
+                0xd7, 0x8b, 0x33, 0x15, 0x31, 0x30, 0xfb, 0x44, 0x8f, 0xb7, 0x9e, 0x8a, 0x66, 0x9d,
+                0xb8, 0xa0, 0xf3, 0x5c, 0xdf, 0x9a, 0xe5, 0xd3, 0x2d, 0x73, 0x2f, 0xc7, 0x94, 0x18,
+                0xe2, 0x3b, 0x45, 0x1d, 0xdc, 0x95, 0xa2, 0x2a, 0xba, 0xbb, 0x05, 0x6e, 0xc6, 0xb5,
+                0xe8, 0xba, 0x4f, 0x52, 0x4d, 0xfa, 0xfe, 0x87, 0x52, 0x62, 0xdd, 0x7b, 0xe4, 0x1c,
+                0xbb, 0xc6, 0x24, 0x20, 0xd4, 0xad, 0x6d, 0xf5, 0xc9, 0xb7, 0x13, 0x60, 0x4f, 0x65,
+                0x60, 0x88, 0xa4, 0x48, 0x5e, 0x93, 0xbe, 0x19,
+            ],
+            cv_net: [
+                0xf4, 0x5c, 0xba, 0x14, 0x6a, 0xe7, 0x18, 0x85, 0xfd, 0x61, 0xb4, 0xa0, 0xf3, 0x6b,
+                0x95, 0x26, 0xa6, 0xe9, 0x4a, 0x49, 0x70, 0x10, 0xe3, 0x2a, 0x8a, 0x76, 0xbc, 0xdf,
+                0xa7, 0x20, 0xb8, 0xa6,
+            ],
+            rho: [
+                0x85, 0x2f, 0x5c, 0x39, 0xd3, 0xf3, 0x55, 0xa3, 0x85, 0xe2, 0xab, 0xd2, 0x54, 0x3a,
+                0xa5, 0xed, 0x09, 0xc6, 0xee, 0x3b, 0x7f, 0x39, 0x34, 0x14, 0xe1, 0x1c, 0xd4, 0x20,
+                0x4c, 0x3f, 0x8d, 0x26,
+            ],
+            cmx: [
+                0x69, 0x4b, 0x6f, 0x3a, 0xb8, 0x37, 0xa9, 0x26, 0xd6, 0x77, 0x3e, 0xc4, 0xa6, 0x76,
+                0x5d, 0xef, 0x82, 0x89, 0x33, 0x74, 0x2d, 0x93, 0x29, 0xfc, 0x88, 0x67, 0x1c, 0xcd,
+                0x81, 0x21, 0xa4, 0x23,
+            ],
+            esk: [
+                0xaa, 0x84, 0x16, 0x79, 0xd4, 0xd2, 0x40, 0xb0, 0xab, 0xc4, 0xa5, 0xd8, 0x9a, 0xa8,
+                0xd6, 0xb3, 0xb0, 0x86, 0x92, 0x23, 0xed, 0x76, 0x3b, 0x67, 0x6a, 0x72, 0xcb, 0x74,
+                0xfb, 0x18, 0xd1, 0x17,
+            ],
+            ephemeral_key: [
+                0x3c, 0x04, 0xbe, 0x6e, 0x42, 0xa6, 0xca, 0x7f, 0x5d, 0xda, 0x0d, 0x82, 0xdf, 0x30,
+                0x7b, 0xd9, 0x6b, 0xb7, 0xb1, 0xae, 0x8d, 0x62, 0x31, 0x87, 0xe3, 0x9c, 0x00, 0xa4,
+                0x8c, 0x25, 0xaa, 0x9d,
+            ],
+            shared_secret: [
+                0x3a, 0x60, 0x2b, 0xaf, 0xb8, 0xa2, 0x66, 0x5a, 0x74, 0xdf, 0x34, 0xab, 0x6e, 0x3c,
+                0x48, 0x8b, 0x09, 0xe2, 0x28, 0x4e, 0xa1, 0x7d, 0x56, 0x02, 0x62, 0xe2, 0x1f, 0x7f,
+                0x3c, 0xba, 0xa3, 0x95,
+            ],
+            k_enc: [
+                0x1b, 0x6d, 0xd1, 0x03, 0x49, 0x63, 0x67, 0xc9, 0x2b, 0x36, 0x8f, 0xc2, 0xf1, 0xc6,
+                0x2e, 0x56, 0xc8, 0xc9, 0xfb, 0xe3, 0x4a, 0x35, 0x84, 0x1f, 0xe1, 0xa3, 0x70, 0x96,
+                0x43, 0xe1, 0x35, 0xe1,
+            ],
+            p_enc: [
+                0x03, 0xfb, 0x8e, 0xa2, 0xcc, 0x0a, 0xd2, 0x30, 0x91, 0x32, 0xfd, 0x11, 0x07, 0xd2,
+                0x7a, 0xc6, 0xec, 0x3c, 0x57, 0x25, 0x0b, 0x39, 0x05, 0xa4, 0xe3, 0xbd, 0x01, 0xc5,
+                0x4d, 0xf8, 0x64, 0x34, 0x43, 0xbe, 0x0f, 0x88, 0x90, 0x32, 0xea, 0x32, 0x5b, 0xf0,
+                0x71, 0x07, 0xfd, 0x41, 0xd6, 0x73, 0xee, 0xba, 0xe6, 0xfa, 0x64, 0xd0, 0x87, 0x40,
+                0x89, 0x86, 0xe7, 0x3d, 0x6e, 0x28, 0x4f, 0xea, 0x9a, 0x23, 0xc3, 0x93, 0x11, 0x78,
+                0x2f, 0x86, 0xca, 0xbf, 0xf9, 0x45, 0x5e, 0x4c, 0xf6, 0x99, 0xe5, 0xf5, 0xd4, 0xbc,
+                0xff, 0x63, 0x7b, 0x70, 0xcc, 0x0e, 0xd3, 0xf0, 0x09, 0x58, 0xdf, 0xb8, 0xdc, 0xf0,
+                0x0e, 0x85, 0xa1, 0xd0, 0xa6, 0xa8, 0x90, 0x81, 0x40, 0xc2, 0xf4, 0x34, 0xc2, 0xe2,
+                0x60, 0xef, 0xb0, 0xbc, 0xa2, 0x00, 0x35, 0x04, 0xc9, 0x99, 0x93, 0xa9, 0xe1, 0xc0,
+                0xff, 0x9c, 0xef, 0xe6, 0xa6, 0x65, 0xd7, 0x91, 0x42, 0x86, 0x90, 0xe4, 0x7e, 0xf8,
+                0xc1, 0x31, 0xa8, 0xe9, 0xbf, 0xb4, 0xc3, 0x08, 0x02, 0x35, 0x03, 0x2d, 0x73, 0x1b,
+                0x0d, 0x38, 0x41, 0x22, 0x5f, 0x1c, 0x11, 0xe2, 0xc2, 0x8e, 0xe8, 0x4d, 0x35, 0xf9,
+                0x22, 0x61, 0x00, 0x56, 0x59, 0x72, 0xeb, 0x26, 0x9d, 0x27, 0x8e, 0xf6, 0x49, 0x79,
+                0xbf, 0x65, 0x15, 0xed, 0x4a, 0x68, 0x40, 0xb0, 0x88, 0x3a, 0x9e, 0x6e, 0xf6, 0x4a,
+                0x0e, 0xfc, 0xae, 0x1c, 0xf2, 0x1d, 0xfe, 0x74, 0x85, 0x4e, 0x84, 0xc2, 0x74, 0x9f,
+                0xac, 0x03, 0x82, 0x52, 0x75, 0xc9, 0xb6, 0x30, 0x21, 0x84, 0xc7, 0x2d, 0xf4, 0xc4,
+                0xbb, 0x28, 0x62, 0xe4, 0xe8, 0xa7, 0xd9, 0xa4, 0xa2, 0x82, 0x86, 0x6f, 0x9a, 0x7b,
+                0x2c, 0xfc, 0x9a, 0x56, 0x31, 0x3d, 0xa0, 0xc4, 0x7a, 0x34, 0xb7, 0xb9, 0xcd, 0xa3,
+                0xac, 0xe8, 0x18, 0x5f, 0x07, 0xdf, 0x36, 0xe4, 0x48, 0xa7, 0x6a, 0xa4, 0x77, 0xf2,
+                0x24, 0xd8, 0x7a, 0x07, 0x4f, 0x43, 0xaf, 0x5d, 0x5f, 0x79, 0xb3, 0xab, 0x11, 0x28,
+                0xf0, 0x81, 0x91, 0x44, 0x7f, 0xa6, 0x46, 0xbf, 0xdd, 0xe5, 0xb5, 0x1e, 0x23, 0x3c,
+                0xa6, 0x15, 0x5d, 0x10, 0x15, 0x85, 0xbc, 0x2c, 0x40, 0x15, 0x8a, 0xc2, 0x10, 0x6e,
+                0x66, 0xa2, 0x6e, 0x46, 0x42, 0x33, 0x70, 0x63, 0x68, 0x76, 0xb4, 0x34, 0xa7, 0x4f,
+                0x8c, 0xe8, 0x06, 0x00, 0x50, 0xb0, 0x82, 0xa7, 0x9b, 0x61, 0xbb, 0x5d, 0x34, 0x4e,
+                0xb5, 0xa1, 0x15, 0x83, 0x26, 0xce, 0xd9, 0xa9, 0xd9, 0xf5, 0x4f, 0xb2, 0xfe, 0x8f,
+                0x9f, 0x05, 0xcd, 0x11, 0x1e, 0xe4, 0x6c, 0x47, 0x10, 0xf6, 0xf6, 0x3a, 0x62, 0x69,
+                0x45, 0x57, 0xef, 0x1b, 0x12, 0xc8, 0x80, 0x06, 0xb6, 0x78, 0x72, 0x50, 0x5f, 0x4e,
+                0x88, 0x3b, 0x58, 0x59, 0x07, 0x92, 0x9a, 0x2f, 0x3f, 0xdb, 0x0d, 0x8f, 0x79, 0x14,
+                0xc4, 0x2d, 0xde, 0x2d, 0x20, 0x00, 0xf5, 0xae, 0x02, 0xd4, 0x18, 0x21, 0xc8, 0xe1,
+                0xee, 0x01, 0x38, 0xeb, 0xcb, 0x72, 0x8d, 0x7c, 0x6c, 0x3c, 0x80, 0x02, 0x7e, 0x43,
+                0x75, 0x94, 0xc6, 0x70, 0xfd, 0x6f, 0x39, 0x08, 0x22, 0x2e, 0xe7, 0xa1, 0xb9, 0x17,
+                0xf8, 0x27, 0x1a, 0xbe, 0x66, 0x0e, 0x39, 0xe0, 0x51, 0xaa, 0xa6, 0xfc, 0xa1, 0x86,
+                0x22, 0x76, 0xe2, 0xba, 0xa0, 0xfe, 0x0b, 0x16, 0x2a, 0xeb, 0xcf, 0xe3, 0xd9, 0x34,
+                0x9c, 0x8d, 0x15, 0x4b, 0xb7, 0xee, 0x28, 0x21, 0x2c, 0x1b, 0xaa, 0x70, 0x5d, 0x82,
+                0x07, 0x0d, 0x70, 0x32, 0xf2, 0x69, 0x5d, 0x17, 0x96, 0x80, 0x9f, 0xab, 0x41, 0x24,
+                0x69, 0x26, 0xaf, 0x99, 0x2b, 0x6e, 0xee, 0x95, 0xa9, 0xa0, 0x6b, 0xc4, 0x56, 0x2c,
+                0x5f, 0x2f, 0x1b, 0x19, 0x54, 0x95, 0x00, 0x37, 0x2e, 0x7a, 0xd5, 0x79, 0xa6, 0xd6,
+                0xd7, 0x8b, 0x33, 0x15, 0x31, 0x30, 0xfb, 0x44, 0x8f, 0xb7, 0x9e, 0x8a, 0x66, 0x9d,
+                0xb8, 0xa0, 0xf3, 0x5c, 0xdf, 0x9a, 0xe5, 0xd3, 0x2d, 0x73, 0x2f, 0xc7, 0x94, 0x18,
+                0xe2, 0x3b, 0x45, 0x1d, 0xdc, 0x95, 0xa2, 0x2a, 0xba, 0xbb, 0x05, 0x6e, 0xc6, 0xb5,
+                0xe8, 0xba, 0x4f, 0x52, 0x4d, 0xfa, 0xfe, 0x87, 0x52, 0x62, 0xdd, 0x7b, 0xe4, 0x1c,
+                0xbb, 0xc6, 0x24, 0x20, 0xd4, 0xad, 0x6d, 0xf5, 0xc9, 0xb7, 0x13, 0x60, 0x4f, 0x65,
+                0x60, 0x88, 0xa4, 0x48, 0x5e, 0x93, 0xbe, 0x19,
+            ],
+            c_enc: [
+                0xb4, 0x15, 0x88, 0x23, 0x1d, 0x6b, 0xa2, 0x9c, 0xc5, 0xb9, 0xaa, 0xf0, 0xc1, 0xf0,
+                0xba, 0x44, 0x16, 0x6e, 0xdb, 0x8a, 0x27, 0x29, 0xca, 0xba, 0x53, 0x71, 0xe7, 0xac,
+                0x36, 0x90, 0x0f, 0xaa, 0x64, 0xf5, 0x76, 0x0d, 0xce, 0x55, 0x20, 0xda, 0x82, 0x8d,
+                0x5e, 0x25, 0xbd, 0x83, 0x51, 0x95, 0x11, 0x64, 0x12, 0x11, 0x80, 0x9d, 0xff, 0xd8,
+                0xcf, 0xeb, 0xff, 0xf3, 0xcd, 0xdc, 0xd2, 0x75, 0x88, 0x1e, 0x39, 0xb6, 0x3d, 0xac,
+                0x4d, 0x98, 0x6b, 0x10, 0xc0, 0xe4, 0xc5, 0x52, 0x63, 0xde, 0x3e, 0x02, 0x54, 0x94,
+                0x81, 0x8a, 0x38, 0x08, 0xd9, 0xab, 0xc6, 0xec, 0x38, 0x8f, 0x95, 0x26, 0x73, 0x95,
+                0x0a, 0xa2, 0xd0, 0xe4, 0xba, 0x00, 0x53, 0x75, 0xac, 0x60, 0x5d, 0xc8, 0x25, 0xde,
+                0x4d, 0xd8, 0x93, 0x8b, 0x94, 0x7f, 0xf7, 0x19, 0x4c, 0xfe, 0x7c, 0x1d, 0x79, 0xa1,
+                0x27, 0x15, 0x5d, 0x11, 0xcb, 0xe3, 0x43, 0xf3, 0x2f, 0xd1, 0x0c, 0x7d, 0xae, 0x39,
+                0x1f, 0x00, 0xb4, 0x4f, 0xbe, 0x30, 0x1c, 0x63, 0xfd, 0x4b, 0xf1, 0xc0, 0xdf, 0xb6,
+                0xc9, 0xec, 0xb4, 0xc3, 0xf3, 0xfe, 0xf5, 0x40, 0xb6, 0x7e, 0xb9, 0x23, 0x13, 0x71,
+                0x9c, 0x5a, 0x30, 0x7a, 0xd3, 0x95, 0x6b, 0xb9, 0x4e, 0x29, 0x86, 0x85, 0x2a, 0x64,
+                0x5a, 0x95, 0xd6, 0xdc, 0x75, 0xaa, 0x27, 0x4c, 0xcf, 0xd2, 0x71, 0xd0, 0xea, 0xe2,
+                0x65, 0x81, 0xf5, 0xf5, 0x5d, 0x64, 0x74, 0xaa, 0xad, 0x37, 0x4c, 0x86, 0x45, 0x05,
+                0xe6, 0x92, 0x37, 0xf6, 0x66, 0x99, 0xee, 0x39, 0xe9, 0xfc, 0xf5, 0xb1, 0xb7, 0x03,
+                0x35, 0x1e, 0x71, 0xf6, 0x3b, 0x02, 0x33, 0x40, 0x82, 0xee, 0xbe, 0xd8, 0x68, 0xb5,
+                0x61, 0x2a, 0x33, 0x95, 0x78, 0x5a, 0x33, 0x2a, 0x52, 0x43, 0xe4, 0x98, 0x6e, 0x1f,
+                0xf5, 0xb4, 0x2d, 0x06, 0x69, 0xc1, 0x5c, 0x45, 0xff, 0x81, 0xe2, 0x2e, 0xea, 0xe4,
+                0xde, 0x7d, 0x9a, 0x4f, 0x57, 0x24, 0xc8, 0x96, 0x03, 0x94, 0x92, 0x5b, 0xa1, 0xa1,
+                0x90, 0x0f, 0xa2, 0xb5, 0x59, 0x3d, 0x55, 0x45, 0x5e, 0x0b, 0xe0, 0x31, 0x8c, 0x80,
+                0x23, 0x81, 0xec, 0x9c, 0x0a, 0x83, 0xc2, 0xe5, 0xf9, 0x33, 0x9f, 0x02, 0x9c, 0x44,
+                0x24, 0x72, 0x8f, 0x91, 0x9d, 0x18, 0x4f, 0x36, 0x16, 0x50, 0xba, 0x65, 0xd6, 0x98,
+                0xa8, 0xd1, 0x67, 0xbe, 0xd9, 0xdd, 0x01, 0xfa, 0x70, 0x74, 0xe4, 0x6a, 0xf6, 0x57,
+                0x16, 0xdd, 0xd9, 0x7e, 0x7b, 0xb6, 0x00, 0x13, 0x05, 0x96, 0x8c, 0xd5, 0xb4, 0x87,
+                0x0d, 0xf2, 0x00, 0x42, 0xe7, 0x69, 0xe0, 0x2d, 0xf1, 0x8b, 0x9f, 0xde, 0x9f, 0xda,
+                0xa7, 0x6b, 0x00, 0xca, 0x26, 0x45, 0x9d, 0x54, 0x37, 0x19, 0x19, 0x72, 0xd7, 0x08,
+                0xde, 0xda, 0xbf, 0x1d, 0x61, 0x7f, 0x73, 0x3a, 0x60, 0xeb, 0xfe, 0xc6, 0xac, 0xf0,
+                0x0b, 0xb1, 0xdf, 0xbf, 0x11, 0x2d, 0x3a, 0xaa, 0xc9, 0xfb, 0xd2, 0x30, 0xcc, 0xaa,
+                0x9c, 0xf3, 0x58, 0x45, 0x93, 0x54, 0xac, 0x5b, 0x29, 0xbd, 0xb7, 0x3a, 0x45, 0x27,
+                0x1b, 0x1f, 0x9e, 0xd0, 0x0e, 0x3e, 0x20, 0xb1, 0x2f, 0xed, 0x5c, 0xd5, 0x6a, 0xbb,
+                0xb0, 0xb9, 0x4a, 0x9e, 0xee, 0x5f, 0xf8, 0xf9, 0x36, 0x1d, 0xfd, 0x6c, 0x94, 0x08,
+                0x5d, 0x28, 0x98, 0xe5, 0x46, 0xeb, 0x92, 0xe6, 0xdb, 0xe9, 0xf0, 0x2e, 0xb5, 0xbf,
+                0x7d, 0x12, 0x67, 0x5d, 0x3c, 0x6a, 0xc7, 0x18, 0x4b, 0x26, 0x01, 0xe4, 0xf4, 0x05,
+                0x37, 0x3a, 0x4f, 0x1c, 0x5d, 0xf7, 0x6b, 0x3c, 0xb5, 0x29, 0x99, 0xd8, 0x0f, 0x59,
+                0xb3, 0x94, 0xbc, 0xed, 0x9f, 0x66, 0xbc, 0xf7, 0xdc, 0x37, 0xc2, 0xb4, 0xc6, 0xf7,
+                0x74, 0x5b, 0xc6, 0xf0, 0x37, 0x74, 0xfa, 0xc6, 0x24, 0x5d, 0x7c, 0x63, 0x6d, 0xfc,
+                0x5f, 0x76, 0x58, 0xb2, 0xd2, 0xfd, 0x84, 0xac, 0xa9, 0xe0, 0xef, 0xcd, 0xe0, 0x09,
+                0x3e, 0x62, 0x29, 0x38, 0xb7, 0x5d, 0xae, 0x66, 0xcf, 0x63, 0xf6, 0xd2, 0x35, 0x17,
+                0x2e, 0x5a, 0x0b, 0xbe, 0xcd, 0x15, 0x56, 0x6c, 0x61, 0xfe, 0x5a, 0x58, 0x94, 0x7c,
+                0x18, 0xb9, 0xb5, 0xa1, 0x27, 0x29, 0x4b, 0x67, 0x67, 0xd0, 0x2b, 0x0f, 0x66, 0x4c,
+                0xef, 0x25, 0x8e, 0x26, 0x11, 0x1c, 0xf0, 0x9c, 0x9b, 0x61, 0xd4, 0x41, 0x52, 0x8d,
+                0x8c, 0xa2, 0xd8, 0x00, 0x5c, 0xad, 0x2a, 0xe4, 0x16, 0xe3, 0x4b, 0xb2, 0x6b, 0x41,
+                0xa1, 0x85, 0x5a, 0xf9, 0x90, 0xcd, 0xb6, 0x77, 0xaf, 0x0d,
+            ],
+            ock: [
+                0x67, 0x1c, 0xed, 0xd6, 0xf5, 0x73, 0xa4, 0x6f, 0xf1, 0xea, 0xd0, 0x48, 0x21, 0x98,
+                0x56, 0x36, 0xe2, 0x3f, 0xb1, 0x5c, 0x6f, 0x48, 0x05, 0xfd, 0x57, 0x63, 0x12, 0xc2,
+                0x07, 0x02, 0xa4, 0x24,
+            ],
+            op: [
+                0xcc, 0x18, 0xe4, 0xb6, 0x5f, 0x89, 0x34, 0x06, 0x31, 0x5d, 0xb7, 0x1f, 0xac, 0x06,
+                0x5d, 0x71, 0xd0, 0xea, 0xba, 0x7c, 0xf3, 0xc2, 0xba, 0x94, 0x77, 0x12, 0x32, 0x75,
+                0x43, 0x4b, 0x1e, 0xb0, 0xaa, 0x84, 0x16, 0x79, 0xd4, 0xd2, 0x40, 0xb0, 0xab, 0xc4,
+                0xa5, 0xd8, 0x9a, 0xa8, 0xd6, 0xb3, 0xb0, 0x86, 0x92, 0x23, 0xed, 0x76, 0x3b, 0x67,
+                0x6a, 0x72, 0xcb, 0x74, 0xfb, 0x18, 0xd1, 0x17,
+            ],
+            c_out: [
+                0x59, 0x97, 0x53, 0xe4, 0x0a, 0xda, 0xea, 0xff, 0x6f, 0xaa, 0xf5, 0xa6, 0xf3, 0x0e,
+                0x39, 0x13, 0x8f, 0xde, 0x82, 0x0f, 0x7b, 0xec, 0x7c, 0x8d, 0x0f, 0xd8, 0x4b, 0x48,
+                0x36, 0x94, 0xe5, 0x0c, 0x4b, 0xdd, 0xee, 0x2f, 0xb1, 0xa4, 0xf9, 0x95, 0xb1, 0xa3,
+                0xba, 0x40, 0xf4, 0x66, 0xb4, 0x2e, 0x8b, 0x5d, 0x01, 0x38, 0xfd, 0x30, 0xbf, 0xf6,
+                0xae, 0x8c, 0xb1, 0x55, 0xf4, 0x0c, 0xdc, 0x37, 0x39, 0xfa, 0xbf, 0x2f, 0x00, 0xda,
+                0x3a, 0xc6, 0xa7, 0x36, 0x3b, 0xc2, 0xf4, 0xaa, 0x10, 0xfe,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xb4, 0x9e, 0x3c, 0x5b, 0xb9, 0x9e, 0x47, 0xc5, 0x3d, 0x6e, 0x5c, 0x34, 0x7c, 0x99,
+                0x8f, 0x30, 0x2d, 0x3f, 0xf4, 0x75, 0x23, 0xe7, 0xc3, 0xd7, 0xb6, 0x4c, 0x82, 0x98,
+                0xdc, 0x7b, 0x10, 0xe9, 0x54, 0xdf, 0x06, 0x00, 0x0b, 0xc0, 0xcc, 0x30, 0xec, 0xf6,
+                0x75, 0x5d, 0x92, 0x7e, 0xee, 0xce, 0xe6, 0xec, 0x9e, 0x8e, 0x0c, 0xba, 0xa3, 0x1b,
+                0x71, 0xe0, 0xa4, 0x33, 0x4a, 0xd6, 0x42, 0x1b,
+            ],
+            ovk: [
+                0x97, 0x9f, 0x06, 0x58, 0x66, 0x73, 0xbc, 0x6f, 0xf1, 0xc5, 0xd3, 0xb3, 0x20, 0xf3,
+                0x49, 0xa5, 0xb3, 0xa8, 0xb3, 0x55, 0x59, 0x22, 0x96, 0xaa, 0xf6, 0x1c, 0x5b, 0x72,
+                0x52, 0xf7, 0x3e, 0xc0,
+            ],
+            default_d: [
+                0x8d, 0xb1, 0x31, 0xa6, 0x5b, 0xa6, 0xca, 0x91, 0xc9, 0xe9, 0x7b,
+            ],
+            default_pk_d: [
+                0x6f, 0xce, 0x26, 0xab, 0xe6, 0xc0, 0xb6, 0x84, 0x37, 0x36, 0x96, 0x46, 0xee, 0xe1,
+                0xe9, 0xdc, 0xa5, 0x1a, 0x42, 0x58, 0xf3, 0xae, 0x72, 0x23, 0x87, 0xf6, 0xd0, 0xdf,
+                0xf4, 0x1a, 0x1f, 0x88,
+            ],
+            v: 5531329397987978327,
+            rseed: [
+                0x1f, 0xbd, 0x83, 0xd5, 0x4a, 0xaf, 0x44, 0x1e, 0x31, 0x9e, 0xa4, 0x7a, 0x86, 0x2a,
+                0xd0, 0x29, 0x3c, 0xed, 0xf5, 0xdd, 0x9e, 0xda, 0xde, 0xee, 0x33, 0xcb, 0x52, 0x2c,
+                0xd0, 0x11, 0x8b, 0xbd,
+            ],
+            asset: [
+                0xc3, 0xcc, 0x4f, 0x43, 0xfa, 0x01, 0x88, 0x52, 0x1b, 0xc6, 0x1b, 0x21, 0xdd, 0x04,
+                0xe3, 0x7a, 0x83, 0xec, 0xe6, 0x8c, 0xa7, 0xa2, 0xfa, 0x6c, 0x8f, 0x9e, 0x34, 0xa6,
+                0x29, 0x03, 0x35, 0xaa,
+            ],
+            memo: [
+                0xff, 0x81, 0x1a, 0xce, 0x9a, 0x23, 0xbd, 0xa3, 0x9a, 0xba, 0x72, 0xf1, 0x56, 0x6f,
+                0xc1, 0x68, 0x84, 0x97, 0xd2, 0xa7, 0x92, 0x8c, 0x36, 0x70, 0x15, 0x25, 0x67, 0x8b,
+                0xc9, 0x72, 0x14, 0xb3, 0x1b, 0x37, 0xba, 0xb4, 0x6b, 0x88, 0xf2, 0x7f, 0x04, 0x48,
+                0xde, 0xcb, 0x31, 0x62, 0x2d, 0x0f, 0x0f, 0x87, 0xa8, 0x55, 0xba, 0x54, 0x00, 0x03,
+                0x32, 0x03, 0x1f, 0x73, 0xab, 0xff, 0xd4, 0x65, 0x91, 0xda, 0x0b, 0x88, 0x72, 0x35,
+                0x04, 0xed, 0xb2, 0x33, 0x72, 0x30, 0xda, 0xd2, 0xac, 0xc0, 0xd8, 0xbb, 0x68, 0xbc,
+                0x83, 0x7a, 0x2f, 0xf9, 0x30, 0xbf, 0xf0, 0x6f, 0xde, 0x74, 0xeb, 0x90, 0xaa, 0xe4,
+                0xf6, 0x0d, 0xbb, 0x6e, 0xb8, 0x27, 0xea, 0x99, 0x88, 0x4a, 0xcd, 0x62, 0x85, 0xa9,
+                0x88, 0x92, 0x80, 0x2c, 0xf5, 0x9d, 0x5d, 0x60, 0xd0, 0x16, 0x63, 0x38, 0x7b, 0x3e,
+                0xd2, 0x72, 0x3b, 0xd6, 0x48, 0x9e, 0x9c, 0x2c, 0x10, 0x6d, 0x4a, 0xa2, 0xde, 0x23,
+                0xce, 0xd1, 0x6c, 0x72, 0x04, 0x29, 0xc7, 0x75, 0x3a, 0x77, 0x38, 0xec, 0x7d, 0x9d,
+                0xb8, 0x62, 0x42, 0x29, 0xed, 0xd2, 0x17, 0xb8, 0x0d, 0x74, 0x87, 0x5a, 0x14, 0xca,
+                0xe4, 0x86, 0x3f, 0x13, 0x9e, 0x9c, 0x0b, 0x13, 0x1b, 0x2a, 0x4c, 0x28, 0x07, 0x1a,
+                0x38, 0xec, 0x61, 0xf6, 0x68, 0x01, 0xaa, 0x59, 0x56, 0xfc, 0xb2, 0xa4, 0x6b, 0x95,
+                0x87, 0x66, 0x5b, 0x75, 0x71, 0xaa, 0x03, 0x48, 0x1f, 0xd8, 0xd9, 0xd5, 0x69, 0x8f,
+                0x83, 0x6f, 0xc8, 0x63, 0x5e, 0x69, 0xe3, 0xbd, 0xe4, 0x2f, 0x4a, 0xc0, 0x71, 0x32,
+                0x8b, 0x54, 0x09, 0xf6, 0xe4, 0x2d, 0x79, 0x0a, 0xed, 0xd7, 0x3b, 0xc1, 0xa2, 0x35,
+                0x47, 0x23, 0xb3, 0xb8, 0x19, 0xd0, 0x63, 0x7a, 0x6f, 0xa4, 0x66, 0x39, 0x46, 0xa3,
+                0x0a, 0xc5, 0xaf, 0xdd, 0x30, 0xce, 0x83, 0x0f, 0x67, 0x91, 0xb4, 0x57, 0x52, 0x70,
+                0xa1, 0x72, 0x0f, 0x91, 0x86, 0x6e, 0x2b, 0x86, 0xf4, 0x78, 0x88, 0x94, 0xc8, 0xda,
+                0x62, 0xd8, 0xb9, 0x1f, 0xaf, 0x52, 0x0e, 0x3b, 0xed, 0xbc, 0x12, 0x06, 0xa5, 0xa5,
+                0xe6, 0xef, 0xd3, 0xdf, 0xde, 0x08, 0x43, 0xc3, 0xb0, 0x67, 0x57, 0x64, 0x3f, 0xc0,
+                0x06, 0x00, 0x88, 0x38, 0xca, 0x47, 0x30, 0x87, 0xf8, 0x97, 0x79, 0x18, 0xcc, 0x1b,
+                0x81, 0xc9, 0xe6, 0x8e, 0x3b, 0x88, 0x8f, 0xe6, 0xf7, 0xc6, 0x30, 0xf1, 0xbc, 0x7a,
+                0xe1, 0x88, 0xf5, 0x12, 0x84, 0x20, 0x41, 0xca, 0xda, 0x1e, 0x05, 0xf8, 0x66, 0xd2,
+                0x56, 0x2d, 0xbe, 0x09, 0xc4, 0xb4, 0x30, 0x68, 0xf7, 0x54, 0xda, 0xd3, 0x4d, 0xf0,
+                0xfc, 0xfc, 0x18, 0x1f, 0x31, 0x80, 0x1a, 0x79, 0x92, 0xd2, 0xf1, 0x6b, 0xe0, 0x21,
+                0x1b, 0x4a, 0x22, 0xf6, 0x2a, 0xab, 0x64, 0x70, 0x1b, 0xf4, 0xa4, 0xe6, 0xd6, 0x66,
+                0xfc, 0x30, 0x4a, 0x5c, 0x79, 0xc6, 0x09, 0xac, 0xc4, 0x3b, 0x00, 0xb4, 0x86, 0x48,
+                0x93, 0xd3, 0x7d, 0x50, 0x07, 0xf0, 0xc3, 0x29, 0xa4, 0x75, 0x50, 0x52, 0x57, 0x75,
+                0x70, 0xdd, 0x38, 0xfa, 0xc0, 0x43, 0xcd, 0x91, 0xc1, 0x2e, 0xe3, 0x4e, 0x9c, 0xfa,
+                0xe3, 0x92, 0xa7, 0x8b, 0xda, 0xbd, 0x4e, 0xe3, 0x1d, 0xc0, 0xde, 0xb0, 0x2f, 0xe7,
+                0xb1, 0xd8, 0xb0, 0x17, 0x8a, 0xc9, 0x51, 0x31, 0x05, 0xfc, 0xc7, 0xe3, 0x0b, 0xa8,
+                0xe0, 0x16, 0xaa, 0x36, 0xa6, 0xb5, 0xdf, 0x5e, 0x5a, 0x19, 0x09, 0xf6, 0x3a, 0xba,
+                0x09, 0x5d, 0x98, 0x77, 0xa8, 0xf2, 0xdc, 0x53, 0xf4, 0x6f, 0x6c, 0x9b, 0x07, 0xad,
+                0xdf, 0x14, 0x6f, 0x4f, 0xfa, 0x50, 0x1f, 0x9d, 0xd3, 0xcf, 0xf9, 0x24, 0xe3, 0x01,
+                0x0f, 0xaf, 0x50, 0x4e, 0x2b, 0x8a, 0xca, 0x73,
+            ],
+            cv_net: [
+                0x1a, 0xa2, 0x3d, 0x96, 0x79, 0xbc, 0x66, 0x04, 0xb6, 0x25, 0x2c, 0x4f, 0x48, 0x1b,
+                0x3a, 0x2a, 0xf5, 0x46, 0x32, 0xf8, 0x30, 0x08, 0x14, 0x68, 0x29, 0x65, 0x94, 0x5e,
+                0x7e, 0x33, 0x2a, 0x0d,
+            ],
+            rho: [
+                0x09, 0x1d, 0x83, 0x73, 0x3a, 0x9f, 0xfb, 0x18, 0xc1, 0x7a, 0xd1, 0x93, 0x8d, 0xd2,
+                0x67, 0x93, 0xc3, 0xfe, 0xfa, 0xda, 0xee, 0xa8, 0xe2, 0x3c, 0x44, 0xd5, 0xe0, 0x18,
+                0x4b, 0xc8, 0x45, 0x10,
+            ],
+            cmx: [
+                0x76, 0xf1, 0xbd, 0x50, 0xf9, 0xb9, 0x06, 0xcb, 0x9f, 0xf2, 0xdd, 0x91, 0x8a, 0x36,
+                0x7e, 0x5f, 0xb1, 0xa2, 0xef, 0x39, 0xf1, 0x4f, 0x6c, 0xe9, 0x4f, 0xf9, 0xf0, 0x91,
+                0x55, 0xf8, 0xc2, 0x11,
+            ],
+            esk: [
+                0x2f, 0x98, 0x2d, 0xec, 0xa7, 0x60, 0x51, 0x41, 0xd9, 0xc9, 0xa1, 0xe6, 0xfb, 0x57,
+                0xe2, 0xb8, 0x01, 0xb4, 0x49, 0x6f, 0xbd, 0xd4, 0xc0, 0xa8, 0xb9, 0x5f, 0xc8, 0x7e,
+                0xa7, 0x37, 0x3e, 0x2f,
+            ],
+            ephemeral_key: [
+                0xda, 0x72, 0x84, 0xa0, 0xe0, 0xde, 0x52, 0x09, 0x3c, 0xc2, 0xe1, 0x9c, 0x0a, 0xf1,
+                0x93, 0xbd, 0xb4, 0x2c, 0x80, 0xc9, 0xc7, 0xf9, 0xf2, 0x36, 0x00, 0xe6, 0x08, 0x01,
+                0x72, 0xc5, 0xf5, 0x39,
+            ],
+            shared_secret: [
+                0x9b, 0xcf, 0xb9, 0x6f, 0x4c, 0xf1, 0x83, 0xc1, 0x7f, 0xb1, 0x99, 0xda, 0x16, 0x5f,
+                0xbf, 0x8a, 0x47, 0x47, 0x7e, 0x00, 0x36, 0x6d, 0x1c, 0xb7, 0x3b, 0x32, 0xec, 0x0e,
+                0x3a, 0xc1, 0x98, 0x0f,
+            ],
+            k_enc: [
+                0x21, 0xe0, 0x97, 0x87, 0x0a, 0xee, 0xc0, 0x19, 0x76, 0x86, 0xee, 0x37, 0x22, 0x78,
+                0xfe, 0x4a, 0xa2, 0x23, 0x8d, 0x87, 0x65, 0x32, 0x63, 0x84, 0x8a, 0x2f, 0xf5, 0x27,
+                0x9f, 0x2b, 0x1d, 0x9b,
+            ],
+            p_enc: [
+                0x03, 0x8d, 0xb1, 0x31, 0xa6, 0x5b, 0xa6, 0xca, 0x91, 0xc9, 0xe9, 0x7b, 0x57, 0xac,
+                0xbf, 0xfe, 0xc7, 0x3a, 0xc3, 0x4c, 0x1f, 0xbd, 0x83, 0xd5, 0x4a, 0xaf, 0x44, 0x1e,
+                0x31, 0x9e, 0xa4, 0x7a, 0x86, 0x2a, 0xd0, 0x29, 0x3c, 0xed, 0xf5, 0xdd, 0x9e, 0xda,
+                0xde, 0xee, 0x33, 0xcb, 0x52, 0x2c, 0xd0, 0x11, 0x8b, 0xbd, 0xc3, 0xcc, 0x4f, 0x43,
+                0xfa, 0x01, 0x88, 0x52, 0x1b, 0xc6, 0x1b, 0x21, 0xdd, 0x04, 0xe3, 0x7a, 0x83, 0xec,
+                0xe6, 0x8c, 0xa7, 0xa2, 0xfa, 0x6c, 0x8f, 0x9e, 0x34, 0xa6, 0x29, 0x03, 0x35, 0xaa,
+                0xff, 0x81, 0x1a, 0xce, 0x9a, 0x23, 0xbd, 0xa3, 0x9a, 0xba, 0x72, 0xf1, 0x56, 0x6f,
+                0xc1, 0x68, 0x84, 0x97, 0xd2, 0xa7, 0x92, 0x8c, 0x36, 0x70, 0x15, 0x25, 0x67, 0x8b,
+                0xc9, 0x72, 0x14, 0xb3, 0x1b, 0x37, 0xba, 0xb4, 0x6b, 0x88, 0xf2, 0x7f, 0x04, 0x48,
+                0xde, 0xcb, 0x31, 0x62, 0x2d, 0x0f, 0x0f, 0x87, 0xa8, 0x55, 0xba, 0x54, 0x00, 0x03,
+                0x32, 0x03, 0x1f, 0x73, 0xab, 0xff, 0xd4, 0x65, 0x91, 0xda, 0x0b, 0x88, 0x72, 0x35,
+                0x04, 0xed, 0xb2, 0x33, 0x72, 0x30, 0xda, 0xd2, 0xac, 0xc0, 0xd8, 0xbb, 0x68, 0xbc,
+                0x83, 0x7a, 0x2f, 0xf9, 0x30, 0xbf, 0xf0, 0x6f, 0xde, 0x74, 0xeb, 0x90, 0xaa, 0xe4,
+                0xf6, 0x0d, 0xbb, 0x6e, 0xb8, 0x27, 0xea, 0x99, 0x88, 0x4a, 0xcd, 0x62, 0x85, 0xa9,
+                0x88, 0x92, 0x80, 0x2c, 0xf5, 0x9d, 0x5d, 0x60, 0xd0, 0x16, 0x63, 0x38, 0x7b, 0x3e,
+                0xd2, 0x72, 0x3b, 0xd6, 0x48, 0x9e, 0x9c, 0x2c, 0x10, 0x6d, 0x4a, 0xa2, 0xde, 0x23,
+                0xce, 0xd1, 0x6c, 0x72, 0x04, 0x29, 0xc7, 0x75, 0x3a, 0x77, 0x38, 0xec, 0x7d, 0x9d,
+                0xb8, 0x62, 0x42, 0x29, 0xed, 0xd2, 0x17, 0xb8, 0x0d, 0x74, 0x87, 0x5a, 0x14, 0xca,
+                0xe4, 0x86, 0x3f, 0x13, 0x9e, 0x9c, 0x0b, 0x13, 0x1b, 0x2a, 0x4c, 0x28, 0x07, 0x1a,
+                0x38, 0xec, 0x61, 0xf6, 0x68, 0x01, 0xaa, 0x59, 0x56, 0xfc, 0xb2, 0xa4, 0x6b, 0x95,
+                0x87, 0x66, 0x5b, 0x75, 0x71, 0xaa, 0x03, 0x48, 0x1f, 0xd8, 0xd9, 0xd5, 0x69, 0x8f,
+                0x83, 0x6f, 0xc8, 0x63, 0x5e, 0x69, 0xe3, 0xbd, 0xe4, 0x2f, 0x4a, 0xc0, 0x71, 0x32,
+                0x8b, 0x54, 0x09, 0xf6, 0xe4, 0x2d, 0x79, 0x0a, 0xed, 0xd7, 0x3b, 0xc1, 0xa2, 0x35,
+                0x47, 0x23, 0xb3, 0xb8, 0x19, 0xd0, 0x63, 0x7a, 0x6f, 0xa4, 0x66, 0x39, 0x46, 0xa3,
+                0x0a, 0xc5, 0xaf, 0xdd, 0x30, 0xce, 0x83, 0x0f, 0x67, 0x91, 0xb4, 0x57, 0x52, 0x70,
+                0xa1, 0x72, 0x0f, 0x91, 0x86, 0x6e, 0x2b, 0x86, 0xf4, 0x78, 0x88, 0x94, 0xc8, 0xda,
+                0x62, 0xd8, 0xb9, 0x1f, 0xaf, 0x52, 0x0e, 0x3b, 0xed, 0xbc, 0x12, 0x06, 0xa5, 0xa5,
+                0xe6, 0xef, 0xd3, 0xdf, 0xde, 0x08, 0x43, 0xc3, 0xb0, 0x67, 0x57, 0x64, 0x3f, 0xc0,
+                0x06, 0x00, 0x88, 0x38, 0xca, 0x47, 0x30, 0x87, 0xf8, 0x97, 0x79, 0x18, 0xcc, 0x1b,
+                0x81, 0xc9, 0xe6, 0x8e, 0x3b, 0x88, 0x8f, 0xe6, 0xf7, 0xc6, 0x30, 0xf1, 0xbc, 0x7a,
+                0xe1, 0x88, 0xf5, 0x12, 0x84, 0x20, 0x41, 0xca, 0xda, 0x1e, 0x05, 0xf8, 0x66, 0xd2,
+                0x56, 0x2d, 0xbe, 0x09, 0xc4, 0xb4, 0x30, 0x68, 0xf7, 0x54, 0xda, 0xd3, 0x4d, 0xf0,
+                0xfc, 0xfc, 0x18, 0x1f, 0x31, 0x80, 0x1a, 0x79, 0x92, 0xd2, 0xf1, 0x6b, 0xe0, 0x21,
+                0x1b, 0x4a, 0x22, 0xf6, 0x2a, 0xab, 0x64, 0x70, 0x1b, 0xf4, 0xa4, 0xe6, 0xd6, 0x66,
+                0xfc, 0x30, 0x4a, 0x5c, 0x79, 0xc6, 0x09, 0xac, 0xc4, 0x3b, 0x00, 0xb4, 0x86, 0x48,
+                0x93, 0xd3, 0x7d, 0x50, 0x07, 0xf0, 0xc3, 0x29, 0xa4, 0x75, 0x50, 0x52, 0x57, 0x75,
+                0x70, 0xdd, 0x38, 0xfa, 0xc0, 0x43, 0xcd, 0x91, 0xc1, 0x2e, 0xe3, 0x4e, 0x9c, 0xfa,
+                0xe3, 0x92, 0xa7, 0x8b, 0xda, 0xbd, 0x4e, 0xe3, 0x1d, 0xc0, 0xde, 0xb0, 0x2f, 0xe7,
+                0xb1, 0xd8, 0xb0, 0x17, 0x8a, 0xc9, 0x51, 0x31, 0x05, 0xfc, 0xc7, 0xe3, 0x0b, 0xa8,
+                0xe0, 0x16, 0xaa, 0x36, 0xa6, 0xb5, 0xdf, 0x5e, 0x5a, 0x19, 0x09, 0xf6, 0x3a, 0xba,
+                0x09, 0x5d, 0x98, 0x77, 0xa8, 0xf2, 0xdc, 0x53, 0xf4, 0x6f, 0x6c, 0x9b, 0x07, 0xad,
+                0xdf, 0x14, 0x6f, 0x4f, 0xfa, 0x50, 0x1f, 0x9d, 0xd3, 0xcf, 0xf9, 0x24, 0xe3, 0x01,
+                0x0f, 0xaf, 0x50, 0x4e, 0x2b, 0x8a, 0xca, 0x73,
+            ],
+            c_enc: [
+                0x13, 0xd7, 0xdf, 0xcd, 0x1d, 0x75, 0x4d, 0xcd, 0x16, 0x52, 0x32, 0x83, 0x8f, 0x14,
+                0xdd, 0x80, 0x5e, 0x12, 0xcc, 0x7e, 0x75, 0x15, 0x43, 0xd2, 0xa6, 0x8e, 0x23, 0x7a,
+                0x92, 0x3b, 0xce, 0xeb, 0xa3, 0x5a, 0x62, 0x43, 0xc6, 0xa4, 0xc5, 0xf0, 0xd2, 0xa4,
+                0xc3, 0x86, 0x07, 0xa6, 0xf1, 0x1b, 0x17, 0xfd, 0xd6, 0xc6, 0x92, 0x66, 0xf2, 0xc9,
+                0x6a, 0xdc, 0x44, 0x6f, 0x2e, 0x2d, 0x07, 0x3e, 0xe9, 0xea, 0xe2, 0x9a, 0x37, 0xef,
+                0x5d, 0x03, 0xf6, 0x78, 0xf5, 0x56, 0x29, 0x45, 0xb2, 0x08, 0x27, 0x76, 0xce, 0x9f,
+                0x39, 0x08, 0x87, 0x3a, 0x99, 0xa6, 0xa2, 0x8b, 0xae, 0xdc, 0x7f, 0x54, 0x89, 0xce,
+                0x4b, 0x30, 0xd8, 0x43, 0x66, 0xc5, 0x46, 0xb4, 0x36, 0x67, 0x91, 0x44, 0xf9, 0x27,
+                0xf7, 0x1c, 0x65, 0x09, 0x69, 0xda, 0x22, 0x42, 0x28, 0x5a, 0x86, 0x27, 0x96, 0x54,
+                0x89, 0xb7, 0x0b, 0x35, 0x6c, 0xf7, 0x4e, 0x07, 0x8a, 0xa2, 0x7d, 0xa8, 0xf9, 0x2f,
+                0xb3, 0x09, 0x57, 0x12, 0x62, 0xf2, 0xd4, 0xc3, 0x36, 0xf7, 0x12, 0x15, 0x9b, 0x3e,
+                0x9b, 0x43, 0x24, 0x38, 0x5b, 0xb3, 0x26, 0x2a, 0xc5, 0xf3, 0x13, 0x57, 0xaf, 0x9e,
+                0x1a, 0xaa, 0x75, 0xd0, 0x1c, 0x06, 0x31, 0xbf, 0xdd, 0x34, 0xc5, 0x9b, 0x27, 0xd5,
+                0x3b, 0xeb, 0xf1, 0xaa, 0x54, 0xe9, 0xc4, 0xaa, 0x98, 0x0f, 0x24, 0x7b, 0xf4, 0x22,
+                0xa0, 0xe6, 0xdb, 0xf5, 0x54, 0x6e, 0xdc, 0x10, 0x0f, 0xce, 0x6c, 0xce, 0xc8, 0x32,
+                0x7e, 0xb4, 0x8a, 0x9a, 0x39, 0xe4, 0xc2, 0xa9, 0x12, 0xb2, 0x98, 0x85, 0xe0, 0xc3,
+                0xe7, 0x33, 0x55, 0x58, 0xbd, 0x85, 0x84, 0x38, 0xd0, 0x35, 0xd2, 0xf2, 0xbe, 0x1d,
+                0x35, 0x66, 0xe4, 0x22, 0xfe, 0x37, 0xc0, 0xcb, 0x2e, 0x05, 0x8d, 0xad, 0x8c, 0xc6,
+                0x45, 0x62, 0xa5, 0x50, 0x1b, 0x54, 0xa4, 0x4f, 0x9a, 0x77, 0x77, 0xc6, 0xd2, 0x77,
+                0x04, 0xa4, 0xce, 0xad, 0x26, 0xa1, 0xc2, 0x56, 0x01, 0x8d, 0xc1, 0xbb, 0xfa, 0x58,
+                0x84, 0xa0, 0x6c, 0xc7, 0x25, 0x23, 0xaf, 0xfb, 0x43, 0xf5, 0xc5, 0xbc, 0x2f, 0x1d,
+                0x36, 0x04, 0x0f, 0x85, 0xf7, 0xe8, 0xc0, 0x62, 0xc1, 0xf2, 0x26, 0x50, 0x9d, 0x20,
+                0xf9, 0xa4, 0x88, 0x5e, 0x15, 0x70, 0x4f, 0x73, 0x01, 0xdf, 0x60, 0x3d, 0xa1, 0xfc,
+                0x5b, 0xca, 0x84, 0xf8, 0x55, 0xc1, 0x17, 0xcb, 0x30, 0x55, 0xc5, 0x70, 0x83, 0x45,
+                0x7e, 0x1d, 0x14, 0x85, 0x7c, 0x2b, 0xf9, 0x41, 0xe8, 0x20, 0x73, 0x5c, 0x58, 0x8a,
+                0xae, 0x6f, 0x66, 0x45, 0xdc, 0x3f, 0xbd, 0x30, 0x65, 0xab, 0xa1, 0x7f, 0xd2, 0x48,
+                0x2a, 0x1b, 0x37, 0xb2, 0xf3, 0x88, 0x07, 0x5e, 0x46, 0xbb, 0x9d, 0x37, 0x27, 0xcc,
+                0x73, 0xdb, 0xae, 0x0e, 0x96, 0xa8, 0x44, 0x5f, 0xda, 0x8f, 0x87, 0x64, 0xf9, 0x68,
+                0x0b, 0xf6, 0xc5, 0x91, 0xa8, 0x48, 0x10, 0xfa, 0x0c, 0x1b, 0x5a, 0x2f, 0x2a, 0xa9,
+                0xad, 0xbb, 0x88, 0x64, 0x22, 0x31, 0x72, 0x1e, 0xd6, 0xea, 0x12, 0x16, 0xab, 0x9b,
+                0xfa, 0x0e, 0x12, 0x4c, 0xe4, 0x74, 0x94, 0x44, 0x53, 0x4d, 0x68, 0x70, 0x19, 0x74,
+                0x60, 0xf7, 0x49, 0xef, 0xb0, 0x28, 0x8f, 0x96, 0x28, 0x3f, 0xc9, 0x37, 0xef, 0xbb,
+                0x14, 0x59, 0xaa, 0x73, 0xc2, 0x7b, 0x6b, 0x2b, 0x5c, 0x57, 0x7d, 0x46, 0x60, 0xf9,
+                0x8e, 0x81, 0x8c, 0xaa, 0xad, 0xbe, 0x45, 0x4e, 0xcd, 0x16, 0xc1, 0xd8, 0xa9, 0x9b,
+                0x77, 0x97, 0x8e, 0x93, 0xd6, 0x9d, 0xcb, 0x8b, 0xf0, 0xe8, 0x4a, 0x0a, 0x91, 0x3f,
+                0x55, 0xcc, 0x16, 0x50, 0xc2, 0xb9, 0x2d, 0x4c, 0x9d, 0xcd, 0xb1, 0x2e, 0xe2, 0x36,
+                0x7e, 0xd9, 0x79, 0xb9, 0x53, 0x5f, 0xe1, 0x5c, 0x87, 0xd1, 0x7f, 0x37, 0xa3, 0x24,
+                0x84, 0x7f, 0x16, 0x45, 0x39, 0x75, 0x7d, 0x83, 0x00, 0x87, 0xf6, 0x39, 0xeb, 0x6c,
+                0x3e, 0xfb, 0x8d, 0xa4, 0xff, 0xa5, 0xd7, 0xca, 0x58, 0x34, 0x4d, 0x65, 0x81, 0x76,
+                0x64, 0xa7, 0x4e, 0xaf, 0xa1, 0xa4, 0x7f, 0x69, 0xf1, 0xc8, 0x10, 0x6b, 0x6f, 0x5f,
+                0x96, 0x4f, 0x4c, 0x73, 0xed, 0xed, 0xb1, 0xe1, 0x25, 0xde, 0xb2, 0x28, 0xc5, 0x62,
+                0xfd, 0xc1, 0x87, 0x41, 0x41, 0xa9, 0x7c, 0x62, 0x58, 0x16, 0xc0, 0xcf, 0xeb, 0x83,
+                0x84, 0x28, 0x7f, 0x6b, 0x2d, 0x5f, 0xa1, 0x81, 0x89, 0xe1, 0x4f, 0x91, 0xdf, 0x72,
+                0x4e, 0x59, 0x80, 0x45, 0x8c, 0x51, 0xfb, 0x1c, 0xd8, 0x46,
+            ],
+            ock: [
+                0x57, 0x97, 0xef, 0x48, 0x70, 0xb0, 0x86, 0x50, 0xfa, 0x99, 0xad, 0xae, 0x58, 0x85,
+                0x19, 0x9e, 0x3b, 0x04, 0x4b, 0x2a, 0x0a, 0x8c, 0xe1, 0x61, 0x43, 0x42, 0xb5, 0xdc,
+                0xb2, 0x8e, 0x6e, 0x09,
+            ],
+            op: [
+                0x6f, 0xce, 0x26, 0xab, 0xe6, 0xc0, 0xb6, 0x84, 0x37, 0x36, 0x96, 0x46, 0xee, 0xe1,
+                0xe9, 0xdc, 0xa5, 0x1a, 0x42, 0x58, 0xf3, 0xae, 0x72, 0x23, 0x87, 0xf6, 0xd0, 0xdf,
+                0xf4, 0x1a, 0x1f, 0x88, 0x2f, 0x98, 0x2d, 0xec, 0xa7, 0x60, 0x51, 0x41, 0xd9, 0xc9,
+                0xa1, 0xe6, 0xfb, 0x57, 0xe2, 0xb8, 0x01, 0xb4, 0x49, 0x6f, 0xbd, 0xd4, 0xc0, 0xa8,
+                0xb9, 0x5f, 0xc8, 0x7e, 0xa7, 0x37, 0x3e, 0x2f,
+            ],
+            c_out: [
+                0xb8, 0xb4, 0x6c, 0x7e, 0xc4, 0xa8, 0x74, 0x2a, 0x22, 0xd3, 0xcd, 0x11, 0x74, 0x1c,
+                0x23, 0x04, 0x22, 0x1c, 0xa5, 0x97, 0x29, 0x4e, 0x08, 0xa4, 0xc7, 0x1b, 0x17, 0xc7,
+                0x26, 0x5d, 0x4d, 0xa7, 0x7c, 0xfe, 0x84, 0xb8, 0x7e, 0x76, 0xed, 0xaa, 0xec, 0xc2,
+                0x24, 0xb8, 0x36, 0xde, 0x22, 0x4c, 0x73, 0x58, 0x13, 0x19, 0xa0, 0xba, 0x27, 0x88,
+                0xdb, 0xf8, 0x3b, 0xcf, 0x47, 0xa4, 0x8e, 0xeb, 0x02, 0xb4, 0x3a, 0x18, 0x02, 0x7b,
+                0x8f, 0x59, 0x11, 0x65, 0xc2, 0x86, 0xe8, 0xb6, 0x54, 0xec,
+            ],
+        },
+        TestVector {
+            incoming_viewing_key: [
+                0xa6, 0x68, 0x13, 0x52, 0xa3, 0x52, 0x26, 0x91, 0x10, 0x0f, 0x53, 0xfc, 0x34, 0xab,
+                0x73, 0x32, 0x8a, 0xf1, 0xb9, 0xf3, 0xa4, 0xa0, 0x6d, 0xbd, 0x3a, 0x14, 0x99, 0x67,
+                0x09, 0xe6, 0xf2, 0x84, 0x31, 0xee, 0x72, 0xf2, 0x69, 0xae, 0xd7, 0x5d, 0x36, 0x34,
+                0x89, 0x36, 0x90, 0x5e, 0xbb, 0x91, 0x80, 0x7d, 0x74, 0xd5, 0x0c, 0xb2, 0x7f, 0xcd,
+                0x8b, 0x4f, 0xb6, 0xf4, 0x48, 0xc3, 0x62, 0x03,
+            ],
+            ovk: [
+                0x78, 0xf1, 0x45, 0xea, 0x29, 0xd2, 0x71, 0xb9, 0x40, 0xc6, 0x99, 0x41, 0xe4, 0xc3,
+                0xfd, 0x2d, 0x71, 0xf3, 0xb1, 0x90, 0x69, 0x0e, 0xe1, 0x6f, 0x5d, 0x14, 0xac, 0x22,
+                0x24, 0xe6, 0xfc, 0x89,
+            ],
+            default_d: [
+                0x11, 0x6e, 0x79, 0x94, 0x55, 0xae, 0xa1, 0x91, 0x8f, 0xbf, 0xd4,
+            ],
+            default_pk_d: [
+                0x3e, 0x5e, 0x46, 0xeb, 0x0f, 0xe8, 0xe6, 0xf0, 0xcf, 0x6a, 0xab, 0x2b, 0x41, 0xfb,
+                0xcf, 0xfb, 0xb2, 0x98, 0xf8, 0xd5, 0x34, 0xc8, 0xd9, 0xd3, 0x11, 0xe4, 0xc6, 0x10,
+                0x3a, 0x56, 0x6a, 0xaa,
+            ],
+            v: 15093716717054627455,
+            rseed: [
+                0x7e, 0x62, 0x25, 0x8d, 0x65, 0xa1, 0x92, 0x15, 0x7c, 0xdf, 0x2e, 0xc3, 0x21, 0x40,
+                0x7f, 0x68, 0x2f, 0x5e, 0xec, 0x6a, 0x32, 0x97, 0xab, 0x20, 0xb7, 0x06, 0x1c, 0x62,
+                0x24, 0x57, 0x16, 0xa4,
+            ],
+            asset: [
+                0x96, 0x86, 0xaa, 0x36, 0x36, 0xbd, 0x37, 0x5b, 0xd3, 0x13, 0x6b, 0xee, 0x0b, 0xda,
+                0xab, 0xcf, 0xac, 0x88, 0x1b, 0xc7, 0x01, 0x81, 0x27, 0x21, 0xe6, 0xfb, 0x75, 0xaa,
+                0x07, 0x2d, 0x2d, 0x18,
+            ],
+            memo: [
+                0xff, 0x4f, 0x71, 0xfb, 0xfc, 0x34, 0xc7, 0x9b, 0x44, 0xe0, 0x9e, 0x42, 0x12, 0xac,
+                0x26, 0x53, 0xf6, 0xc4, 0x03, 0x64, 0x3e, 0x1c, 0x5b, 0x9a, 0xd1, 0x34, 0xd8, 0x9c,
+                0x68, 0x0b, 0x70, 0x72, 0x83, 0xaf, 0x54, 0x32, 0x6f, 0xc4, 0xf8, 0x4d, 0x6a, 0x58,
+                0x29, 0xa0, 0xad, 0x48, 0x30, 0x80, 0x6c, 0x05, 0x75, 0x84, 0x92, 0xcd, 0x6a, 0xc4,
+                0x6b, 0xa0, 0x1a, 0x2b, 0x37, 0x22, 0xb5, 0xe4, 0xcd, 0xaf, 0xbb, 0x3f, 0x36, 0x78,
+                0x5f, 0x42, 0x4a, 0xf0, 0x44, 0xda, 0xc5, 0xdb, 0x5f, 0x7d, 0xf8, 0x39, 0xeb, 0x63,
+                0xc0, 0xc1, 0x7d, 0x8b, 0x0c, 0x79, 0xdb, 0x86, 0x30, 0x94, 0x20, 0x15, 0xbe, 0x13,
+                0xf7, 0x9a, 0xf6, 0xf4, 0x3e, 0x5a, 0xb0, 0x77, 0x81, 0x14, 0x79, 0x8f, 0x44, 0x22,
+                0x58, 0xee, 0xdc, 0x43, 0x6f, 0xcc, 0x38, 0x6b, 0x36, 0xb5, 0x7e, 0x19, 0x17, 0xd7,
+                0x20, 0x17, 0x73, 0x66, 0xf4, 0x24, 0xb0, 0xa5, 0x4b, 0x0b, 0x60, 0xf4, 0xfb, 0x13,
+                0x58, 0xc2, 0x0a, 0xa4, 0x1d, 0xc5, 0x02, 0xe1, 0xdd, 0x8a, 0x16, 0x33, 0xf3, 0xd8,
+                0xe3, 0x27, 0x6b, 0x59, 0xe7, 0xd2, 0xc4, 0xe6, 0x24, 0xa6, 0xf5, 0x36, 0x95, 0xbc,
+                0xaf, 0x24, 0x7e, 0x36, 0x48, 0x3f, 0x13, 0xb2, 0x04, 0x42, 0x22, 0x37, 0xfc, 0x6a,
+                0xb3, 0xeb, 0xa0, 0x2f, 0xc4, 0x14, 0x2b, 0x42, 0x97, 0xeb, 0xb5, 0x68, 0x3d, 0xb8,
+                0xd2, 0x43, 0x19, 0x70, 0x6a, 0xd2, 0x6a, 0xaf, 0xd8, 0x1c, 0x53, 0xb7, 0x40, 0xf3,
+                0x45, 0x43, 0xa6, 0xb3, 0xe9, 0xf5, 0xbb, 0x7d, 0x5c, 0x49, 0xe8, 0xc3, 0x7f, 0x61,
+                0x49, 0x21, 0x25, 0x4f, 0x32, 0x12, 0x39, 0x4c, 0x79, 0x7d, 0x1c, 0xee, 0x78, 0x99,
+                0xb7, 0xb4, 0xb6, 0x5b, 0x59, 0xb7, 0x34, 0x2f, 0x92, 0x53, 0x1c, 0x1d, 0x59, 0xe1,
+                0x79, 0x70, 0xb7, 0x31, 0x74, 0x14, 0x43, 0x8c, 0xd8, 0x0b, 0xd0, 0xf9, 0xa6, 0x7c,
+                0x9b, 0x9e, 0x55, 0x2f, 0x01, 0x3c, 0x11, 0x5a, 0x95, 0x4f, 0x35, 0xe0, 0x61, 0x6c,
+                0x68, 0xd4, 0x31, 0x63, 0xd3, 0x34, 0xda, 0xc3, 0x82, 0x70, 0x33, 0xe5, 0xad, 0x84,
+                0x88, 0xbf, 0xd9, 0xc4, 0xbb, 0xbe, 0x8f, 0x59, 0x35, 0xc6, 0xc5, 0xea, 0x04, 0xc3,
+                0xad, 0x49, 0xc7, 0x47, 0xa9, 0xe7, 0x23, 0x1b, 0xcd, 0x7d, 0x16, 0x21, 0x5e, 0x6e,
+                0x80, 0x73, 0x7d, 0x6b, 0x54, 0xfe, 0xc8, 0xb8, 0x84, 0x02, 0xf0, 0x47, 0x52, 0x45,
+                0xe1, 0x74, 0xa7, 0x45, 0xb8, 0x31, 0xf8, 0xfe, 0x03, 0xa7, 0x6f, 0xb9, 0xce, 0xca,
+                0x4d, 0x22, 0xb7, 0x83, 0xc3, 0x28, 0xc6, 0x91, 0x5c, 0x43, 0x40, 0x50, 0x64, 0xae,
+                0x56, 0xbc, 0x89, 0xe6, 0x4d, 0x15, 0x78, 0xe4, 0xd3, 0xa3, 0x4b, 0xb9, 0x55, 0x91,
+                0xea, 0xf1, 0xd3, 0xda, 0x02, 0xa4, 0x54, 0x9f, 0xa8, 0x0d, 0xb0, 0xff, 0x7c, 0xb0,
+                0x39, 0x93, 0xb6, 0x8a, 0xe1, 0x5a, 0x30, 0xe8, 0x79, 0x49, 0xaa, 0x08, 0x0e, 0x94,
+                0xab, 0xde, 0x68, 0x89, 0x8c, 0x33, 0x92, 0xa2, 0x17, 0xd6, 0x49, 0x61, 0x6b, 0xbe,
+                0x73, 0x9b, 0x13, 0xd1, 0x4d, 0xf0, 0x3f, 0xf2, 0x76, 0x71, 0x48, 0x9b, 0xe0, 0xb4,
+                0xbe, 0xba, 0xaf, 0xa7, 0xd1, 0xe6, 0x39, 0xd5, 0xb3, 0xe9, 0x94, 0xff, 0xb6, 0xb7,
+                0xa2, 0x09, 0xf6, 0xad, 0xfe, 0x8d, 0x1e, 0x5c, 0xcf, 0x01, 0x0c, 0x19, 0x16, 0x8a,
+                0xeb, 0x18, 0xaa, 0x9d, 0x68, 0x7e, 0x24, 0xad, 0xc0, 0xb1, 0x13, 0x5c, 0x70, 0xc9,
+                0x70, 0xe0, 0x90, 0x3a, 0xf6, 0xe1, 0x70, 0x81, 0xd5, 0x81, 0x8e, 0x88, 0xb1, 0x4e,
+                0x4f, 0x60, 0x1b, 0x8c, 0x06, 0x3e, 0x3f, 0x43, 0x87, 0xff, 0xa2, 0x32, 0x2a, 0x51,
+                0x81, 0x90, 0x9f, 0x09, 0x80, 0xd6, 0x89, 0xde,
+            ],
+            cv_net: [
+                0x91, 0x6d, 0xc3, 0x82, 0x2a, 0x4e, 0x3b, 0xb4, 0x1f, 0xa8, 0x33, 0xc2, 0x73, 0xa9,
+                0xd3, 0x7d, 0x17, 0x17, 0xa4, 0x8d, 0x8f, 0x00, 0x6c, 0x1f, 0xf5, 0x86, 0x21, 0x46,
+                0x29, 0x55, 0x39, 0x1c,
+            ],
+            rho: [
+                0x57, 0x87, 0x18, 0x97, 0x6d, 0xa3, 0xdc, 0xb4, 0x30, 0x32, 0x71, 0x52, 0x20, 0x72,
+                0xd0, 0x28, 0x44, 0x22, 0x13, 0x50, 0x86, 0x4e, 0xed, 0x56, 0x3d, 0xab, 0x30, 0x22,
+                0x7f, 0x28, 0x4b, 0x2e,
+            ],
+            cmx: [
+                0x89, 0xe6, 0xa2, 0xb9, 0x70, 0x84, 0xe3, 0xd3, 0x34, 0x4f, 0xee, 0xb4, 0x64, 0x65,
+                0x05, 0x72, 0x51, 0xb1, 0x9d, 0xa0, 0xce, 0xdf, 0x79, 0x71, 0x94, 0xc5, 0x97, 0xf9,
+                0xf7, 0x7e, 0xf2, 0x1f,
+            ],
+            esk: [
+                0xe4, 0x00, 0x13, 0x04, 0x47, 0xc1, 0xbd, 0x1a, 0x0c, 0x13, 0x02, 0xf5, 0x10, 0xe9,
+                0xeb, 0x09, 0xed, 0x76, 0xda, 0xbc, 0xfe, 0x2a, 0x69, 0x1c, 0xc4, 0x69, 0x2d, 0x0c,
+                0x1b, 0x30, 0x33, 0x01,
+            ],
+            ephemeral_key: [
+                0x27, 0xcb, 0x40, 0x68, 0x0f, 0xb1, 0xd9, 0x19, 0x64, 0x6e, 0x74, 0x20, 0xe6, 0xa8,
+                0xb5, 0x20, 0xe1, 0x9a, 0x17, 0x3f, 0x1e, 0x79, 0x4d, 0x2b, 0x49, 0x2b, 0xfa, 0xbb,
+                0x83, 0xce, 0x6c, 0xa0,
+            ],
+            shared_secret: [
+                0x1c, 0xd0, 0x66, 0x91, 0x6c, 0x19, 0xfa, 0x33, 0x69, 0xaa, 0x3c, 0x6a, 0x53, 0x76,
+                0x97, 0xf4, 0xb4, 0x26, 0x44, 0xda, 0x20, 0xca, 0x46, 0x79, 0x93, 0x2b, 0x7c, 0x90,
+                0x5f, 0x2d, 0x69, 0x00,
+            ],
+            k_enc: [
+                0xce, 0x9d, 0x22, 0x0d, 0x3a, 0xfe, 0xc6, 0x23, 0x21, 0xdd, 0xf1, 0x97, 0xa6, 0x36,
+                0xdc, 0xb3, 0x45, 0x58, 0x83, 0xb7, 0x35, 0x82, 0x8c, 0x65, 0xe7, 0x16, 0x6c, 0x15,
+                0xd8, 0xcc, 0xfc, 0xf9,
+            ],
+            p_enc: [
+                0x03, 0x11, 0x6e, 0x79, 0x94, 0x55, 0xae, 0xa1, 0x91, 0x8f, 0xbf, 0xd4, 0x7f, 0x8e,
+                0x6a, 0x5c, 0x62, 0xa7, 0x77, 0xd1, 0x7e, 0x62, 0x25, 0x8d, 0x65, 0xa1, 0x92, 0x15,
+                0x7c, 0xdf, 0x2e, 0xc3, 0x21, 0x40, 0x7f, 0x68, 0x2f, 0x5e, 0xec, 0x6a, 0x32, 0x97,
+                0xab, 0x20, 0xb7, 0x06, 0x1c, 0x62, 0x24, 0x57, 0x16, 0xa4, 0x96, 0x86, 0xaa, 0x36,
+                0x36, 0xbd, 0x37, 0x5b, 0xd3, 0x13, 0x6b, 0xee, 0x0b, 0xda, 0xab, 0xcf, 0xac, 0x88,
+                0x1b, 0xc7, 0x01, 0x81, 0x27, 0x21, 0xe6, 0xfb, 0x75, 0xaa, 0x07, 0x2d, 0x2d, 0x18,
+                0xff, 0x4f, 0x71, 0xfb, 0xfc, 0x34, 0xc7, 0x9b, 0x44, 0xe0, 0x9e, 0x42, 0x12, 0xac,
+                0x26, 0x53, 0xf6, 0xc4, 0x03, 0x64, 0x3e, 0x1c, 0x5b, 0x9a, 0xd1, 0x34, 0xd8, 0x9c,
+                0x68, 0x0b, 0x70, 0x72, 0x83, 0xaf, 0x54, 0x32, 0x6f, 0xc4, 0xf8, 0x4d, 0x6a, 0x58,
+                0x29, 0xa0, 0xad, 0x48, 0x30, 0x80, 0x6c, 0x05, 0x75, 0x84, 0x92, 0xcd, 0x6a, 0xc4,
+                0x6b, 0xa0, 0x1a, 0x2b, 0x37, 0x22, 0xb5, 0xe4, 0xcd, 0xaf, 0xbb, 0x3f, 0x36, 0x78,
+                0x5f, 0x42, 0x4a, 0xf0, 0x44, 0xda, 0xc5, 0xdb, 0x5f, 0x7d, 0xf8, 0x39, 0xeb, 0x63,
+                0xc0, 0xc1, 0x7d, 0x8b, 0x0c, 0x79, 0xdb, 0x86, 0x30, 0x94, 0x20, 0x15, 0xbe, 0x13,
+                0xf7, 0x9a, 0xf6, 0xf4, 0x3e, 0x5a, 0xb0, 0x77, 0x81, 0x14, 0x79, 0x8f, 0x44, 0x22,
+                0x58, 0xee, 0xdc, 0x43, 0x6f, 0xcc, 0x38, 0x6b, 0x36, 0xb5, 0x7e, 0x19, 0x17, 0xd7,
+                0x20, 0x17, 0x73, 0x66, 0xf4, 0x24, 0xb0, 0xa5, 0x4b, 0x0b, 0x60, 0xf4, 0xfb, 0x13,
+                0x58, 0xc2, 0x0a, 0xa4, 0x1d, 0xc5, 0x02, 0xe1, 0xdd, 0x8a, 0x16, 0x33, 0xf3, 0xd8,
+                0xe3, 0x27, 0x6b, 0x59, 0xe7, 0xd2, 0xc4, 0xe6, 0x24, 0xa6, 0xf5, 0x36, 0x95, 0xbc,
+                0xaf, 0x24, 0x7e, 0x36, 0x48, 0x3f, 0x13, 0xb2, 0x04, 0x42, 0x22, 0x37, 0xfc, 0x6a,
+                0xb3, 0xeb, 0xa0, 0x2f, 0xc4, 0x14, 0x2b, 0x42, 0x97, 0xeb, 0xb5, 0x68, 0x3d, 0xb8,
+                0xd2, 0x43, 0x19, 0x70, 0x6a, 0xd2, 0x6a, 0xaf, 0xd8, 0x1c, 0x53, 0xb7, 0x40, 0xf3,
+                0x45, 0x43, 0xa6, 0xb3, 0xe9, 0xf5, 0xbb, 0x7d, 0x5c, 0x49, 0xe8, 0xc3, 0x7f, 0x61,
+                0x49, 0x21, 0x25, 0x4f, 0x32, 0x12, 0x39, 0x4c, 0x79, 0x7d, 0x1c, 0xee, 0x78, 0x99,
+                0xb7, 0xb4, 0xb6, 0x5b, 0x59, 0xb7, 0x34, 0x2f, 0x92, 0x53, 0x1c, 0x1d, 0x59, 0xe1,
+                0x79, 0x70, 0xb7, 0x31, 0x74, 0x14, 0x43, 0x8c, 0xd8, 0x0b, 0xd0, 0xf9, 0xa6, 0x7c,
+                0x9b, 0x9e, 0x55, 0x2f, 0x01, 0x3c, 0x11, 0x5a, 0x95, 0x4f, 0x35, 0xe0, 0x61, 0x6c,
+                0x68, 0xd4, 0x31, 0x63, 0xd3, 0x34, 0xda, 0xc3, 0x82, 0x70, 0x33, 0xe5, 0xad, 0x84,
+                0x88, 0xbf, 0xd9, 0xc4, 0xbb, 0xbe, 0x8f, 0x59, 0x35, 0xc6, 0xc5, 0xea, 0x04, 0xc3,
+                0xad, 0x49, 0xc7, 0x47, 0xa9, 0xe7, 0x23, 0x1b, 0xcd, 0x7d, 0x16, 0x21, 0x5e, 0x6e,
+                0x80, 0x73, 0x7d, 0x6b, 0x54, 0xfe, 0xc8, 0xb8, 0x84, 0x02, 0xf0, 0x47, 0x52, 0x45,
+                0xe1, 0x74, 0xa7, 0x45, 0xb8, 0x31, 0xf8, 0xfe, 0x03, 0xa7, 0x6f, 0xb9, 0xce, 0xca,
+                0x4d, 0x22, 0xb7, 0x83, 0xc3, 0x28, 0xc6, 0x91, 0x5c, 0x43, 0x40, 0x50, 0x64, 0xae,
+                0x56, 0xbc, 0x89, 0xe6, 0x4d, 0x15, 0x78, 0xe4, 0xd3, 0xa3, 0x4b, 0xb9, 0x55, 0x91,
+                0xea, 0xf1, 0xd3, 0xda, 0x02, 0xa4, 0x54, 0x9f, 0xa8, 0x0d, 0xb0, 0xff, 0x7c, 0xb0,
+                0x39, 0x93, 0xb6, 0x8a, 0xe1, 0x5a, 0x30, 0xe8, 0x79, 0x49, 0xaa, 0x08, 0x0e, 0x94,
+                0xab, 0xde, 0x68, 0x89, 0x8c, 0x33, 0x92, 0xa2, 0x17, 0xd6, 0x49, 0x61, 0x6b, 0xbe,
+                0x73, 0x9b, 0x13, 0xd1, 0x4d, 0xf0, 0x3f, 0xf2, 0x76, 0x71, 0x48, 0x9b, 0xe0, 0xb4,
+                0xbe, 0xba, 0xaf, 0xa7, 0xd1, 0xe6, 0x39, 0xd5, 0xb3, 0xe9, 0x94, 0xff, 0xb6, 0xb7,
+                0xa2, 0x09, 0xf6, 0xad, 0xfe, 0x8d, 0x1e, 0x5c, 0xcf, 0x01, 0x0c, 0x19, 0x16, 0x8a,
+                0xeb, 0x18, 0xaa, 0x9d, 0x68, 0x7e, 0x24, 0xad, 0xc0, 0xb1, 0x13, 0x5c, 0x70, 0xc9,
+                0x70, 0xe0, 0x90, 0x3a, 0xf6, 0xe1, 0x70, 0x81, 0xd5, 0x81, 0x8e, 0x88, 0xb1, 0x4e,
+                0x4f, 0x60, 0x1b, 0x8c, 0x06, 0x3e, 0x3f, 0x43, 0x87, 0xff, 0xa2, 0x32, 0x2a, 0x51,
+                0x81, 0x90, 0x9f, 0x09, 0x80, 0xd6, 0x89, 0xde,
+            ],
+            c_enc: [
+                0xb1, 0x69, 0x64, 0x77, 0xe6, 0x58, 0xb6, 0xf8, 0xe2, 0x4e, 0x02, 0x55, 0x52, 0xb4,
+                0x8d, 0xd4, 0x84, 0x58, 0xf2, 0xcd, 0x75, 0x70, 0xc0, 0xe8, 0xce, 0xc4, 0xed, 0x4c,
+                0xf7, 0x9b, 0xd5, 0xb6, 0x9e, 0xa8, 0x54, 0x12, 0x3b, 0x4e, 0xaf, 0x97, 0x8b, 0x14,
+                0x2e, 0xb3, 0xef, 0x53, 0xaa, 0xfc, 0x78, 0x90, 0xdd, 0xa2, 0x8a, 0xfa, 0x25, 0xf1,
+                0x45, 0xc8, 0xb9, 0x7f, 0x7b, 0x94, 0x50, 0xc1, 0xd5, 0xe0, 0xc3, 0x7d, 0xaf, 0x5e,
+                0xd4, 0xec, 0xd9, 0xb6, 0x3d, 0xbc, 0xd2, 0x15, 0x11, 0x23, 0x13, 0x9b, 0xbc, 0x2b,
+                0x65, 0x1a, 0x8f, 0x69, 0xcf, 0xbf, 0xb7, 0xcb, 0x60, 0x44, 0x78, 0xf3, 0xf2, 0x64,
+                0xd9, 0xdd, 0x75, 0xcf, 0x31, 0x9e, 0x3e, 0xcd, 0xf5, 0xb3, 0x34, 0x26, 0x54, 0x85,
+                0x7c, 0x52, 0xa1, 0xfc, 0x61, 0x40, 0x55, 0xa2, 0x46, 0xf5, 0x26, 0x3e, 0x85, 0x36,
+                0x83, 0xef, 0x54, 0x41, 0x3b, 0xac, 0x99, 0x1a, 0xe6, 0x35, 0x01, 0x50, 0xe1, 0x34,
+                0x52, 0xa3, 0xa6, 0x20, 0xc5, 0x3f, 0x80, 0xda, 0xcc, 0x7a, 0xf0, 0x59, 0x26, 0xd9,
+                0xc5, 0x9a, 0x94, 0xe4, 0x78, 0x9a, 0xcc, 0x68, 0xd8, 0x51, 0x05, 0x6b, 0x75, 0xa7,
+                0x4e, 0x2e, 0x1b, 0x38, 0xbf, 0xcb, 0x6d, 0xba, 0xab, 0x37, 0xa3, 0x8a, 0xe0, 0x2c,
+                0x9c, 0x35, 0x25, 0x9e, 0x52, 0x84, 0xe4, 0xfe, 0x83, 0xdd, 0xb2, 0x29, 0x24, 0xa1,
+                0xc4, 0x0a, 0xa2, 0x5e, 0xd1, 0xf5, 0xc0, 0x6d, 0xa1, 0x58, 0x31, 0xf0, 0x41, 0x50,
+                0xa3, 0x7c, 0x1b, 0xa3, 0xd1, 0x17, 0x04, 0x93, 0xca, 0x29, 0xf3, 0x43, 0x4a, 0xfa,
+                0x06, 0x9b, 0x46, 0xaf, 0xdc, 0x87, 0x0a, 0x29, 0x6f, 0xdc, 0x0e, 0xb6, 0x1b, 0x55,
+                0x70, 0x77, 0xa1, 0xda, 0x1f, 0xe8, 0x22, 0xb6, 0xce, 0x24, 0x7c, 0x8e, 0x19, 0x9f,
+                0xc4, 0x85, 0x14, 0x6f, 0x38, 0x4a, 0xcf, 0x5c, 0x52, 0x69, 0x7e, 0xfa, 0xcc, 0x5b,
+                0xfe, 0x42, 0x02, 0xe8, 0x5f, 0x06, 0x4b, 0xc8, 0xe1, 0x2e, 0xee, 0x39, 0x79, 0x6d,
+                0xfd, 0x13, 0x99, 0xb1, 0xc1, 0xe8, 0xc7, 0x4b, 0x5e, 0xc3, 0xc3, 0x1d, 0x2c, 0xfa,
+                0x44, 0x87, 0x02, 0x5c, 0xeb, 0x5d, 0xb3, 0x55, 0x9d, 0x4b, 0x7b, 0xac, 0x02, 0x73,
+                0xf1, 0x33, 0x51, 0xd2, 0xd1, 0x3c, 0xec, 0x0a, 0x44, 0x8c, 0x00, 0x11, 0x09, 0x45,
+                0x2c, 0x40, 0x92, 0xc8, 0x11, 0x91, 0xa0, 0xda, 0xa9, 0x79, 0xe2, 0x6a, 0x96, 0x24,
+                0xe4, 0x0c, 0xa4, 0xac, 0xcb, 0x63, 0x46, 0xaa, 0xe1, 0x88, 0xca, 0x09, 0x39, 0xdd,
+                0x9f, 0x6b, 0x6e, 0x45, 0xe4, 0x1b, 0xca, 0xeb, 0xdc, 0x1d, 0xa8, 0x01, 0xcc, 0xd4,
+                0xdc, 0x93, 0x32, 0x26, 0x6f, 0xb3, 0xeb, 0x23, 0x7b, 0x07, 0x72, 0x45, 0xa7, 0x91,
+                0xec, 0xb4, 0x0e, 0x5c, 0x40, 0x56, 0xad, 0xd6, 0xb1, 0xb5, 0xf7, 0xf8, 0xfa, 0x10,
+                0x4f, 0xba, 0x61, 0x3e, 0xd9, 0x29, 0xe1, 0xfa, 0xd2, 0x26, 0x47, 0x50, 0x35, 0xb6,
+                0x1a, 0x9f, 0x85, 0xaf, 0xba, 0xfb, 0x16, 0x6b, 0x24, 0xc2, 0x4d, 0x2c, 0x28, 0x93,
+                0x7b, 0x17, 0x70, 0xba, 0x26, 0x9c, 0x15, 0xeb, 0x2d, 0x9b, 0xdc, 0x2b, 0x83, 0xea,
+                0xd8, 0xa0, 0x1d, 0xdb, 0x11, 0x08, 0x3b, 0x13, 0xd6, 0x2d, 0x57, 0x2c, 0xf7, 0x8d,
+                0x5c, 0xba, 0x6f, 0x36, 0x52, 0xca, 0xc4, 0xd2, 0x4c, 0x71, 0xc5, 0x47, 0x27, 0x26,
+                0x24, 0xc0, 0x78, 0xe0, 0xb9, 0x69, 0x68, 0xfe, 0x09, 0xd8, 0x3e, 0xf7, 0x30, 0x20,
+                0x62, 0xbb, 0x5d, 0x3a, 0x2c, 0xcf, 0x73, 0x4e, 0x0f, 0xd3, 0x51, 0x01, 0xfd, 0x58,
+                0x64, 0x73, 0x3f, 0x44, 0xd0, 0x75, 0xc3, 0x8b, 0x73, 0xf6, 0xbf, 0xb8, 0xc3, 0x9c,
+                0x7b, 0x6b, 0x3d, 0xbc, 0xd1, 0x9a, 0x05, 0x89, 0x91, 0x86, 0x37, 0xf7, 0x5b, 0xbe,
+                0x40, 0x15, 0x7b, 0x80, 0xe5, 0x9e, 0x55, 0x58, 0x50, 0x28, 0xa5, 0xec, 0x20, 0x1e,
+                0x00, 0x8f, 0xf6, 0xf5, 0x12, 0xe2, 0x53, 0xcc, 0x9a, 0xcf, 0x62, 0x7d, 0x94, 0x35,
+                0xdb, 0x6b, 0x14, 0xb9, 0x82, 0x48, 0x79, 0xf4, 0xe4, 0x0a, 0x36, 0xd5, 0xec, 0x94,
+                0x2b, 0xff, 0x04, 0xfd, 0x0b, 0xb8, 0x0c, 0x3e, 0xdd, 0xb7, 0xb2, 0x0a, 0x11, 0x6b,
+                0xa7, 0x0d, 0x84, 0x84, 0x6e, 0xc6, 0xd2, 0x52, 0x0f, 0xe7, 0x68, 0x89, 0x9e, 0xd5,
+                0x27, 0xd3, 0x1d, 0x32, 0x19, 0x68, 0xde, 0xc1, 0x32, 0x7b, 0x81, 0xcc, 0x61, 0x89,
+                0x8f, 0x2c, 0xc4, 0x5a, 0xeb, 0x43, 0x52, 0x9e, 0x7d, 0x08,
+            ],
+            ock: [
+                0x95, 0x83, 0xf1, 0x0f, 0xed, 0x70, 0xa4, 0x1e, 0x45, 0x8c, 0x65, 0x5c, 0xc0, 0x14,
+                0xe2, 0x35, 0x5a, 0x7f, 0x99, 0xae, 0xbc, 0xfe, 0xf7, 0x4a, 0x55, 0x9a, 0xcd, 0x24,
+                0x25, 0xfa, 0x21, 0xcf,
+            ],
+            op: [
+                0x3e, 0x5e, 0x46, 0xeb, 0x0f, 0xe8, 0xe6, 0xf0, 0xcf, 0x6a, 0xab, 0x2b, 0x41, 0xfb,
+                0xcf, 0xfb, 0xb2, 0x98, 0xf8, 0xd5, 0x34, 0xc8, 0xd9, 0xd3, 0x11, 0xe4, 0xc6, 0x10,
+                0x3a, 0x56, 0x6a, 0xaa, 0xe4, 0x00, 0x13, 0x04, 0x47, 0xc1, 0xbd, 0x1a, 0x0c, 0x13,
+                0x02, 0xf5, 0x10, 0xe9, 0xeb, 0x09, 0xed, 0x76, 0xda, 0xbc, 0xfe, 0x2a, 0x69, 0x1c,
+                0xc4, 0x69, 0x2d, 0x0c, 0x1b, 0x30, 0x33, 0x01,
+            ],
+            c_out: [
+                0xb8, 0x3b, 0x74, 0x5c, 0x9c, 0x0b, 0x04, 0xdd, 0xc7, 0xf1, 0x38, 0x16, 0x94, 0x38,
+                0x99, 0x55, 0x3a, 0x30, 0x6a, 0x4a, 0xd0, 0xf2, 0xf5, 0x70, 0x92, 0x2a, 0x89, 0x9b,
+                0xab, 0xb9, 0xda, 0xca, 0xd2, 0xbb, 0xc9, 0x5c, 0xf6, 0x5b, 0x73, 0x08, 0x55, 0x0d,
+                0xce, 0xdb, 0x64, 0x9e, 0xf1, 0x5e, 0x0b, 0x1a, 0x09, 0x1f, 0xad, 0x5a, 0x93, 0x92,
+                0xd0, 0x71, 0xb7, 0x5a, 0xb5, 0x1a, 0x7e, 0x35, 0x06, 0xad, 0x58, 0xd1, 0x71, 0x95,
+                0xc9, 0x9f, 0x29, 0x8a, 0xc3, 0x14, 0xec, 0x05, 0xa6, 0x6a,
+            ],
+        },
+    ]
+}
diff --git a/src/value.rs b/src/value.rs
index dd3a5546d..b514e7a28 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -53,13 +53,14 @@ use pasta_curves::{
 use rand::RngCore;
 use subtle::CtOption;
 
-use crate::builder::Error;
-use crate::note::AssetId;
 use crate::{
     constants::fixed_bases::{VALUE_COMMITMENT_PERSONALIZATION, VALUE_COMMITMENT_R_BYTES},
     primitives::redpallas::{self, Binding},
 };
 
+use crate::builder::Error;
+use crate::note::AssetId;
+
 /// Maximum note value.
 pub const MAX_NOTE_VALUE: u64 = u64::MAX;
 
diff --git a/tests/builder.rs b/tests/builder.rs
index 312541ecf..3e7c416c6 100644
--- a/tests/builder.rs
+++ b/tests/builder.rs
@@ -6,7 +6,7 @@ use orchard::{
     circuit::{ProvingKey, VerifyingKey},
     keys::{FullViewingKey, PreparedIncomingViewingKey, Scope, SpendAuthorizingKey, SpendingKey},
     note::ExtractedNoteCommitment,
-    note_encryption::OrchardDomain,
+    note_encryption_v3::OrchardDomainV3,
     tree::{MerkleHashOrchard, MerklePath},
     value::NoteValue,
     Anchor, Bundle, Note,
@@ -89,7 +89,7 @@ fn bundle_chain() {
             .actions()
             .iter()
             .find_map(|action| {
-                let domain = OrchardDomain::for_action(action);
+                let domain = OrchardDomainV3::for_action(action);
                 try_note_decryption(&domain, &ivk, action)
             })
             .unwrap();
diff --git a/tests/zsa.rs b/tests/zsa.rs
index 9aad802d5..fa41d48e4 100644
--- a/tests/zsa.rs
+++ b/tests/zsa.rs
@@ -7,7 +7,7 @@ use orchard::bundle::Authorized;
 use orchard::issuance::{verify_issue_bundle, IssueBundle, Signed, Unauthorized};
 use orchard::keys::{IssuanceAuthorizingKey, IssuanceValidatingKey};
 use orchard::note::{AssetId, ExtractedNoteCommitment};
-use orchard::note_encryption::OrchardDomain;
+use orchard::note_encryption_v3::OrchardDomainV3;
 use orchard::tree::{MerkleHashOrchard, MerklePath};
 use orchard::{
     builder::Builder,
@@ -204,7 +204,7 @@ fn create_native_note(keys: &Keychain) -> Note {
         .actions()
         .iter()
         .find_map(|action| {
-            let domain = OrchardDomain::for_action(action);
+            let domain = OrchardDomainV3::for_action(action);
             try_note_decryption(&domain, &PreparedIncomingViewingKey::new(&ivk), action)
         })
         .unwrap();