create-dubhe 0.1.13 → 1.2.0-pre.51

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

@@ -1,112 +0,0 @@
-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

@@ -1,153 +0,0 @@
-/// 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

@@ -1,265 +0,0 @@
-/// 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
-        );
-    }
-}