Merge pull request #482 from hashgraph/sr/prng-transaction

Author: mehcode

sdk/rust/examples/prng.rs

@@ -0,0 +1,55 @@
+/*
+ * ‌
+ * Hedera Rust SDK
+ * ​
+ * Copyright (C) 2022 - 2023 Hedera Hashgraph, LLC
+ * ​
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ‍
+ */
+
+use clap::Parser;
+use hedera::{AccountId, Client, PrivateKey, PrngTransaction};
+
+#[derive(Parser, Debug)]
+struct Args {
+    #[clap(long, env)]
+    operator_account_id: AccountId,
+
+    #[clap(long, env)]
+    operator_key: PrivateKey,
+
+    #[clap(long, env, default_value = "testnet")]
+    hedera_network: String,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let _ = dotenvy::dotenv();
+    let args = Args::parse();
+
+    let client = Client::for_name(&args.hedera_network)?;
+
+    client.set_operator(args.operator_account_id, args.operator_key);
+
+    let record = PrngTransaction::new()
+        .range(100)
+        .execute(&client)
+        .await?
+        .get_record(&client)
+        .await?;
+
+    println!("generated random number = {:?}", record.prng_number);
+
+    Ok(())
+}

sdk/rust/src/lib.rs

@@ -143,6 +143,7 @@ mod node_address;
 mod node_address_book;
 mod node_address_book_query;
 mod ping_query;
+mod prng_transaction;
 mod query;
 mod retry;
 mod schedule;
@@ -259,6 +260,7 @@ pub use node_address::NodeAddress;
 pub use node_address_book::NodeAddressBook;
 pub use node_address_book_query::NodeAddressBookQuery;
 pub(crate) use node_address_book_query::NodeAddressBookQueryData;
+pub use prng_transaction::PrngTransaction;
 pub(crate) use protobuf::{
     FromProtobuf,
     ToProtobuf,

sdk/rust/src/prng_transaction.rs

@@ -0,0 +1,118 @@
+/*
+ * ‌
+ * Hedera Rust SDK
+ * ​
+ * Copyright (C) 2022 - 2023 Hedera Hashgraph, LLC
+ * ​
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ‍
+ */
+
+use hedera_proto::services;
+use hedera_proto::services::util_service_client::UtilServiceClient;
+
+use crate::entity_id::ValidateChecksums;
+use crate::protobuf::{
+    FromProtobuf,
+    ToProtobuf,
+};
+use crate::transaction::{
+    AnyTransactionData,
+    ChunkInfo,
+    ToSchedulableTransactionDataProtobuf,
+    ToTransactionDataProtobuf,
+    TransactionData,
+    TransactionExecute,
+};
+use crate::Transaction;
+
+/// Random Number Generator Transaction.
+pub type PrngTransaction = Transaction<PrngTransactionData>;
+
+#[derive(Debug, Clone, Default)]
+#[cfg_attr(test, derive(Eq, PartialEq))]
+pub struct PrngTransactionData {
+    range: Option<u32>,
+}
+
+impl PrngTransaction {
+    /// Returns the upper-bound for the random number.
+    pub fn get_range(&self) -> Option<u32> {
+        self.data().range
+    }
+
+    /// Sets the upper-bound for the random number.
+    ///
+    /// If the value is zero, instead of returning a 32-bit number, a 384-bit number will be returned.
+    pub fn range(&mut self, range: u32) -> &mut Self {
+        self.data_mut().range = Some(range);
+
+        return self;
+    }
+}
+
+impl FromProtobuf<services::UtilPrngTransactionBody> for PrngTransactionData {
+    fn from_protobuf(pb: services::UtilPrngTransactionBody) -> crate::Result<Self> {
+        Ok(Self { range: (pb.range != 0).then_some(pb.range as u32) })
+    }
+}
+
+impl ToProtobuf for PrngTransactionData {
+    type Protobuf = services::UtilPrngTransactionBody;
+    fn to_protobuf(&self) -> Self::Protobuf {
+        services::UtilPrngTransactionBody { range: self.range.unwrap_or_default() as i32 }
+    }
+}
+
+impl TransactionData for PrngTransactionData {}
+
+impl From<PrngTransactionData> for AnyTransactionData {
+    fn from(value: PrngTransactionData) -> Self {
+        Self::Prng(value)
+    }
+}
+
+impl ValidateChecksums for PrngTransactionData {
+    fn validate_checksums(&self, _ledger_id: &crate::LedgerId) -> crate::Result<()> {
+        Ok(())
+    }
+}
+
+impl ToSchedulableTransactionDataProtobuf for PrngTransactionData {
+    fn to_schedulable_transaction_data_protobuf(
+        &self,
+    ) -> services::schedulable_transaction_body::Data {
+        services::schedulable_transaction_body::Data::UtilPrng(self.to_protobuf())
+    }
+}
+
+impl ToTransactionDataProtobuf for PrngTransactionData {
+    fn to_transaction_data_protobuf(
+        &self,
+        chunk_info: &ChunkInfo,
+    ) -> services::transaction_body::Data {
+        let _ = chunk_info.assert_single_transaction();
+
+        services::transaction_body::Data::UtilPrng(self.to_protobuf())
+    }
+}
+
+impl TransactionExecute for PrngTransactionData {
+    fn execute(
+        &self,
+        channel: tonic::transport::Channel,
+        request: services::Transaction,
+    ) -> crate::BoxGrpcFuture<'_, services::TransactionResponse> {
+        Box::pin(async { UtilServiceClient::new(channel).prng(request).await })
+    }
+}

