create-dubhe 0.0.8 → 0.0.10

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/InitiaStdlib/query.move

@@ -0,0 +1,112 @@
+module initia_std::query {
+    use initia_std::string::{Self, String};
+    use initia_std::json;
+
+    /*
+    type QueryProposalResponse struct {
+        Proposal *Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"`
+    }
+
+    type Proposal struct {
+        Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
+        Messages []*types1.Any `protobuf:"bytes,2,rep,name=messages,proto3" json:"messages,omitempty"`
+        Status v1.ProposalStatus `protobuf:"varint,3,opt,name=status,proto3,enum=cosmos.gov.v1.ProposalStatus" json:"status,omitempty"`
+        FinalTallyResult *v1.TallyResult `protobuf:"bytes,4,opt,name=final_tally_result,json=finalTallyResult,proto3" json:"final_tally_result,omitempty"`
+        SubmitTime *time.Time `protobuf:"bytes,5,opt,name=submit_time,json=submitTime,proto3,stdtime" json:"submit_time,omitempty"`
+        DepositEndTime *time.Time `protobuf:"bytes,6,opt,name=deposit_end_time,json=depositEndTime,proto3,stdtime" json:"deposit_end_time,omitempty"`
+        TotalDeposit []types.Coin `protobuf:"bytes,7,rep,name=total_deposit,json=totalDeposit,proto3" json:"total_deposit"`
+        VotingStartTime *time.Time `protobuf:"bytes,8,opt,name=voting_start_time,json=votingStartTime,proto3,stdtime" json:"voting_start_time,omitempty"`
+        VotingEndTime          *time.Time `protobuf:"bytes,9,opt,name=voting_end_time,json=votingEndTime,proto3,stdtime" json:"voting_end_time,omitempty"`
+        EmergencyStartTime     *time.Time `protobuf:"bytes,10,opt,name=emergency_start_time,json=emergencyStartTime,proto3,stdtime" json:"emergency_start_time,omitempty"`
+        EmergencyNextTallyTime *time.Time `protobuf:"bytes,11,opt,name=emergency_next_tally_time,json=emergencyNextTallyTime,proto3,stdtime" json:"emergency_next_tally_time,omitempty"`
+        Metadata string `protobuf:"bytes,12,opt,name=metadata,proto3" json:"metadata,omitempty"`
+
+        Title string `protobuf:"bytes,13,opt,name=title,proto3" json:"title,omitempty"`
+
+        Summary string `protobuf:"bytes,14,opt,name=summary,proto3" json:"summary,omitempty"`
+
+        Proposer string `protobuf:"bytes,15,opt,name=proposer,proto3" json:"proposer,omitempty"`
+
+        Expedited bool `protobuf:"varint,16,opt,name=expedited,proto3" json:"expedited,omitempty"`
+        Emergency bool `protobuf:"varint,17,opt,name=emergency,proto3" json:"emergency,omitempty"`
+
+        FailedReason string `protobuf:"bytes,18,opt,name=failed_reason,json=failedReason,proto3" json:"failed_reason,omitempty"`
+    }
+
+    */
+
+    struct ProposalRequest has copy, drop {
+        proposal_id: u64
+    }
+
+    struct ProposalResponse has copy, drop {
+        id: u64,
+        title: String,
+        summary: String,
+        status: String,
+        submit_time: String,
+        emergency: bool
+    }
+
+    #[view]
+    public fun get_proposal(proposal_id: u64): (u64, String, String, String) {
+        let response =
+            query_stargate(
+                b"/initia.gov.v1.Query/Proposal",
+                json::marshal(&ProposalRequest { proposal_id })
+            );
+        let res = json::unmarshal<ProposalResponse>(response);
+        (res.id, res.title, res.summary, string::utf8(response))
+    }
+
+    #[view]
+    public fun get_proposal_status(proposal_id: u64): (u64, String, String, bool) {
+        let response =
+            query_stargate(
+                b"/initia.gov.v1.Query/Proposal",
+                json::marshal(&ProposalRequest { proposal_id })
+            );
+        let res = json::unmarshal<ProposalResponse>(response);
+        (res.id, res.status, res.submit_time, res.emergency)
+    }
+
+    /// query_custom examples are in initia_stdlib::address module
+    native public fun query_custom(name: vector<u8>, data: vector<u8>): vector<u8>;
+    native public fun query_stargate(path: vector<u8>, data: vector<u8>): vector<u8>;
+
+    #[test_only]
+    native public fun set_query_response(
+        path_or_name: vector<u8>, data: vector<u8>, response: vector<u8>
+    );
+
+    #[test_only]
+    native public fun unset_query_response(
+        path_or_name: vector<u8>, data: vector<u8>
+    );
+
+    #[test]
+    fun test_query_custom() {
+        set_query_response(b"path", b"data123", b"output");
+
+        let res = query_custom(b"path", b"data123");
+        assert!(res == b"output", 0);
+    }
+
+    #[test]
+    fun test_query_stargate() {
+        set_query_response(b"path", b"data123", b"output");
+
+        let res = query_stargate(b"path", b"data123");
+        assert!(res == b"output", 0);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = 0x1006E, location = Self)]
+    fun test_query_unsset() {
+        set_query_response(b"path", b"data123", b"output");
+        unset_query_response(b"path", b"data123");
+
+        let res = query_custom(b"path", b"data123");
+        assert!(res == b"", 0);
+    }
+}

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/InitiaStdlib/royalty.move

