@aptos-labs/ts-sdk 1.27.1-zeta.0 → 1.28.0-zeta.0

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosStdlib/crypto_algebra.move

@@ -1,351 +0,0 @@
-/// This module provides generic structs/functions for operations of algebraic structures (e.g. fields and groups),
-/// which can be used to build generic cryptographic schemes atop.
-/// E.g., a Groth16 ZK proof verifier can be built to work over any pairing supported in this module.
-///
-/// In general, every structure implements basic operations like (de)serialization, equality check, random sampling.
-///
-/// A group may also implement the following operations. (Additive group notation is assumed.)
-/// - `order()` for getting the group order.
-/// - `zero()` for getting the group identity.
-/// - `one()` for getting the group generator (if exists).
-/// - `neg()` for group element inversion.
-/// - `add()` for group operation (i.e., a group addition).
-/// - `sub()` for group element subtraction.
-/// - `double()` for efficient doubling.
-/// - `scalar_mul()` for group scalar multiplication.
-/// - `multi_scalar_mul()` for efficient group multi-scalar multiplication.
-/// - `hash_to()` for hash-to-group.
-///
-/// A field may also implement the following operations.
-/// - `zero()` for getting the field additive identity.
-/// - `one()` for getting the field multiplicative identity.
-/// - `add()` for field addition.
-/// - `sub()` for field subtraction.
-/// - `mul()` for field multiplication.
-/// - `div()` for field division.
-/// - `neg()` for field negation.
-/// - `inv()` for field inversion.
-/// - `sqr()` for efficient field element squaring.
-/// - `from_u64()` for quick conversion from u64 to field element.
-///
-/// For 3 groups that admit a bilinear map, `pairing()` and `multi_pairing()` may be implemented.
-///
-/// For a subset/superset relationship between 2 structures, `upcast()` and `downcast()` may be implemented.
-/// E.g., in BLS12-381 pairing, since `Gt` is a subset of `Fq12`,
-/// `upcast<Gt, Fq12>()` and `downcast<Fq12, Gt>()` will be supported.
-///
-/// See `*_algebra.move` for currently implemented algebraic structures.
-module aptos_std::crypto_algebra {
-    use std::option::{Option, some, none};
-    use std::features;
-
-    const E_NOT_IMPLEMENTED: u64 = 1;
-    const E_NON_EQUAL_LENGTHS: u64 = 2;
-    const E_TOO_MUCH_MEMORY_USED: u64 = 3;
-
-    /// This struct represents an element of a structure `S`.
-    struct Element<phantom S> has copy, drop {
-        handle: u64
-    }
-
-    //
-    // Public functions begin.
-    //
-
-    /// Check if `x == y` for elements `x` and `y` of a structure `S`.
-    public fun eq<S>(x: &Element<S>, y: &Element<S>): bool {
-        abort_unless_cryptography_algebra_natives_enabled();
-        eq_internal<S>(x.handle, y.handle)
-    }
-
-    /// Convert a u64 to an element of a structure `S`.
-    public fun from_u64<S>(value: u64): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<S> {
-            handle: from_u64_internal<S>(value)
-        }
-    }
-
-    /// Return the additive identity of field `S`, or the identity of group `S`.
-    public fun zero<S>(): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<S> {
-            handle: zero_internal<S>()
-        }
-    }
-
-    /// Return the multiplicative identity of field `S`, or a fixed generator of group `S`.
-    public fun one<S>(): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<S> {
-            handle: one_internal<S>()
-        }
-    }
-
-    /// Compute `-x` for an element `x` of a structure `S`.
-    public fun neg<S>(x: &Element<S>): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<S> {
-            handle: neg_internal<S>(x.handle)
-        }
-    }
-
-    /// Compute `x + y` for elements `x` and `y` of structure `S`.
-    public fun add<S>(x: &Element<S>, y: &Element<S>): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<S> {
-            handle: add_internal<S>(x.handle, y.handle)
-        }
-    }
-
-    /// Compute `x - y` for elements `x` and `y` of a structure `S`.
-    public fun sub<S>(x: &Element<S>, y: &Element<S>): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<S> {
-            handle: sub_internal<S>(x.handle, y.handle)
-        }
-    }
-
-    /// Compute `x * y` for elements `x` and `y` of a structure `S`.
-    public fun mul<S>(x: &Element<S>, y: &Element<S>): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<S> {
-            handle: mul_internal<S>(x.handle, y.handle)
-        }
-    }
-
-    /// Try computing `x / y` for elements `x` and `y` of a structure `S`.
-    /// Return none if `y` does not have a multiplicative inverse in the structure `S`
-    /// (e.g., when `S` is a field, and `y` is zero).
-    public fun div<S>(x: &Element<S>, y: &Element<S>): Option<Element<S>> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        let (succ, handle) = div_internal<S>(x.handle, y.handle);
-        if (succ) {
-            some(Element<S> { handle })
-        } else {
-            none()
-        }
-    }
-
-    /// Compute `x^2` for an element `x` of a structure `S`. Faster and cheaper than `mul(x, x)`.
-    public fun sqr<S>(x: &Element<S>): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<S> {
-            handle: sqr_internal<S>(x.handle)
-        }
-    }
-
-    /// Try computing `x^(-1)` for an element `x` of a structure `S`.
-    /// Return none if `x` does not have a multiplicative inverse in the structure `S`
-    /// (e.g., when `S` is a field, and `x` is zero).
-    public fun inv<S>(x: &Element<S>): Option<Element<S>> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        let (succeeded, handle) = inv_internal<S>(x.handle);
-        if (succeeded) {
-            let scalar = Element<S> { handle };
-            some(scalar)
-        } else {
-            none()
-        }
-    }
-
-    /// Compute `2*P` for an element `P` of a structure `S`. Faster and cheaper than `add(P, P)`.
-    public fun double<S>(element_p: &Element<S>): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<S> {
-            handle: double_internal<S>(element_p.handle)
-        }
-    }
-
-    /// Compute `k[0]*P[0]+...+k[n-1]*P[n-1]`, where
-    /// `P[]` are `n` elements of group `G` represented by parameter `elements`, and
-    /// `k[]` are `n` elements of the scalarfield `S` of group `G` represented by parameter `scalars`.
-    ///
-    /// Abort with code `std::error::invalid_argument(E_NON_EQUAL_LENGTHS)` if the sizes of `elements` and `scalars` do not match.
-    public fun multi_scalar_mul<G, S>(elements: &vector<Element<G>>, scalars: &vector<Element<S>>): Element<G> {
-        let element_handles = handles_from_elements(elements);
-        let scalar_handles = handles_from_elements(scalars);
-        Element<G> {
-            handle: multi_scalar_mul_internal<G, S>(element_handles, scalar_handles)
-        }
-    }
-
-    /// Compute `k*P`, where `P` is an element of a group `G` and `k` is an element of the scalar field `S` associated to the group `G`.
-    public fun scalar_mul<G, S>(element_p: &Element<G>, scalar_k: &Element<S>): Element<G> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<G> {
-            handle: scalar_mul_internal<G, S>(element_p.handle, scalar_k.handle)
-        }
-    }
-
-    /// Efficiently compute `e(P[0],Q[0])+...+e(P[n-1],Q[n-1])`,
-    /// where `e: (G1,G2) -> (Gt)` is the pairing function from groups `(G1,G2)` to group `Gt`,
-    /// `P[]` are `n` elements of group `G1` represented by parameter `g1_elements`, and
-    /// `Q[]` are `n` elements of group `G2` represented by parameter `g2_elements`.
-    ///
-    /// Abort with code `std::error::invalid_argument(E_NON_EQUAL_LENGTHS)` if the sizes of `g1_elements` and `g2_elements` do not match.
-    ///
-    /// NOTE: we are viewing the target group `Gt` of the pairing as an additive group,
-    /// rather than a multiplicative one (which is typically the case).
-    public fun multi_pairing<G1,G2,Gt>(g1_elements: &vector<Element<G1>>, g2_elements: &vector<Element<G2>>): Element<Gt> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        let g1_handles = handles_from_elements(g1_elements);
-        let g2_handles = handles_from_elements(g2_elements);
-        Element<Gt> {
-            handle: multi_pairing_internal<G1,G2,Gt>(g1_handles, g2_handles)
-        }
-    }
-
-    /// Compute the pairing function (a.k.a., bilinear map) on a `G1` element and a `G2` element.
-    /// Return an element in the target group `Gt`.
-    public fun pairing<G1,G2,Gt>(element_1: &Element<G1>, element_2: &Element<G2>): Element<Gt> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<Gt> {
-            handle: pairing_internal<G1,G2,Gt>(element_1.handle, element_2.handle)
-        }
-    }
-
-    /// Try deserializing a byte array to an element of an algebraic structure `S` using a given serialization format `F`.
-    /// Return none if the deserialization failed.
-    public fun deserialize<S, F>(bytes: &vector<u8>): Option<Element<S>> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        let (succeeded, handle) = deserialize_internal<S, F>(bytes);
-        if (succeeded) {
-            some(Element<S> { handle })
-        } else {
-            none()
-        }
-    }
-
-    /// Serialize an element of an algebraic structure `S` to a byte array using a given serialization format `F`.
-    public fun serialize<S, F>(element: &Element<S>): vector<u8> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        serialize_internal<S, F>(element.handle)
-    }
-
-    /// Get the order of structure `S`, a big integer little-endian encoded as a byte array.
-    public fun order<S>(): vector<u8> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        order_internal<S>()
-    }
-
-    /// Cast an element of a structure `S` to a parent structure `L`.
-    public fun upcast<S,L>(element: &Element<S>): Element<L> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<L> {
-            handle: upcast_internal<S,L>(element.handle)
-        }
-    }
-
-    /// Try casting an element `x` of a structure `L` to a sub-structure `S`.
-    /// Return none if `x` is not a member of `S`.
-    ///
-    /// NOTE: Membership check in `S` is performed inside, which can be expensive, depending on the structures `L` and `S`.
-    public fun downcast<L,S>(element_x: &Element<L>): Option<Element<S>> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        let (succ, new_handle) = downcast_internal<L,S>(element_x.handle);
-        if (succ) {
-            some(Element<S> { handle: new_handle })
-        } else {
-            none()
-        }
-    }
-
-    /// Hash an arbitrary-length byte array `msg` into structure `S` with a domain separation tag `dst`
-    /// using the given hash-to-structure suite `H`.
-    ///
-    /// NOTE: some hashing methods do not accept a `dst` and will abort if a non-empty one is provided.
-    public fun hash_to<S, H>(dst: &vector<u8>, msg: &vector<u8>): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element {
-            handle: hash_to_internal<S, H>(dst, msg)
-        }
-    }
-
-    #[test_only]
-    /// Generate a random element of an algebraic structure `S`.
-    public fun rand_insecure<S>(): Element<S> {
-        abort_unless_cryptography_algebra_natives_enabled();
-        Element<S> {
-            handle: rand_insecure_internal<S>()
-        }
-    }
-
-    //
-    // (Public functions end here.)
-    // Private functions begin.
-    //
-
-    fun abort_unless_cryptography_algebra_natives_enabled() {
-        if (features::cryptography_algebra_enabled()) return;
-        abort(std::error::not_implemented(0))
-    }
-
-    #[test_only]
-    public fun enable_cryptography_algebra_natives(fx: &signer) {
-        std::features::change_feature_flags_for_testing(fx, vector[std::features::get_cryptography_algebra_natives_feature()], vector[]);
-    }
-
-    fun handles_from_elements<S>(elements: &vector<Element<S>>): vector<u64> {
-        let num_elements = std::vector::length(elements);
-        let element_handles = std::vector::empty();
-        let i = 0;
-        while ({
-            spec {
-                invariant len(element_handles) == i;
-                invariant forall k in 0..i: element_handles[k] == elements[k].handle;
-            };
-            i < num_elements
-        }) {
-            std::vector::push_back(&mut element_handles, std::vector::borrow(elements, i).handle);
-            i = i + 1;
-        };
-        element_handles
-    }
-
-    //
-    // (Private functions end here.)
-    // Native functions begin.
-    //
-
-    native fun add_internal<S>(handle_1: u64, handle_2: u64): u64;
-    native fun deserialize_internal<S, F>(bytes: &vector<u8>): (bool, u64);
-    native fun div_internal<F>(handle_1: u64, handle_2: u64): (bool, u64);
-    native fun double_internal<G>(element_handle: u64): u64;
-    native fun downcast_internal<L,S>(handle: u64): (bool, u64);
-    native fun from_u64_internal<S>(value: u64): u64;
-    native fun eq_internal<S>(handle_1: u64, handle_2: u64): bool;
-    native fun hash_to_internal<S, H>(dst: &vector<u8>, bytes: &vector<u8>): u64;
-    native fun inv_internal<F>(handle: u64): (bool, u64);
-    #[test_only]
-    native fun rand_insecure_internal<S>(): u64;
-    native fun mul_internal<F>(handle_1: u64, handle_2: u64): u64;
-    native fun multi_pairing_internal<G1,G2,Gt>(g1_handles: vector<u64>, g2_handles: vector<u64>): u64;
-    native fun multi_scalar_mul_internal<G, S>(element_handles: vector<u64>, scalar_handles: vector<u64>): u64;
-    native fun neg_internal<F>(handle: u64): u64;
-    native fun one_internal<S>(): u64;
-    native fun order_internal<G>(): vector<u8>;
-    native fun pairing_internal<G1,G2,Gt>(g1_handle: u64, g2_handle: u64): u64;
-    native fun scalar_mul_internal<G, S>(element_handle: u64, scalar_handle: u64): u64;
-    native fun serialize_internal<S, F>(handle: u64): vector<u8>;
-    native fun sqr_internal<G>(handle: u64): u64;
-    native fun sub_internal<G>(handle_1: u64, handle_2: u64): u64;
-    native fun upcast_internal<S,L>(handle: u64): u64;
-    native fun zero_internal<S>(): u64;
-
-    //
-    // (Native functions end here.)
-    // Tests begin.
-    //
-
-    #[test_only]
-    struct MysteriousGroup {}
-
-    #[test(fx = @std)]
-    #[expected_failure(abort_code = 0x0c0001, location = Self)]
-    fun test_generic_operation_should_abort_with_unsupported_structures(fx: signer) {
-        enable_cryptography_algebra_natives(&fx);
-        let _ = order<MysteriousGroup>();
-    }
-    // Tests end.
-}

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosStdlib/debug.move

