Generating custom principals/uuids in Rust

lastmjs · March 25, 2021, 11:05pm

Hey, I’ve looked through quite a few different places, and I’m not quite sure on the best way to generate custom principals or uuids with Rust.

How would I go about doing this? Is it possible to create custom principals? I think it would just be nice to be able to generate uuids that have the same format as IC principals.

hansl · March 25, 2021, 11:15pm

Custom or random? Random ones can be generated from a random private/public key pair.

Principals follow a pattern and don’t make sense as a random blob; canister IDs are created by the system and cannot sign messages, only derived Principal IDs (derived from a private key) can sign messages.

So the only “custom” prinicpals I could see would be canister IDs, which you can use the text format to encode some. But the goal of Principals was always as an opaque blob that doesn’t make sense as a random value.

lastmjs · March 25, 2021, 11:16pm

Thank you.

I want to be able to create UUIDs from within a canister. What is the best way to go about that? I think it would be nice for the UUID generated to have the same format as a principal, even if it doesn’t have the special features of a principal. All of this in Rust

hansl · March 25, 2021, 11:42pm

You can use a PRNG, and you could seed it with the random beacon if you really want random stuff (otherwise timestamp would be enough?). The beacon API is here: The Internet Computer Interface Specification :: Internet Computer (it’s raw_rand : () -> (blob)).

Creating principals from a UUID wouldn’t make much sense IMO.

Just to back up a little, what is the problem you’re trying to solve by getting Principals in this manner? How are the principals going to be used?

lastmjs · March 25, 2021, 11:47pm

I’m just trying to generate UUIDs for database entries is all, and I would prefer to have UUIDs instead of incremental integers

lastmjs · March 25, 2021, 11:50pm

How do I access raw_rand from a Rust canister? I don’t see it in the ic-cdk packages as far as I can tell. Am I supposed to treat the management canister as a canister and call it that way? Could you provide an example?

hansl · March 26, 2021, 12:02am

Yes. It’s a bit low level currently but it should work as any inter canister calls.

let (bytes,): (Vec<u8>,) = ic_cdk::api::call(Principal.management_canister(), "raw_rand", ()).await?;

lastmjs · March 26, 2021, 12:06am

Thank you! Are inter-canister calls documented for Rust at all? There doesn’t seem to be very much Rust documentation at all, unless I am not looking in the right places.

hansl · March 26, 2021, 12:08am

The CDK is a bit low level for the time being, just mapping on top of the System API exports with a bit of functionality for making calls async. Sorry about that, it’s still early in the development We will get better over time.

rckprtr · March 26, 2021, 2:23am

Very cool, I was looking for something similar for UUID’s, I ended up going with a global index.

Ori · March 26, 2021, 10:53am

I did too for now. I was wondering about the cost of using raw_rand for this?

lastmjs · April 1, 2021, 8:39pm

I was able to get this working from a canister by creating a sha256 hash of the random bytes, which is awesome!

I am running into an issue with the IC’s async/await implementation though, I think. I’m using async-graphql, and from within an async mutation resolver, I’m getting some crazy errors about threading. I’m sure I’ll learn a lot more about this in the coming days and weeks, but can you give some insight into the async/await implementation that the IC has chosen? Here’s the issue I’ve opened in the async-graphql repo: Having trouble using std::rc::Rc values within a Mutation object. · Issue #110 · async-graphql/async-graphql · GitHub

I’m fearing that the IC’s async/await implementation might not be compatible with async-graphql, perhaps because the IC’s async/await has made an assumption that it will only operate in a single-threaded environment.

lastmjs · April 1, 2021, 9:52pm

Also, would it be possible to make the raw_rand function synchronous? For example, getting the current time is a simple synchronous call to ic_cdk::api::time, so nice and simple. ic_cdk::api::raw_rand would be really nice.

hansl · April 1, 2021, 10:02pm

The random value returned is guaranteed to be truly random (using a physical random beacon), so it cannot be synchronous. If you don’t need that kind of security, I recommend to use a PRNG seeded with either the beacon or time.

lastmjs · April 2, 2021, 12:21am

@hansl Sounds good on the sync, thank you. My bigger problem from a couple comments back remains…and I’m afraid it’s going to become a very large problem once I need to do inter-canister calls

paulyoung · May 26, 2022, 9:00pm

@rckprtr how does what you’re doing compare with what I wrote here?

github.com/roman-kashitsyn/mmapped.blog

Effective Rust Canisters

opened 07:28PM - 26 May 22 UTC

closed 02:09PM - 19 Sep 22 UTC

paulyoung