@@ -0,0 +1,153 @@
+/// This defines an object-based Royalty. The royalty can be applied to either a collection or a
+/// nft. Applications should read the royalty from the nft, as it will read the appropriate
+/// royalty.
+module initia_std::royalty {
+    use std::error;
+    use std::option::{Self, Option};
+    use initia_std::bigdecimal::{Self, BigDecimal};
+    use initia_std::object::{Self, ConstructorRef, ExtendRef, Object};
+
+    friend initia_std::nft;
+
+    /// Royalty does not exist
+    const EROYALTY_DOES_NOT_EXIST: u64 = 1;
+    /// The royalty cannot be greater than 100%
+    const EROYALTY_EXCEEDS_MAXIMUM: u64 = 2;
+    /// The royalty denominator cannot be 0
+    const EROYALTY_DENOMINATOR_IS_ZERO: u64 = 3;
+
+    /// The royalty of a nft within this collection
+    ///
+    /// Royalties are optional for a collection.
+    struct Royalty has copy, drop, key {
+        royalty: BigDecimal,
+        /// creators.
+        payee_address: address
+    }
+
+    /// This enables creating or overwriting a `MutatorRef`.
+    struct MutatorRef has drop, store {
+        inner: ExtendRef
+    }
+
+    /// Add a royalty, given a ConstructorRef.
+    public fun init(ref: &ConstructorRef, royalty: Royalty) {
+        let signer = object::generate_signer(ref);
+        move_to(&signer, royalty);
+    }
+
+    /// Set the royalty if it does not exist, replace it otherwise.
+    public fun update(mutator_ref: &MutatorRef, royalty: Royalty) acquires Royalty {
+        let addr = object::address_from_extend_ref(&mutator_ref.inner);
+        if (exists<Royalty>(addr)) {
+            move_from<Royalty>(addr);
+        };
+
+        let signer = object::generate_signer_for_extending(&mutator_ref.inner);
+        move_to(&signer, royalty);
+    }
+
+    /// Creates a new royalty, verifying that it is a valid percentage
+    public fun create(royalty: BigDecimal, payee_address: address): Royalty {
+        assert!(
+            bigdecimal::le(royalty, bigdecimal::one()),
+            error::out_of_range(EROYALTY_EXCEEDS_MAXIMUM)
+        );
+
+        Royalty { royalty, payee_address }
+    }
+
+    public fun generate_mutator_ref(ref: ExtendRef): MutatorRef {
+        MutatorRef { inner: ref }
+    }
+
+    public fun exists_at(addr: address): bool {
+        exists<Royalty>(addr)
+    }
+
+    public(friend) fun delete(addr: address) acquires Royalty {
+        assert!(
+            exists<Royalty>(addr),
+            error::not_found(EROYALTY_DOES_NOT_EXIST)
+        );
+        move_from<Royalty>(addr);
+    }
+
+    // Accessors
+    public fun get<T: key>(maybe_royalty: Object<T>): Option<Royalty> acquires Royalty {
+        let obj_addr = object::object_address(&maybe_royalty);
+        if (exists<Royalty>(obj_addr)) {
+            option::some(*borrow_global<Royalty>(obj_addr))
+        } else {
+            option::none()
+        }
+    }
+
+    public fun royalty(royalty: &Royalty): BigDecimal {
+        royalty.royalty
+    }
+
+    public fun payee_address(royalty: &Royalty): address {
+        royalty.payee_address
+    }
+
+    #[test(creator = @0x123)]
+    fun test_none(creator: &signer) acquires Royalty {
+        let constructor_ref = object::create_named_object(creator, b"");
+        let object =
+            object::object_from_constructor_ref<object::ObjectCore>(&constructor_ref);
+        assert!(option::none() == get(object), 0);
+    }
+
+    #[test(creator = @0x123)]
+    fun test_init_and_update(creator: &signer) acquires Royalty {
+        let constructor_ref = object::create_named_object(creator, b"");
+        let object =
+            object::object_from_constructor_ref<object::ObjectCore>(&constructor_ref);
+        let init_royalty = create(bigdecimal::from_ratio_u64(1, 2), @0x123);
+        init(&constructor_ref, init_royalty);
+        assert!(option::some(init_royalty) == get(object), 0);
+        assert!(
+            royalty(&init_royalty) == bigdecimal::from_ratio_u64(1, 2),
+            1
+        );
+        assert!(payee_address(&init_royalty) == @0x123, 2);
+
+        let mutator_ref =
+            generate_mutator_ref(object::generate_extend_ref(&constructor_ref));
+        let update_royalty = create(bigdecimal::from_ratio_u64(2, 5), @0x456);
+        update(&mutator_ref, update_royalty);
+        assert!(option::some(update_royalty) == get(object), 3);
+        assert!(
+            royalty(&update_royalty) == bigdecimal::from_ratio_u64(2, 5),
+            4
+        );
+        assert!(payee_address(&update_royalty) == @0x456, 5);
+    }
+
+    #[test(creator = @0x123)]
+    fun test_update_only(creator: &signer) acquires Royalty {
+        let constructor_ref = object::create_named_object(creator, b"");
+        let object =
+            object::object_from_constructor_ref<object::ObjectCore>(&constructor_ref);
+        assert!(option::none() == get(object), 0);
+
+        let mutator_ref =
+            generate_mutator_ref(object::generate_extend_ref(&constructor_ref));
+        let update_royalty = create(bigdecimal::from_ratio_u64(1, 5), @0x123);
+        update(&mutator_ref, update_royalty);
+        assert!(option::some(update_royalty) == get(object), 1);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = 0x60001, location = Self)]
+    fun test_does_not_exist() acquires Royalty {
+        delete(@0x1);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = 0x20002, location = Self)]
+    fun test_exceeds_maximum() {
+        create(bigdecimal::from_ratio_u64(6, 5), @0x1);
+    }
+}

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/InitiaStdlib/secp256k1.move

