diff --git a/c-pallets/file-bank/src/lib.rs b/c-pallets/file-bank/src/lib.rs index c2669d3a..d6256793 100755 --- a/c-pallets/file-bank/src/lib.rs +++ b/c-pallets/file-bank/src/lib.rs @@ -405,19 +405,17 @@ pub mod pallet { #[pallet::call] impl Pallet { - /// Users need to make a declaration before uploading files. + /// Upload Declaration of Data Storage /// - /// This method is used to declare the file to be uploaded. - /// If the file already exists on the chain, - /// the user directly becomes one of the holders of the file - /// If the file does not exist, after declaring the file, - /// wait for the dispatcher to upload the meta information of the file - /// - /// The dispatch origin of this call must be _Signed_. + /// This function allows a user to upload a declaration for data storage, specifying the file's metadata, + /// deal information, and ownership details. It is used to initiate the storage process of a file. /// /// Parameters: - /// - `file_hash`: Hash of the file to be uploaded. - /// - `file_name`: User defined file name. + /// - `origin`: The origin of the transaction. + /// - `file_hash`: The unique hash identifier of the file. + /// - `deal_info`: A list of segment details for data storage. + /// - `user_brief`: A brief description of the user and the file's ownership. + /// - `file_size`: The size of the file in bytes. #[pallet::call_index(0)] #[transactional] #[pallet::weight(::WeightInfo::upload_declaration(deal_info.len() as u32))] @@ -472,6 +470,17 @@ pub mod pallet { Ok(()) } + /// Reassign Miners for a Storage Deal + /// + /// This function is used to reassign miners for an existing storage deal. It is typically called when a deal + /// needs to be modified or if the storage task fails for some miners in the deal. The function allows reassigning + /// miners to ensure the storage deal is fulfilled within the specified parameters. + /// + /// Parameters: + /// - `origin`: The origin of the transaction, expected to be a root/administrator account. + /// - `deal_hash`: The unique hash identifier of the storage deal. + /// - `count`: The new count (number of miners) for the storage deal. Must be less than or equal to 20. + /// - `life`: The duration (in blocks) for which the storage deal will remain active. #[pallet::call_index(1)] // #[transactional] #[pallet::weight( @@ -525,21 +534,17 @@ pub mod pallet { Ok(()) } - /// Transfer needs to be restricted, such as target consent - /// Document ownership transfer function. - /// - /// You can replace Alice, the holder of the file, with Bob. At the same time, - /// Alice will lose the ownership of the file and release the corresponding use space. - /// Bob will get the ownership of the file and increase the corresponding use space + + /// Transfer Ownership of a File /// - /// Premise: - /// - Alice has ownership of the file - /// - Bob has enough space and corresponding bucket + /// This function allows the owner of a file to transfer ownership to another account. The file is identified by its unique + /// `file_hash`, and the ownership is transferred to the target user specified in the `target_brief`. The sender of the + /// transaction must be the current owner of the file. /// /// Parameters: - /// - `owner_bucket_name`: Origin stores the bucket name corresponding to the file - /// - `target_brief`: Information about the transfer object - /// - `file_hash`: File hash, which is also the unique identifier of the file + /// - `origin`: The origin of the transaction, representing the current owner of the file. + /// - `target_brief`: User brief information of the target user to whom ownership is being transferred. + /// - `file_hash`: The unique hash identifier of the file to be transferred #[pallet::call_index(2)] #[transactional] #[pallet::weight(1_000_000_000)] @@ -593,17 +598,16 @@ pub mod pallet { Ok(()) } - /// Upload info of stored file. - /// - /// The dispatch origin of this call must be _Signed_. + + /// Transfer Report for a Storage Deal /// - /// The same file will only upload meta information once, - /// which will be uploaded by consensus. + /// This function allows miners participating in a storage deal to report that they have successfully stored the data segments. + /// A storage deal is identified by its unique `deal_hash`. Miners who are part of the deal and have successfully stored their assigned + /// data segments can call this function to report completion. /// /// Parameters: - /// - `file_hash`: The beneficiary related to signer account. - /// - `file_size`: File size calculated by consensus. - /// - `slice_info`: List of file slice information. + /// - `origin`: The origin of the transaction, representing the reporting miner. + /// - `deal_hash`: The unique hash identifier of the storage deal being reported. #[pallet::call_index(3)] // #[transactional] #[pallet::weight(::WeightInfo::transfer_report(Pallet::::get_segment_length_from_deal(&deal_hash)))] @@ -686,6 +690,13 @@ pub mod pallet { Ok(()) } + /// Calculate End of a Storage Deal + /// + /// This function is used to finalize a storage deal and mark it as successfully completed. + /// + /// Parameters: + /// - `origin`: The root origin, which authorizes administrative operations. + /// - `deal_hash`: The unique hash identifier of the storage deal to be finalized. #[pallet::call_index(4)] #[transactional] #[pallet::weight(::WeightInfo::calculate_end(Pallet::::get_segment_length_from_deal(&deal_hash)))] @@ -722,6 +733,16 @@ pub mod pallet { Ok(()) } + /// Replace Idle Space + /// + /// This function allows a signed user to replace their idle storage space. + /// + /// Parameters: + /// - `origin`: The origin of the transaction. + /// - `idle_sig_info`: Space proof information associated with the idle space to be replaced. + /// - `tee_sig`: A signature from the TEE (Trusted Execution Environment) used to verify the idle space replacement. + /// + /// The function ensures that the caller has enough pending space to perform the replacement. #[pallet::call_index(5)] #[transactional] #[pallet::weight(::WeightInfo::replace_idle_space())] @@ -765,6 +786,14 @@ pub mod pallet { Ok(()) } + /// Delete File + /// + /// This function allows an authorized user to delete a file associated with a specific storage hash. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. + /// - `owner`: The owner of the file, representing the user who has permission to delete the file. + /// - `file_hash`: The unique hash identifier of the file to be deleted. #[pallet::call_index(6)] #[transactional] #[pallet::weight({ @@ -785,16 +814,16 @@ pub mod pallet { Ok(()) } - /// Upload idle files for miners. - /// - /// The dispatch origin of this call must be _Signed_. + + /// Certify Idle Space /// - /// Upload up to ten idle files for one transaction. - /// Currently, the size of each idle file is fixed at 8MiB. + /// This function allows a user to certify their idle storage space by providing + /// a proof of their idle space's integrity and availability. /// /// Parameters: - /// - `miner`: For which miner, miner's wallet address. - /// - `filler_list`: Meta information list of idle files. + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. + /// - `idle_sig_info`: Information about the idle space, including the accumulator and rear values. + /// - `tee_sig`: A cryptographic signature provided by a Trusted Execution Environment (TEE) to verify the proof. #[pallet::call_index(8)] #[transactional] #[pallet::weight(::WeightInfo::cert_idle_space())] @@ -826,6 +855,14 @@ pub mod pallet { Ok(()) } + /// Create a Data Storage Bucket + /// + /// This function allows a user with appropriate permissions to create a new data storage bucket. + /// + /// Parameters: + /// - `origin`: The origin of the transaction. + /// - `owner`: The account identifier of the bucket owner. + /// - `name`: The name of the new bucket. #[pallet::call_index(11)] #[transactional] #[pallet::weight(::WeightInfo::create_bucket())] @@ -848,6 +885,15 @@ pub mod pallet { Ok(()) } + /// Delete a Bucket + /// + /// This function allows a user to delete an empty storage bucket that they own. + /// Deleting a bucket is only possible if it contains no files. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. + /// - `owner`: The owner's account for whom the bucket should be deleted. + /// - `name`: The name of the bucket to be deleted. #[pallet::call_index(12)] #[transactional] #[pallet::weight(::WeightInfo::delete_bucket())] @@ -883,7 +929,15 @@ pub mod pallet { Ok(()) } - // restoral file + /// Generate a Restoration Order + /// + /// This function allows a user to generate a restoration order for a specific fragment of a file. + /// A restoration order is used to request the restoration of a lost or corrupted fragment from the network. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. + /// - `file_hash`: The hash of the file that the fragment belongs to. + /// - `restoral_fragment`: The hash of the fragment to be restored. #[pallet::call_index(13)] #[transactional] #[pallet::weight(::WeightInfo::generate_restoral_order())] @@ -931,6 +985,15 @@ pub mod pallet { }) } + /// Claim a Restoration Order + /// + /// This function allows a network miner to claim a restoration order for a specific fragment of a file. + /// A restoration order is generated when a user requests the restoration of a lost or corrupted fragment. + /// Miners can claim these orders to provide the requested fragments. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. This function can only be called by authorized miners. + /// - `restoral_fragment`: The hash of the fragment associated with the restoration order to be claimed. #[pallet::call_index(14)] #[transactional] #[pallet::weight(::WeightInfo::claim_restoral_order())] @@ -961,6 +1024,17 @@ pub mod pallet { Ok(()) } + /// Claim a Non-Existent Restoration Order + /// + /// This function allows an authorized network miner to claim a non-existent restoration order. + /// A non-existent restoration order is generated when a user requests the restoration of a lost or corrupted fragment, + /// but the corresponding restoration order does not exist. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. This function can only be called by authorized miners. + /// - `miner`: The miner's account that claims the non-existent restoration order. + /// - `file_hash`: The hash of the file associated with the non-existent restoration order. + /// - `restoral_fragment`: The hash of the fragment for which the non-existent restoration order is being claimed. #[pallet::call_index(15)] #[transactional] #[pallet::weight(::WeightInfo::claim_restoral_noexist_order())] @@ -1021,6 +1095,16 @@ pub mod pallet { Ok(()) } + /// Complete a Restoration Order + /// + /// This function allows authorized network miners to complete a restoration order, + /// indicating that they have successfully restored a fragment to its original state. + /// Restoration orders are generated when users request the restoration of lost or corrupted fragments. + /// Miners claim these orders and provide the requested fragments for restoration. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. This function can only be called by authorized miners. + /// - `fragment_hash`: The hash of the fragment to be restored, for which the restoration order is being completed. #[pallet::call_index(16)] #[transactional] #[pallet::weight(::WeightInfo::restoral_order_complete())] diff --git a/c-pallets/oss/src/lib.rs b/c-pallets/oss/src/lib.rs index 73d2466e..4d56e83b 100644 --- a/c-pallets/oss/src/lib.rs +++ b/c-pallets/oss/src/lib.rs @@ -88,6 +88,15 @@ pub mod pallet { #[pallet::call] impl Pallet { + + /// Authorize Operator + /// + /// This function allows an account to authorize another account as an operator, + /// granting them specific permissions or access rights to perform actions on behalf of the authorizing account. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the authorizing account. + /// - `operator`: The account that will be authorized as an operator by the authorizing account. #[pallet::call_index(0)] #[transactional] #[pallet::weight(::WeightInfo::authorize())] @@ -110,6 +119,14 @@ pub mod pallet { Ok(()) } + /// Cancel Authorization + /// + /// This function allows an account to cancel the authorization of another account (operator), + /// revoking the operator's permissions or access rights to perform actions on behalf of the authorizing account. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the authorizing account. + /// - `oss`: The account for which the authorization is canceled by the authorizing account. #[pallet::call_index(1)] #[transactional] #[pallet::weight(::WeightInfo::cancel_authorize())] @@ -131,6 +148,16 @@ pub mod pallet { Ok(()) } + /// Register an OSS + /// + /// This function allows an account to register as an OSS in the pallet. + /// An OSS is a service provider that offers its services via a defined endpoint. + /// Registering as an OSS enables the account to make its services accessible to other users and be authorized for certain actions. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the account registering as an OSS. + /// - `endpoint`: The unique peer ID or endpoint that identifies the OSS and its services. + /// - `domain`: A bounded vector of up to 50 bytes representing the domain or description of the OSS. #[pallet::call_index(2)] #[transactional] #[pallet::weight(::WeightInfo::register())] @@ -148,6 +175,17 @@ pub mod pallet { Ok(()) } + /// Update OSS Information + /// + /// This function allows a registered OSS to update its information, + /// including its endpoint and domain. + /// An OSS is a service provider that offers its services via a defined endpoint. + /// This function enables the OSS to modify its endpoint and provide an updated description of its services. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the registered OSS that wishes to update its information. + /// - `endpoint`: The new unique peer ID or endpoint that identifies the OSS and its services. + /// - `domain`: A bounded vector of up to 50 bytes representing the updated domain or description of the OSS's services. #[pallet::call_index(3)] #[transactional] #[pallet::weight(::WeightInfo::update())] @@ -167,6 +205,14 @@ pub mod pallet { Ok(()) } + /// Destroy OSS Registration + /// + /// This function allows a registered OSS to voluntarily destroy its registration, + /// effectively unregistering from the system. Once an OSS is unregistered, + /// it will no longer be recognized as a valid service provider. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the registered OSS that wishes to destroy its registration. #[pallet::call_index(4)] #[transactional] #[pallet::weight(::WeightInfo::destroy())] diff --git a/c-pallets/sminer/src/lib.rs b/c-pallets/sminer/src/lib.rs index 4dc0c4dd..f7f8a1a3 100644 --- a/c-pallets/sminer/src/lib.rs +++ b/c-pallets/sminer/src/lib.rs @@ -294,14 +294,19 @@ pub mod pallet { #[pallet::call] impl Pallet { - /// Staking and register for storage miner. + /// Register as a Miner and Stake Collateral /// - /// The dispatch origin of this call must be _Signed_. + /// This function allows an account to register as a Miner in the network and stake a certain amount of collateral to participate in the mining process. + /// The registration also includes specifying a beneficiary account, providing a unique peer ID for network identification, + /// and submitting a proof of space (PoS) key along with a TeeRSA signature for verification. /// /// Parameters: - /// - `beneficiary`: The beneficiary related to signer account. - /// - `ip`: The registered IP of storage miner. - /// - `staking_val`: The number of staking. + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the account that wishes to register as a Miner. + /// - `beneficiary`: The account that will receive the rewards for mining. + /// - `peer_id`: A unique identifier for the Miner on the network. + /// - `staking_val`: The amount of collateral that the Miner is staking to participate in mining. + /// - `pois_key`: The PoS key provided by the Miner. + /// - `tee_sig`: A TeeRSA signature for verifying the authenticity of the PoS key. #[pallet::call_index(0)] #[transactional] #[pallet::weight(::WeightInfo::regnstk())] @@ -374,10 +379,15 @@ pub mod pallet { Ok(()) } - /// Increase the miner collateral. + + /// Increase Collateral and Update Miner's State + /// + /// This function allows a registered Miner to increase their staked collateral. + /// The additional collateral is used to support the Miner's participation in the network and may affect the Miner's state. /// /// Parameters: - /// - `collaterals`: Miner's TCESS. + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the account that is a registered Miner. + /// - `collaterals`: The amount of additional collateral the Miner wants to stake. It is specified as a `BalanceOf` value, typically a token balance(Miner's TCESS). #[pallet::call_index(1)] #[transactional] #[pallet::weight(::WeightInfo::increase_collateral())] @@ -431,10 +441,14 @@ pub mod pallet { Ok(()) } - /// update miner beneficiary. + /// Update Miner's Beneficiary Account + /// + /// This function allows a registered Miner to update their beneficiary account. + /// The beneficiary account is the recipient of the Miner's rewards and earnings from the network. /// /// Parameters: - /// - `beneficiary`: The beneficiary related to signer account. + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the account that is a registered Miner. + /// - `beneficiary`: The new beneficiary account to be associated with the Miner. #[pallet::call_index(2)] #[transactional] #[pallet::weight(::WeightInfo::update_beneficiary())] @@ -455,10 +469,13 @@ pub mod pallet { Ok(()) } - /// update miner IP. + /// Update Miner's Peer ID + /// + /// This function allows a registered Miner to update their Peer ID, which is used for network communication and connectivity. /// /// Parameters: - /// - `ip`: The registered IP of storage miner. + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the account that is a registered Miner. + /// - `peer_id`: The new Peer ID to be associated with the Miner for network communication. #[pallet::call_index(3)] #[transactional] #[pallet::weight(::WeightInfo::update_peer_id())] @@ -477,6 +494,14 @@ pub mod pallet { Ok(()) } + + /// Receive Miner's Reward + /// + /// This function allows a registered Miner in a positive state to receive their available rewards from the reward pool. + /// It transfers the rewards to the Miner's beneficiary. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the account of a registered Miner. #[pallet::call_index(6)] #[transactional] #[pallet::weight(100_000_000_000)] @@ -515,7 +540,15 @@ pub mod pallet { Ok(()) } - // The lock in time must be greater than the survival period of the challenge + /// Prepare Miner Exit + /// + /// This function allows a registered Miner to initiate the process of exiting the system gracefully. + /// It transitions the Miner from a positive state to a locked state, effectively preparing for the exit. + /// During the locked state, the Miner's resources will be locked for a specific period, + /// ensuring that they fulfill any existing challenges before they can exit completely. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, this is the account of a registered Miner. #[pallet::call_index(7)] #[transactional] #[pallet::weight(::WeightInfo::miner_exit_prep())] @@ -562,6 +595,15 @@ pub mod pallet { Ok(()) } + /// Miner Exit + /// + /// This function allows a privileged entity, typically a root user, + /// to finalize the exit process for a Miner who has previously initiated the exit preparation using the `miner_exit_prep` function. + /// It transitions the Miner from a locked state to an exited state, effectively allowing the Miner to leave the system gracefully. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, ensuring the caller has root privileges. + /// - `miner`: The account of the Miner who is exiting the system. #[pallet::call_index(8)] #[transactional] #[pallet::weight(::WeightInfo::miner_exit())] @@ -585,6 +627,13 @@ pub mod pallet { Ok(()) } + /// Miner Withdraw + /// + /// This function allows a Miner to withdraw their assets and rights from the network after their exit has been finalized, + /// and any necessary cool-down period has passed. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, representing the Miner's account. #[pallet::call_index(9)] #[transactional] #[pallet::weight(::WeightInfo::miner_withdraw())] diff --git a/c-pallets/storage-handler/src/lib.rs b/c-pallets/storage-handler/src/lib.rs index 75d65862..333e56bb 100644 --- a/c-pallets/storage-handler/src/lib.rs +++ b/c-pallets/storage-handler/src/lib.rs @@ -171,12 +171,14 @@ pub mod pallet { #[pallet::call] impl Pallet { - /// Transaction of user purchasing space. - /// - /// The dispatch origin of this call must be Signed. - /// - /// Parameters: - /// - `gib_count`: Quantity of several gibs purchased. + /// Buy Space + /// + /// This function allows a user to purchase storage space in the network by specifying the desired capacity in gibibytes (GiB). + /// The user's account is debited with the corresponding payment for the purchased space. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, representing the user's account. + /// - `gib_count`: The amount of storage space to purchase, specified in gibibytes (GiB). #[pallet::call_index(0)] #[transactional] #[pallet::weight(::WeightInfo::buy_space())] @@ -210,14 +212,16 @@ pub mod pallet { Self::deposit_event(Event::::BuySpace { acc: sender, storage_capacity: space, spend: price }); Ok(()) } - /// Upgrade package (expansion of storage space) - /// - /// It can only be called when the package has been purchased, - /// And the upgrade target needs to be higher than the current package. - /// - /// Parameters: - /// - `gib_count`: Additional purchase quantity of several gibs. - #[pallet::call_index(1)] + + /// Expansion of Purchased Space + /// + /// This function allows a user who has previously purchased storage space to expand their purchased space by adding more storage capacity. + /// The user specifies the desired capacity in gibibytes (GiB) for expansion. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, representing the user's account. + /// - `gib_count`: The amount of additional storage space to purchase for expansion, specified in gibibytes (GiB). + #[pallet::call_index(1)] #[transactional] #[pallet::weight(::WeightInfo::expansion_space())] pub fn expansion_space(origin: OriginFor, gib_count: u32) -> DispatchResult { @@ -284,9 +288,14 @@ pub mod pallet { }); Ok(()) } - /// Package renewal - /// - /// Currently, lease renewal only supports single month renewal + + /// Renewal of Purchased Space Lease + /// + /// This function allows a user who has purchased storage space to renew their lease for additional days by paying a renewal fee. The user specifies the number of days they wish to extend the lease. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, representing the user's account. + /// - `days`: The number of days for which the user wishes to renew the space lease. #[pallet::call_index(2)] #[transactional] #[pallet::weight(::WeightInfo::renewal_space())] diff --git a/c-pallets/tee-worker/src/lib.rs b/c-pallets/tee-worker/src/lib.rs index 0dc41d1d..e067a075 100644 --- a/c-pallets/tee-worker/src/lib.rs +++ b/c-pallets/tee-worker/src/lib.rs @@ -125,7 +125,18 @@ pub mod pallet { pub struct Pallet(_); #[pallet::call] impl Pallet { - //Scheduling registration method + /// Register a TEE Worker + /// + /// This function allows a user to register a Trusted Execution Environment (TEE) worker by providing necessary information, + /// including the TEE worker's public keys, Peer ID, and other details. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, representing the user's account. + /// - `stash_account`: The stash account associated with the TEE worker, used for staking and governance. + /// - `node_key`: The public key of the TEE node. + /// - `peer_id`: The Peer ID of the TEE worker. + /// - `podr2_pbk`: The public key used for Proofs of Data Replication 2 (PoDR2) operations. + /// - `sgx_attestation_report`: The attestation report from the Intel Software Guard Extensions (SGX) enclave. #[pallet::call_index(0)] #[transactional] #[pallet::weight(::WeightInfo::registration_scheduler())] @@ -174,6 +185,15 @@ pub mod pallet { Ok(()) } + /// Update the TEE Worker MR Enclave Whitelist + /// + /// This function allows the root or superuser to update the whitelist of Trusted Execution Environment (TEE) Worker MR (Measurement and Report) Enclaves. + /// Each MR Enclave represents a specific instance of a TEE worker. By adding an MR Enclave to the whitelist, + /// the user ensures that the associated TEE worker can participate in network activities. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, representing the user's account. Only the root user is authorized to call this function. + /// - `mr_enclave`: A fixed-size array of 64 bytes representing the MR Enclave of the TEE worker to be added to the whitelist. #[pallet::call_index(1)] #[transactional] #[pallet::weight(Weight::zero())] @@ -188,6 +208,13 @@ pub mod pallet { Ok(()) } + /// Exit a TEE Worker from the Network + /// + /// This function allows a TEE (Trusted Execution Environment) Worker to voluntarily exit from the network. + /// When a TEE Worker exits, it will no longer participate in network activities and will be removed from the list of active TEE Workers. + /// + /// Parameters: + /// - `origin`: The origin from which the function is called, representing the account of the TEE Worker. This should be the controller account of the TEE Worker. #[pallet::call_index(2)] #[transactional] #[pallet::weight(100_000_000)]