@aptos-labs/ts-sdk 3.1.0 → 3.1.1

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

@@ -1,114 +0,0 @@
-/// This module implements ECDSA signatures based on the prime-order secp256k1 ellptic curve (i.e., cofactor is 1).
-
-module aptos_std::secp256k1 {
-    use std::option::Option;
-
-    /// An error occurred while deserializing, for example due to wrong input size.
-    const E_DESERIALIZE: u64 = 1;   // This code must be the same, if ever returned from the native Rust implementation.
-
-    /// The size of a secp256k1-based ECDSA public key, in bytes.
-    const RAW_PUBLIC_KEY_NUM_BYTES: u64 = 64;
-    //const COMPRESSED_PUBLIC_KEY_SIZE: u64 = 33;
-
-    /// The size of a secp256k1-based ECDSA signature, in bytes.
-    const SIGNATURE_NUM_BYTES: u64 = 64;
-
-    /// A 64-byte ECDSA public key.
-    struct ECDSARawPublicKey has copy, drop, store {
-        bytes: vector<u8>
-    }
-
-    /// A 64-byte ECDSA signature.
-    struct ECDSASignature has copy, drop, store {
-        bytes: vector<u8>
-    }
-
-    /// Constructs an ECDSASignature struct from the given 64 bytes.
-    public fun ecdsa_signature_from_bytes(bytes: vector<u8>): ECDSASignature {
-        assert!(std::vector::length(&bytes) == SIGNATURE_NUM_BYTES, std::error::invalid_argument(E_DESERIALIZE));
-        ECDSASignature { bytes }
-    }
-
-    /// Constructs an ECDSARawPublicKey struct, given a 64-byte raw representation.
-    public fun ecdsa_raw_public_key_from_64_bytes(bytes: vector<u8>): ECDSARawPublicKey {
-        assert!(std::vector::length(&bytes) == RAW_PUBLIC_KEY_NUM_BYTES, std::error::invalid_argument(E_DESERIALIZE));
-        ECDSARawPublicKey { bytes }
-    }
-
-    /// Serializes an ECDSARawPublicKey struct to 64-bytes.
-    public fun ecdsa_raw_public_key_to_bytes(pk: &ECDSARawPublicKey): vector<u8> {
-        pk.bytes
-    }
-
-    /// Serializes an ECDSASignature struct to 64-bytes.
-    public fun ecdsa_signature_to_bytes(sig: &ECDSASignature): vector<u8> {
-        sig.bytes
-    }
-
-    /// Recovers the signer's raw (64-byte) public key from a secp256k1 ECDSA `signature` given the `recovery_id` and the signed
-    /// `message` (32 byte digest).
-    ///
-    /// Note that an invalid signature, or a signature from a different message, will result in the recovery of an
-    /// incorrect public key. This recovery algorithm can only be used to check validity of a signature if the signer's
-    /// public key (or its hash) is known beforehand.
-    public fun ecdsa_recover(
-        message: vector<u8>,
-        recovery_id: u8,
-        signature: &ECDSASignature,
-    ): Option<ECDSARawPublicKey> {
-        let (pk, success) = ecdsa_recover_internal(message, recovery_id, signature.bytes);
-        if (success) {
-            std::option::some(ecdsa_raw_public_key_from_64_bytes(pk))
-        } else {
-            std::option::none<ECDSARawPublicKey>()
-        }
-    }
-
-    //
-    // Native functions
-    //
-
-    /// Returns `(public_key, true)` if `signature` verifies on `message` under the recovered `public_key`
-    /// and returns `([], false)` otherwise.
-    native fun ecdsa_recover_internal(
-        message: vector<u8>,
-        recovery_id: u8,
-        signature: vector<u8>
-    ): (vector<u8>, bool);
-
-    //
-    // Tests
-    //
-
-    #[test]
-    /// Test on a valid secp256k1 ECDSA signature created using sk = x"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
-    fun test_ecdsa_recover() {
-        use std::hash;
-
-        let pk = ecdsa_recover(
-            hash::sha2_256(b"test aptos secp256k1"),
-            0,
-            &ECDSASignature { bytes: x"f7ad936da03f948c14c542020e3c5f4e02aaacd1f20427c11aa6e2fbf8776477646bba0e1a37f9e7c777c423a1d2849baafd7ff6a9930814a43c3f80d59db56f" },
-        );
-        assert!(std::option::is_some(&pk), 1);
-        assert!(std::option::extract(&mut pk).bytes == x"4646ae5047316b4230d0086c8acec687f00b1cd9d1dc634f6cb358ac0a9a8ffffe77b4dd0a4bfb95851f3b7355c781dd60f8418fc8a65d14907aff47c903a559", 1);
-
-        // Flipped bits; Signature stays valid
-        let pk = ecdsa_recover(
-            hash::sha2_256(b"test aptos secp256k1"),
-            0,
-            // NOTE: A '7' was flipped to an 'f' here
-            &ECDSASignature { bytes: x"f7ad936da03f948c14c542020e3c5f4e02aaacd1f20427c11aa6e2fbf8776477646bba0e1a37f9e7c7f7c423a1d2849baafd7ff6a9930814a43c3f80d59db56f" },
-        );
-        assert!(std::option::is_some(&pk), 1);
-        assert!(std::option::extract(&mut pk).bytes != x"4646ae5047316b4230d0086c8acec687f00b1cd9d1dc634f6cb358ac0a9a8ffffe77b4dd0a4bfb95851f3b7355c781dd60f8418fc8a65d14907aff47c903a559", 1);
-
-        // Flipped bits; Signature becomes invalid
-        let pk = ecdsa_recover(
-            hash::sha2_256(b"test aptos secp256k1"),
-            0,
-            &ECDSASignature { bytes: x"ffad936da03f948c14c542020e3c5f4e02aaacd1f20427c11aa6e2fbf8776477646bba0e1a37f9e7c7f7c423a1d2849baafd7ff6a9930814a43c3f80d59db56f" },
-        );
-        assert!(std::option::is_none(&pk), 1);
-    }
-}

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