@@ -0,0 +1,265 @@
+/// This module implements ECDSA signatures based on the prime-order secp256k1 ellptic curve (i.e., cofactor is 1).
+
+module initia_std::secp256k1 {
+    use std::option::Option;
+
+    //
+    // Error codes
+    //
+
+    /// 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.
+
+    //
+    // constants
+    //
+
+    /// The size of a secp256k1-based ECDSA public key, in bytes.
+    const RAW_PUBLIC_KEY_NUM_BYTES: u64 = 64;
+
+    /// The size of a secp256k1-based ECDSA compressed public key, in bytes.
+    const COMPRESSED_PUBLIC_KEY_SIZE: u64 = 33;
+
+    /// The size of a secp256k1-based ECDSA signature, in bytes.
+    const SIGNATURE_NUM_BYTES: u64 = 64;
+
+    /// The size of a hashed message for secp256k1-based ECDSA signing
+    const MESSAGE_SIZE: u64 = 32;
+
+    /// A 64-byte ECDSA public key.
+    struct ECDSARawPublicKey has copy, drop, store {
+        bytes: vector<u8>
+    }
+
+    /// A 33-byte ECDSA public key.
+    struct ECDSACompressedPublicKey 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 {
+        ecdsa_raw_public_key_from_bytes(bytes)
+    }
+
+    /// Constructs an ECDSARawPublicKey struct, given a 64-byte raw representation.
+    public fun ecdsa_raw_public_key_from_bytes(bytes: vector<u8>): ECDSARawPublicKey {
+        assert!(
+            std::vector::length(&bytes) == RAW_PUBLIC_KEY_NUM_BYTES,
+            std::error::invalid_argument(E_DESERIALIZE)
+        );
+        ECDSARawPublicKey { bytes }
+    }
+
+    /// Constructs an ECDSACompressedPublicKey struct, given a 33-byte raw representation.
+    public fun ecdsa_compressed_public_key_from_bytes(bytes: vector<u8>):
+        ECDSACompressedPublicKey {
+        assert!(
+            std::vector::length(&bytes) == COMPRESSED_PUBLIC_KEY_SIZE,
+            std::error::invalid_argument(E_DESERIALIZE)
+        );
+        ECDSACompressedPublicKey { bytes }
+    }
+
+    /// Serializes an ECDSARawPublicKey struct to 64-bytes.
+    public fun ecdsa_raw_public_key_to_bytes(pk: &ECDSARawPublicKey): vector<u8> {
+        pk.bytes
+    }
+
+    /// Serializes an ECDSARawPublicKey struct to 64-bytes.
+    public fun ecdsa_compressed_public_key_to_bytes(
+        pk: &ECDSACompressedPublicKey
+    ): vector<u8> {
+        pk.bytes
+    }
+
+    /// Serializes an ECDSASignature struct to 64-bytes.
+    public fun ecdsa_signature_to_bytes(sig: &ECDSASignature): vector<u8> {
+        sig.bytes
+    }
+
+    /// Returns `true` if the signature can verify the public key on the message
+    public fun verify(
+        message: vector<u8>,
+        public_key: &ECDSACompressedPublicKey,
+        signature: &ECDSASignature
+    ): bool {
+        assert!(
+            std::vector::length(&message) == MESSAGE_SIZE,
+            std::error::invalid_argument(E_DESERIALIZE)
+        );
+
+        return verify_internal(message, public_key.bytes, signature.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> {
+        assert!(
+            std::vector::length(&message) == MESSAGE_SIZE,
+            std::error::invalid_argument(E_DESERIALIZE)
+        );
+
+        let (pk, success) =
+            recover_public_key_internal(recovery_id, message, signature.bytes, false);
+        if (success) {
+            std::option::some(ecdsa_raw_public_key_from_bytes(pk))
+        } else {
+            std::option::none<ECDSARawPublicKey>()
+        }
+    }
+
+    /// 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_compressed(
+        message: vector<u8>, recovery_id: u8, signature: &ECDSASignature
+    ): Option<ECDSACompressedPublicKey> {
+        assert!(
+            std::vector::length(&message) == MESSAGE_SIZE,
+            std::error::invalid_argument(E_DESERIALIZE)
+        );
+
+        let (pk, success) =
+            recover_public_key_internal(recovery_id, message, signature.bytes, true);
+        if (success) {
+            std::option::some(ecdsa_compressed_public_key_from_bytes(pk))
+        } else {
+            std::option::none<ECDSACompressedPublicKey>()
+        }
+    }
+
+    //
+    // Native functions
+    //
+
+    /// Returns `true` if `signature` verifies on `public_key` and `message`
+    /// and returns `false` otherwise.
+    ///
+    /// - `message`: A 32-byte hashed message.
+    /// - `public_key`: A compressed public key in bytes.
+    /// - `signature`: A 64-byte ECDSA signature.
+    native fun verify_internal(
+        message: vector<u8>, public_key: vector<u8>, signature: vector<u8>
+    ): bool;
+
+    /// Returns `(public_key, true)` if `signature` verifies on `message` under the recovered `public_key`
+    /// and returns `([], false)` otherwise.
+    native fun recover_public_key_internal(
+        recovery_id: u8,
+        message: vector<u8>,
+        signature: vector<u8>,
+        compressed: bool
+    ): (vector<u8>, bool);
+
+    #[test_only]
+    /// Generates an secp256k1 ECDSA key pair.
+    native public fun generate_keys(compressed: bool): (vector<u8>, vector<u8>);
+
+    #[test_only]
+    /// Generates an secp256k1 ECDSA signature for a given byte array using a given signing key.
+    native public fun sign(message: vector<u8>, secrete_key: vector<u8>): (u8, vector<u8>);
+
+    //
+    // Tests
+    //
+
+    #[test]
+    fun test_secp256k1_sign_verify() {
+        use std::hash;
+
+        let (sk, vk) = generate_keys(true);
+        let pk = ecdsa_compressed_public_key_from_bytes(vk);
+
+        let msg: vector<u8> = hash::sha2_256(b"test initia secp256k1");
+        let (_rid, sig_bytes) = sign(msg, sk);
+        let sig = ecdsa_signature_from_bytes(sig_bytes);
+        assert!(verify(msg, &pk, &sig), 1);
+
+        // Test with an incorrect message
+        let wrong_msg: vector<u8> = hash::sha2_256(b"wrong message");
+        assert!(!verify(wrong_msg, &pk, &sig), 2);
+
+        // Test with an incorrect signature
+        let invalid_sig_bytes = sig_bytes;
+        *std::vector::borrow_mut(&mut invalid_sig_bytes, 0) = *std::vector::borrow(
+            &invalid_sig_bytes, 0
+        ) ^ 0x1; // Corrupt the signature
+        let invalid_sig = ecdsa_signature_from_bytes(invalid_sig_bytes);
+        assert!(!verify(msg, &pk, &invalid_sig), 3);
+    }
+
+    #[test]
+    fun test_gen_sign_recover() {
+        use std::hash;
+
+        let (sk, vk) = generate_keys(false);
+        let pk = ecdsa_raw_public_key_from_bytes(vk);
+
+        let msg: vector<u8> = hash::sha2_256(b"test initia secp256k1");
+        let (rid, sig_bytes) = sign(msg, sk);
+        let sig = ecdsa_signature_from_bytes(sig_bytes);
+        let recovered_pk = ecdsa_recover(msg, rid, &sig);
+        assert!(std::option::is_some(&recovered_pk), 1);
+        assert!(
+            std::option::extract(&mut recovered_pk).bytes == pk.bytes,
+            2
+        );
+
+        let wrong_msg: vector<u8> = hash::sha2_256(b"test initia");
+        let recovered_pk = ecdsa_recover(wrong_msg, rid, &sig);
+        assert!(std::option::is_some(&recovered_pk), 3);
+        assert!(
+            std::option::extract(&mut recovered_pk).bytes != pk.bytes,
+            4
+        );
+    }
+
+    #[test]
+    fun test_gen_sign_recover_compressed() {
+        use std::hash;
+
+        let (sk, vk) = generate_keys(true);
+        let pk = ecdsa_compressed_public_key_from_bytes(vk);
+
+        let msg: vector<u8> = hash::sha2_256(b"test initia secp256k1");
+        let (rid, sig_bytes) = sign(msg, sk);
+        let sig = ecdsa_signature_from_bytes(sig_bytes);
+        let recovered_pk = ecdsa_recover_compressed(msg, rid, &sig);
+        assert!(std::option::is_some(&recovered_pk), 1);
+        assert!(
+            std::option::extract(&mut recovered_pk).bytes == pk.bytes,
+            2
+        );
+
+        let wrong_msg: vector<u8> = hash::sha2_256(b"test initia");
+        let recovered_pk = ecdsa_recover_compressed(wrong_msg, rid, &sig);
+        assert!(std::option::is_some(&recovered_pk), 3);
+        assert!(
+            std::option::extract(&mut recovered_pk).bytes != pk.bytes,
+            4
+        );
+    }
+}