sdk/rust/src/schedule/schedulable_transaction_body.rs

@@ -28,6 +28,7 @@ mod data {
         FileDeleteTransactionData as FileDelete,
         FileUpdateTransactionData as FileUpdate,
     };
+    pub(super) use crate::prng_transaction::PrngTransactionData as Prng;
     pub(super) use crate::schedule::ScheduleDeleteTransactionData as ScheduleDelete;
     pub(super) use crate::system::{
         FreezeTransactionData as Freeze,
@@ -115,6 +116,7 @@ pub(super) enum AnySchedulableTransactionData {
     FileCreate(data::FileCreate),
     FileUpdate(data::FileUpdate),
     FileDelete(data::FileDelete),
+    Prng(data::Prng),
     TokenAssociate(data::TokenAssociate),
     TokenBurn(data::TokenBurn),
     TokenCreate(data::TokenCreate),
@@ -184,6 +186,7 @@ impl AnySchedulableTransactionData {
             AnySchedulableTransactionData::SystemUndelete(it) => it.default_max_transaction_fee(),
             AnySchedulableTransactionData::Freeze(it) => it.default_max_transaction_fee(),
             AnySchedulableTransactionData::ScheduleDelete(it) => it.default_max_transaction_fee(),
+            AnySchedulableTransactionData::Prng(it) => it.default_max_transaction_fee(),
         }
     }
 }
@@ -277,7 +280,7 @@ impl FromProtobuf<services::schedulable_transaction_body::Data> for AnySchedulab
             Data::ScheduleDelete(it) => {
                 Ok(Self::ScheduleDelete(data::ScheduleDelete::from_protobuf(it)?))
             }
-            Data::UtilPrng(_) => unimplemented!("Prng transaction not currently implemented"),
+            Data::UtilPrng(it) => Ok(Self::Prng(data::Prng::from_protobuf(it)?)),
         }
     }
 }
@@ -399,6 +402,9 @@ impl ToSchedulableTransactionDataProtobuf for AnySchedulableTransactionData {
             AnySchedulableTransactionData::ScheduleDelete(it) => {
                 it.to_schedulable_transaction_data_protobuf()
             }
+            AnySchedulableTransactionData::Prng(it) => {
+                it.to_schedulable_transaction_data_protobuf()
+            }
         }
     }
 }
@@ -447,6 +453,8 @@ impl TryFrom<AnyTransactionData> for AnySchedulableTransactionData {
             AnyTransactionData::SystemUndelete(it) => Ok(Self::SystemUndelete(it)),
             AnyTransactionData::Freeze(it) => Ok(Self::Freeze(it)),
             AnyTransactionData::ScheduleDelete(it) => Ok(Self::ScheduleDelete(it)),
+            AnyTransactionData::Prng(it) => Ok(Self::Prng(it)),
+
             // fixme: basic-parse isn't suitable for this.
             AnyTransactionData::ScheduleCreate(_) => {
                 Err(crate::Error::basic_parse("Cannot schedule `ScheduleCreateTransaction`"))
@@ -507,6 +515,7 @@ impl From<AnySchedulableTransactionData> for AnyTransactionData {
             AnySchedulableTransactionData::SystemUndelete(it) => Self::SystemUndelete(it),
             AnySchedulableTransactionData::Freeze(it) => Self::Freeze(it),
             AnySchedulableTransactionData::ScheduleDelete(it) => Self::ScheduleDelete(it),
+            AnySchedulableTransactionData::Prng(it) => Self::Prng(it),
         }
     }
 }