Hi @roman-kashitsyn! I was re-reading [Effective Rust Canisters](https://mmap…ped.blog/posts/01-effective-rust-canisters.html) and I wanted to say thank you for writing it. It’s a great resource. I had some questions/suggestions, particularly around generating sequential user numbers that I hoped you could help me with. Thank you in advance! *** Here, an example is given that uses `Cell` for `NEXT_USER_ID` https://github.com/roman-kashitsyn/mmapped.blog/blob/7eaa01608b73cde2331a84f0ce645da020b05876/posts/01-effective-rust-canisters.html.pm#L44 But later it is explained that variables using `Cell` “flexible” and are discarded on upgrades. https://github.com/roman-kashitsyn/mmapped.blog/blob/7eaa01608b73cde2331a84f0ce645da020b05876/posts/01-effective-rust-canisters.html.pm#L159 https://github.com/roman-kashitsyn/mmapped.blog/blob/7eaa01608b73cde2331a84f0ce645da020b05876/posts/01-effective-rust-canisters.html.pm#L170 Would it make more sense to use `RefCell` in the original example? *** There are some examples of functions that take `UserId`: https://github.com/roman-kashitsyn/mmapped.blog/blob/7eaa01608b73cde2331a84f0ce645da020b05876/posts/01-effective-rust-canisters.html.pm#L217 https://github.com/roman-kashitsyn/mmapped.blog/blob/7eaa01608b73cde2331a84f0ce645da020b05876/posts/01-effective-rust-canisters.html.pm#L250 But there isn’t an example of how one might properly manage the creation of new user IDs (assuming they are incremental, like in `NEXT_USER_ID`) Could you provide an example of that? Are there any pitfalls with something like the following? ```rust thread_local! { static NEXT_USER_ID: RefCell<u128> = RefCell::new(0); } pub struct User { pub id: UserId, pub name: Name, } impl User { pub fn new(name: Name) -> Self { NEXT_USER_ID.with(|next_user_id| { let user = Self { id: UserId(*next_user_id.borrow()), name, }; *next_user_id.borrow_mut() += 1; user }) } } pub struct UserId(pub u128); ``` What do you recommend? *** There’s a link to Internet Identity: https://github.com/roman-kashitsyn/mmapped.blog/blob/7eaa01608b73cde2331a84f0ce645da020b05876/posts/01-effective-rust-canisters.html.pm#L688 Internet Identity also has a sequential user number: https://github.com/dfinity/internet-identity/blob/b434acea3831e4317cf20c26488f1d31570dd35b/src/internet_identity/src/storage.rs#L128-L140 However, it uses stable memory which is much more involved than using a stable variable. Could you explain why that is?

rckprtr · May 26, 2022, 10:44pm

Hey,

So we are probably going to use this method

github.com

dfinity/nns-dapp/blob/main/rs/src/state.rs

use crate::accounts_store::AccountsStore;
use crate::assets::AssetHashes;
use crate::assets::Assets;
use dfn_candid::Candid;
use on_wire::{FromWire, IntoWire};
use std::cell::RefCell;

#[derive(Default)]
pub struct State {
    // NOTE: When adding new persistent fields here, ensure that these fields
    // are being persisted in the `replace` method below.
    pub accounts_store: RefCell<AccountsStore>,
    pub assets: RefCell<Assets>,
    pub asset_hashes: RefCell<AssetHashes>,
}

impl State {
    pub fn replace(&self, new_state: State) {
        self.accounts_store.replace(new_state.accounts_store.take());
        self.assets.replace(new_state.assets.take());

This file has been truncated. show original

We have not had a chance to upgrade to !thread_local yet as we use the old paradigm 200+ times in our repo and figure it would be better to do a complete refactor instead of a quick fix.

Rick

AliSci · January 1, 2023, 8:59am

Can you give me example about using PRNG?
is it like

let id = rand::prng().gen(0..16)

?
Because: when i tried rand::prng it cannot find function prngin craterand [E0425]

paulyoung · January 1, 2023, 10:57pm

I think you’d need to do something like this:

github.com

codebase-labs/ic-auth-tokens/blob/76113cbaa8b788b1989a9d5ef0868cdb12ee46af/crates/ic-auth-tokens/src/lib.rs#L75-L95


      
          // Get a random number generator based on 'raw_rand'.
          // Based on https://github.com/dfinity/internet-identity/blob/f76e36cc45e064b5e04b977de43698c13e7b55d9/src/internet_identity/src/main.rs#L683-L697
          pub async fn make_rng<T: SeedableRng + CryptoRng>() -> T
          where
              // raw_rand returns 32 bytes
              T: SeedableRng<Seed = [u8; 32]>,
          {
              let raw_rand: Vec<u8> = match call(Principal::management_canister(), "raw_rand", ()).await {
                  Ok((res,)) => res,
                  Err((_, err)) => trap(&format!("failed to get seed: {}", err)),
              };
          
          
    let seed: <T as SeedableRng>::Seed = raw_rand[..].try_into().unwrap_or_else(|_| {
                  trap(&format!(
                      "when creating seed from raw_rand output, expected raw randomness to be of length 32, got {}",
                      raw_rand.len()
                  ));
              });
          
          
    T::from_seed(seed)
          }

Topic		Replies	Views
Using random module from Rust Developers	1	884	November 22, 2021
Rust storage patterns Developers	2	716	November 9, 2021
How to get self-address or self-principal of a canister in rust? Developers	1	416	September 14, 2021
Seeded RNG generates same random number on every call Rust	7	237	October 18, 2023
Using Canister principal when making intra-canister calls Rust internet-identity	8	290	December 1, 2023

Generating custom principals/uuids in Rust

Related Topics