@@ -1,319 +0,0 @@
-/// This module provides a solution for unsorted maps, that is it has the properties that
-/// 1) Keys point to Values
-/// 2) Each Key must be unique
-/// 3) A Key can be found within O(N) time
-/// 4) The keys are unsorted.
-/// 5) Adds and removals take O(N) time
-module aptos_std::simple_map {
-    use std::error;
-    use std::option;
-    use std::vector;
-
-    /// Map key already exists
-    const EKEY_ALREADY_EXISTS: u64 = 1;
-    /// Map key is not found
-    const EKEY_NOT_FOUND: u64 = 2;
-
-    struct SimpleMap<Key, Value> has copy, drop, store {
-        data: vector<Element<Key, Value>>,
-    }
-
-    struct Element<Key, Value> has copy, drop, store {
-        key: Key,
-        value: Value,
-    }
-
-    public fun length<Key: store, Value: store>(self: &SimpleMap<Key, Value>): u64 {
-        vector::length(&self.data)
-    }
-
-    /// Create an empty SimpleMap.
-    public fun new<Key: store, Value: store>(): SimpleMap<Key, Value> {
-        SimpleMap {
-            data: vector::empty(),
-        }
-    }
-
-    /// Create a SimpleMap from a vector of keys and values. The keys must be unique.
-    public fun new_from<Key: store, Value: store>(
-        keys: vector<Key>,
-        values: vector<Value>,
-    ): SimpleMap<Key, Value> {
-        let map = new();
-        add_all(&mut map, keys, values);
-        map
-    }
-
-    #[deprecated]
-    /// Create an empty SimpleMap.
-    /// This function is deprecated, use `new` instead.
-    public fun create<Key: store, Value: store>(): SimpleMap<Key, Value> {
-        new()
-    }
-
-    public fun borrow<Key: store, Value: store>(
-        self: &SimpleMap<Key, Value>,
-        key: &Key,
-    ): &Value {
-        let maybe_idx = find(self, key);
-        assert!(option::is_some(&maybe_idx), error::invalid_argument(EKEY_NOT_FOUND));
-        let idx = option::extract(&mut maybe_idx);
-        &vector::borrow(&self.data, idx).value
-    }
-
-    public fun borrow_mut<Key: store, Value: store>(
-        self: &mut SimpleMap<Key, Value>,
-        key: &Key,
-    ): &mut Value {
-        let maybe_idx = find(self, key);
-        assert!(option::is_some(&maybe_idx), error::invalid_argument(EKEY_NOT_FOUND));
-        let idx = option::extract(&mut maybe_idx);
-        &mut vector::borrow_mut(&mut self.data, idx).value
-    }
-
-    public fun contains_key<Key: store, Value: store>(
-        self: &SimpleMap<Key, Value>,
-        key: &Key,
-    ): bool {
-        let maybe_idx = find(self, key);
-        option::is_some(&maybe_idx)
-    }
-
-    public fun destroy_empty<Key: store, Value: store>(self: SimpleMap<Key, Value>) {
-        let SimpleMap { data } = self;
-        vector::destroy_empty(data);
-    }
-
-    /// Add a key/value pair to the map. The key must not already exist.
-    public fun add<Key: store, Value: store>(
-        self: &mut SimpleMap<Key, Value>,
-        key: Key,
-        value: Value,
-    ) {
-        let maybe_idx = find(self, &key);
-        assert!(option::is_none(&maybe_idx), error::invalid_argument(EKEY_ALREADY_EXISTS));
-
-        vector::push_back(&mut self.data, Element { key, value });
-    }
-
-    /// Add multiple key/value pairs to the map. The keys must not already exist.
-    public fun add_all<Key: store, Value: store>(
-        self: &mut SimpleMap<Key, Value>,
-        keys: vector<Key>,
-        values: vector<Value>,
-    ) {
-        vector::zip(keys, values, |key, value| {
-            add(self, key, value);
-        });
-    }
-
-    /// Insert key/value pair or update an existing key to a new value
-    public fun upsert<Key: store, Value: store>(
-        self: &mut SimpleMap<Key, Value>,
-        key: Key,
-        value: Value
-    ): (std::option::Option<Key>, std::option::Option<Value>) {
-        let data = &mut self.data;
-        let len = vector::length(data);
-        let i = 0;
-        while (i < len) {
-            let element = vector::borrow(data, i);
-            if (&element.key == &key) {
-                vector::push_back(data, Element { key, value });
-                vector::swap(data, i, len);
-                let Element { key, value } = vector::pop_back(data);
-                return (std::option::some(key), std::option::some(value))
-            };
-            i = i + 1;
-        };
-        vector::push_back(&mut self.data, Element { key, value });
-        (std::option::none(), std::option::none())
-    }
-
-    /// Return all keys in the map. This requires keys to be copyable.
-    public fun keys<Key: copy, Value>(self: &SimpleMap<Key, Value>): vector<Key> {
-        vector::map_ref(&self.data, |e| {
-            let e: &Element<Key, Value> = e;
-            e.key
-        })
-    }
-
-    /// Return all values in the map. This requires values to be copyable.
-    public fun values<Key, Value: copy>(self: &SimpleMap<Key, Value>): vector<Value> {
-        vector::map_ref(&self.data, |e| {
-            let e: &Element<Key, Value> = e;
-            e.value
-        })
-    }
-
-    /// Transform the map into two vectors with the keys and values respectively
-    /// Primarily used to destroy a map
-    public fun to_vec_pair<Key: store, Value: store>(
-        self: SimpleMap<Key, Value>): (vector<Key>, vector<Value>) {
-        let keys: vector<Key> = vector::empty();
-        let values: vector<Value> = vector::empty();
-        let SimpleMap { data } = self;
-        vector::for_each(data, |e| {
-            let Element { key, value } = e;
-            vector::push_back(&mut keys, key);
-            vector::push_back(&mut values, value);
-        });
-        (keys, values)
-    }
-
-    /// For maps that cannot be dropped this is a utility to destroy them
-    /// using lambdas to destroy the individual keys and values.
-    public inline fun destroy<Key: store, Value: store>(
-        self: SimpleMap<Key, Value>,
-        dk: |Key|,
-        dv: |Value|
-    ) {
-        let (keys, values) = to_vec_pair(self);
-        vector::destroy(keys, |_k| dk(_k));
-        vector::destroy(values, |_v| dv(_v));
-    }
-
-    /// Remove a key/value pair from the map. The key must exist.
-    public fun remove<Key: store, Value: store>(
-        self: &mut SimpleMap<Key, Value>,
-        key: &Key,
-    ): (Key, Value) {
-        let maybe_idx = find(self, key);
-        assert!(option::is_some(&maybe_idx), error::invalid_argument(EKEY_NOT_FOUND));
-        let placement = option::extract(&mut maybe_idx);
-        let Element { key, value } = vector::swap_remove(&mut self.data, placement);
-        (key, value)
-    }
-
-    fun find<Key: store, Value: store>(
-        self: &SimpleMap<Key, Value>,
-        key: &Key,
-    ): option::Option<u64> {
-        let leng = vector::length(&self.data);
-        let i = 0;
-        while (i < leng) {
-            let element = vector::borrow(&self.data, i);
-            if (&element.key == key) {
-                return option::some(i)
-            };
-            i = i + 1;
-        };
-        option::none<u64>()
-    }
-
-    #[test]
-    public fun test_add_remove_many() {
-        let map = create<u64, u64>();
-
-        assert!(length(&map) == 0, 0);
-        assert!(!contains_key(&map, &3), 1);
-        add(&mut map, 3, 1);
-        assert!(length(&map) == 1, 2);
-        assert!(contains_key(&map, &3), 3);
-        assert!(borrow(&map, &3) == &1, 4);
-        *borrow_mut(&mut map, &3) = 2;
-        assert!(borrow(&map, &3) == &2, 5);
-
-        assert!(!contains_key(&map, &2), 6);
-        add(&mut map, 2, 5);
-        assert!(length(&map) == 2, 7);
-        assert!(contains_key(&map, &2), 8);
-        assert!(borrow(&map, &2) == &5, 9);
-        *borrow_mut(&mut map, &2) = 9;
-        assert!(borrow(&map, &2) == &9, 10);
-
-        remove(&mut map, &2);
-        assert!(length(&map) == 1, 11);
-        assert!(!contains_key(&map, &2), 12);
-        assert!(borrow(&map, &3) == &2, 13);
-
-        remove(&mut map, &3);
-        assert!(length(&map) == 0, 14);
-        assert!(!contains_key(&map, &3), 15);
-
-        destroy_empty(map);
-    }
-
-    #[test]
-    public fun test_add_all() {
-        let map = create<u64, u64>();
-
-        assert!(length(&map) == 0, 0);
-        add_all(&mut map, vector[1, 2, 3], vector[10, 20, 30]);
-        assert!(length(&map) == 3, 1);
-        assert!(borrow(&map, &1) == &10, 2);
-        assert!(borrow(&map, &2) == &20, 3);
-        assert!(borrow(&map, &3) == &30, 4);
-
-        remove(&mut map, &1);
-        remove(&mut map, &2);
-        remove(&mut map, &3);
-        destroy_empty(map);
-    }
-
-    #[test]
-    public fun test_keys() {
-        let map = create<u64, u64>();
-        assert!(keys(&map) == vector[], 0);
-        add(&mut map, 2, 1);
-        add(&mut map, 3, 1);
-
-        assert!(keys(&map) == vector[2, 3], 0);
-    }
-
-    #[test]
-    public fun test_values() {
-        let map = create<u64, u64>();
-        assert!(values(&map) == vector[], 0);
-        add(&mut map, 2, 1);
-        add(&mut map, 3, 2);
-
-        assert!(values(&map) == vector[1, 2], 0);
-    }
-
-    #[test]
-    #[expected_failure]
-    public fun test_add_twice() {
-        let map = create<u64, u64>();
-        add(&mut map, 3, 1);
-        add(&mut map, 3, 1);
-
-        remove(&mut map, &3);
-        destroy_empty(map);
-    }
-
-    #[test]
-    #[expected_failure]
-    public fun test_remove_twice() {
-        let map = create<u64, u64>();
-        add(&mut map, 3, 1);
-        remove(&mut map, &3);
-        remove(&mut map, &3);
-
-        destroy_empty(map);
-    }
-
-    #[test]
-    public fun test_upsert_test() {
-        let map = create<u64, u64>();
-        // test adding 3 elements using upsert
-        upsert<u64, u64>(&mut map, 1, 1);
-        upsert(&mut map, 2, 2);
-        upsert(&mut map, 3, 3);
-
-        assert!(length(&map) == 3, 0);
-        assert!(contains_key(&map, &1), 1);
-        assert!(contains_key(&map, &2), 2);
-        assert!(contains_key(&map, &3), 3);
-        assert!(borrow(&map, &1) == &1, 4);
-        assert!(borrow(&map, &2) == &2, 5);
-        assert!(borrow(&map, &3) == &3, 6);
-
-        // change mapping 1->1 to 1->4
-        upsert(&mut map, 1, 4);
-
-        assert!(length(&map) == 3, 7);
-        assert!(contains_key(&map, &1), 8);
-        assert!(borrow(&map, &1) == &4, 9);
-    }
-}