@@ -1,278 +0,0 @@
-/// Module providing debug functionality.
-module aptos_std::debug {
-    use std::string::String;
-
-    public fun print<T>(x: &T) {
-        native_print(format(x));
-    }
-
-    public fun print_stack_trace() {
-        native_print(native_stack_trace());
-    }
-
-    inline fun format<T>(x: &T): String {
-        aptos_std::string_utils::debug_string(x)
-    }
-
-    native fun native_print(x: String);
-    native fun native_stack_trace(): String;
-
-    #[test_only]
-    use std::vector;
-
-    #[test_only]
-    struct Foo has drop {}
-    #[test_only]
-    struct Bar has drop { x: u128, y: Foo, z: bool }
-    #[test_only]
-    struct Box<T> has drop { x: T }
-
-    #[test_only]
-    struct GenericStruct<phantom T> has drop {
-        val: u64,
-    }
-
-    #[test_only]
-    struct TestInner has drop {
-        val: u128,
-        vec: vector<u128>,
-        msgs: vector<vector<u8>>
-    }
-
-    #[test_only]
-    struct TestStruct has drop {
-        addr: address,
-        number: u8,
-        bytes: vector<u8>,
-        name: String,
-        vec: vector<TestInner>,
-    }
-
-    #[test_only]
-    fun assert_equal<T>(x: &T, expected: vector<u8>) {
-        if (std::string::bytes(&format(x)) != &expected) {
-            print(&format(x));
-            print(&std::string::utf8(expected));
-            assert!(false, 1);
-        };
-    }
-
-    #[test_only]
-    fun assert_string_equal(x: vector<u8>, expected: vector<u8>) {
-        assert!(std::string::bytes(&format(&std::string::utf8(x))) == &expected, 1);
-    }
-
-    #[test]
-    public fun test()  {
-        let x = 42;
-        assert_equal(&x, b"42");
-
-        let v = vector::empty();
-        vector::push_back(&mut v, 100);
-        vector::push_back(&mut v, 200);
-        vector::push_back(&mut v, 300);
-        assert_equal(&v, b"[ 100, 200, 300 ]");
-
-        let foo = Foo {};
-        assert_equal(&foo, b"0x1::debug::Foo {\n  dummy_field: false\n}");
-
-        let bar = Bar { x: 404, y: Foo {}, z: true };
-        assert_equal(&bar, b"0x1::debug::Bar {\n  x: 404,\n  y: 0x1::debug::Foo {\n    dummy_field: false\n  },\n  z: true\n}");
-
-        let box = Box { x: Foo {} };
-        assert_equal(&box, b"0x1::debug::Box<0x1::debug::Foo> {\n  x: 0x1::debug::Foo {\n    dummy_field: false\n  }\n}");
-    }
-
-    #[test]
-    fun test_print_string() {
-        let str_bytes = b"Hello, sane Move debugging!";
-
-        assert_equal(&str_bytes, b"0x48656c6c6f2c2073616e65204d6f766520646562756767696e6721");
-
-        let str = std::string::utf8(str_bytes);
-        assert_equal(&str, b"\"Hello, sane Move debugging!\"");
-    }
-
-    #[test]
-    fun test_print_quoted_string() {
-        let str_bytes = b"Can you say \"Hel\\lo\"?";
-
-        let str = std::string::utf8(str_bytes);
-        assert_equal(&str, b"\"Can you say \\\"Hel\\\\lo\\\"?\"");
-    }
-
-
-    #[test_only]
-    use std::features;
-    #[test(s = @0x123)]
-    fun test_print_primitive_types(s: signer) {
-        let u8 = 255u8;
-        assert_equal(&u8, b"255");
-
-        let u16 = 65535u16;
-        assert_equal(&u16, b"65535");
-
-        let u32 = 4294967295u32;
-        assert_equal(&u32, b"4294967295");
-
-        let u64 = 18446744073709551615u64;
-        assert_equal(&u64, b"18446744073709551615");
-
-        let u128 = 340282366920938463463374607431768211455u128;
-        assert_equal(&u128, b"340282366920938463463374607431768211455");
-
-        let u256 = 115792089237316195423570985008687907853269984665640564039457584007913129639935u256;
-        assert_equal(&u256, b"115792089237316195423570985008687907853269984665640564039457584007913129639935");
-
-        let bool = false;
-        assert_equal(&bool, b"false");
-
-        let bool = true;
-        assert_equal(&bool, b"true");
-
-        let a = @0x1234c0ffee;
-        assert_equal(&a, b"@0x1234c0ffee");
-
-        if (features::signer_native_format_fix_enabled()) {
-            let signer = s;
-            assert_equal(&signer, b"signer(@0x123)");
-        }
-    }
-
-    const MSG_1 : vector<u8> = b"abcdef";
-    const MSG_2 : vector<u8> = b"123456";
-
-    #[test]
-    fun test_print_struct() {
-        let obj = TestInner {
-            val: 100,
-            vec: vector[200u128, 400u128],
-            msgs: vector[MSG_1, MSG_2],
-        };
-
-        assert_equal(&obj, b"0x1::debug::TestInner {\n  val: 100,\n  vec: [ 200, 400 ],\n  msgs: [\n    0x616263646566,\n    0x313233343536\n  ]\n}");
-
-        let obj = TestInner {
-            val: 10,
-            vec: vector[],
-            msgs: vector[],
-        };
-
-        assert_equal(&obj, b"0x1::debug::TestInner {\n  val: 10,\n  vec: [],\n  msgs: []\n}");
-    }
-
-    #[test(s1 = @0x123, s2 = @0x456)]
-    fun test_print_vectors(s1: signer, s2: signer) {
-        let v_u8 = x"ffabcdef";
-        assert_equal(&v_u8, b"0xffabcdef");
-
-        let v_u16 = vector[16u16, 17u16, 18u16, 19u16];
-        assert_equal(&v_u16, b"[ 16, 17, 18, 19 ]");
-
-        let v_u32 = vector[32u32, 33u32, 34u32, 35u32];
-        assert_equal(&v_u32, b"[ 32, 33, 34, 35 ]");
-
-        let v_u64 = vector[64u64, 65u64, 66u64, 67u64];
-        assert_equal(&v_u64, b"[ 64, 65, 66, 67 ]");
-
-        let v_u128 = vector[128u128, 129u128, 130u128, 131u128];
-        assert_equal(&v_u128, b"[ 128, 129, 130, 131 ]");
-
-        let v_u256 = vector[256u256, 257u256, 258u256, 259u256];
-        assert_equal(&v_u256, b"[ 256, 257, 258, 259 ]");
-
-        let v_bool = vector[true, false];
-        assert_equal(&v_bool, b"[ true, false ]");
-
-        let v_addr = vector[@0x1234, @0x5678, @0xabcdef];
-        assert_equal(&v_addr, b"[ @0x1234, @0x5678, @0xabcdef ]");
-
-        if (features::signer_native_format_fix_enabled()) {
-            let v_signer = vector[s1, s2];
-            assert_equal(&v_signer, b"[ signer(@0x123), signer(@0x456) ]");
-        };
-
-        let v = vector[
-            TestInner {
-                val: 4u128,
-                vec: vector[127u128, 128u128],
-                msgs: vector[x"00ff", x"abcd"],
-            },
-            TestInner {
-                val: 8u128 ,
-                vec: vector[128u128, 129u128],
-                msgs: vector[x"0000"],
-            }
-        ];
-        assert_equal(&v, b"[\n  0x1::debug::TestInner {\n    val: 4,\n    vec: [ 127, 128 ],\n    msgs: [\n      0x00ff,\n      0xabcd\n    ]\n  },\n  0x1::debug::TestInner {\n    val: 8,\n    vec: [ 128, 129 ],\n    msgs: [\n      0x0000\n    ]\n  }\n]");
-    }
-
-    #[test(s1 = @0x123, s2 = @0x456)]
-    fun test_print_vector_of_vectors(s1: signer, s2: signer) {
-        let v_u8 = vector[x"ffab", x"cdef"];
-        assert_equal(&v_u8, b"[\n  0xffab,\n  0xcdef\n]");
-
-        let v_u16 = vector[vector[16u16, 17u16], vector[18u16, 19u16]];
-        assert_equal(&v_u16, b"[\n  [ 16, 17 ],\n  [ 18, 19 ]\n]");
-
-        let v_u32 = vector[vector[32u32, 33u32], vector[34u32, 35u32]];
-        assert_equal(&v_u32, b"[\n  [ 32, 33 ],\n  [ 34, 35 ]\n]");
-
-        let v_u64 = vector[vector[64u64, 65u64], vector[66u64, 67u64]];
-        assert_equal(&v_u64, b"[\n  [ 64, 65 ],\n  [ 66, 67 ]\n]");
-
-        let v_u128 = vector[vector[128u128, 129u128], vector[130u128, 131u128]];
-        assert_equal(&v_u128, b"[\n  [ 128, 129 ],\n  [ 130, 131 ]\n]");
-
-        let v_u256 = vector[vector[256u256, 257u256], vector[258u256, 259u256]];
-        assert_equal(&v_u256, b"[\n  [ 256, 257 ],\n  [ 258, 259 ]\n]");
-
-        let v_bool = vector[vector[true, false], vector[false, true]];
-        assert_equal(&v_bool, b"[\n  [ true, false ],\n  [ false, true ]\n]");
-
-        let v_addr = vector[vector[@0x1234, @0x5678], vector[@0xabcdef, @0x9999]];
-        assert_equal(&v_addr, b"[\n  [ @0x1234, @0x5678 ],\n  [ @0xabcdef, @0x9999 ]\n]");
-
-        if (features::signer_native_format_fix_enabled()) {
-            let v_signer = vector[vector[s1], vector[s2]];
-            assert_equal(&v_signer, b"[\n  [ signer(@0x123) ],\n  [ signer(@0x456) ]\n]");
-        };
-
-        let v = vector[
-            vector[
-                TestInner { val: 4u128, vec: vector[127u128, 128u128], msgs: vector[] },
-                TestInner { val: 8u128 , vec: vector[128u128, 129u128], msgs: vector[] }
-            ],
-            vector[
-                TestInner { val: 4u128, vec: vector[127u128, 128u128], msgs: vector[] },
-                TestInner { val: 8u128 , vec: vector[128u128, 129u128], msgs: vector[] }
-            ]
-        ];
-        assert_equal(&v, b"[\n  [\n    0x1::debug::TestInner {\n      val: 4,\n      vec: [ 127, 128 ],\n      msgs: []\n    },\n    0x1::debug::TestInner {\n      val: 8,\n      vec: [ 128, 129 ],\n      msgs: []\n    }\n  ],\n  [\n    0x1::debug::TestInner {\n      val: 4,\n      vec: [ 127, 128 ],\n      msgs: []\n    },\n    0x1::debug::TestInner {\n      val: 8,\n      vec: [ 128, 129 ],\n      msgs: []\n    }\n  ]\n]");
-    }
-
-    #[test]
-    fun test_print_nested_struct() {
-        let obj = TestStruct {
-            addr: @0x1,
-            number: 255u8,
-            bytes: x"c0ffee",
-            name: std::string::utf8(b"He\"llo"),
-            vec: vector[
-                TestInner { val: 1, vec: vector[130u128, 131u128], msgs: vector[] },
-                TestInner { val: 2, vec: vector[132u128, 133u128], msgs: vector[] }
-            ],
-        };
-
-        assert_equal(&obj, b"0x1::debug::TestStruct {\n  addr: @0x1,\n  number: 255,\n  bytes: 0xc0ffee,\n  name: \"He\\\"llo\",\n  vec: [\n    0x1::debug::TestInner {\n      val: 1,\n      vec: [ 130, 131 ],\n      msgs: []\n    },\n    0x1::debug::TestInner {\n      val: 2,\n      vec: [ 132, 133 ],\n      msgs: []\n    }\n  ]\n}");
-    }
-
-    #[test]
-    fun test_print_generic_struct() {
-        let obj = GenericStruct<Foo> {
-            val: 60u64,
-        };
-
-        assert_equal(&obj, b"0x1::debug::GenericStruct<0x1::debug::Foo> {\n  val: 60\n}");
-    }
-}