Is there any base32 implemented based on Motoko, specifically RFC4648 with no padding?

flyq · August 5, 2021, 11:45am

Is there any base32 implemented based on Motoko, specifically RFC4648 with no padding.

I need to convert [Nat8] to Principal, currently in motoko, only [Nat8] can be encoded into the text form of Principal, and this process requires base32, and then use Principal.fromText. Any better methods?

flyq · August 5, 2021, 11:55am

github.com

dfinity/motoko-base/blob/master/src/Principal.mo#L24

    
      
          
          
/// Conversion.
          public let toBlob : (p : Principal) -> Blob = Prim.blobOfPrincipal;
          
          
/// Conversion.
          public func toText(p : Principal) : Text = debug_show(p);
          
          
public func hash(principal : Principal) : Hash.Hash =
            Blob.hash (Prim.blobOfPrincipal(principal));
          
          
public func fromText(t : Text) : Principal = fromActor(actor(t));
          
          
/// Returns `x == y`.
          public func equal(x : Principal, y : Principal) : Bool { x == y };
          
          
/// Returns `x != y`.
          public func notEqual(x : Principal, y : Principal) : Bool { x != y };
          
          
/// Returns `x < y`.
          public func less(x : Principal, y : Principal) : Bool { x < y };

this is only fromText in Principal, if there is a fromBlob, it will be very nice.

skilesare · August 5, 2021, 9:56pm

public func bytesToText(_bytes : [Nat8]) : Text{
        var result : Text = "";
        var aChar : [var Nat8] = [var 0, 0, 0, 0];

        for(thisChar in Iter.range(0,_bytes.size())){
            if(thisChar > 0 and thisChar % 4 == 0){
                aChar[0] := _bytes[thisChar-4];
                aChar[1] := _bytes[thisChar-3];
                aChar[2] := _bytes[thisChar-2];
                aChar[3] := _bytes[thisChar-1];
                result := result # Char.toText(Char.fromNat32(bytesToNat32(Array.freeze<Nat8>(aChar))));
            };
        };
        return result;
    };

    public func principalToBytes(_principal: Principal.Principal) : [Nat8]{
        return textToBytes(Principal.toText(_principal));
    };

    //todo: this should go to Blob once they add Principal.fromBlob
    public func bytesToPrincipal(_bytes: [Nat8]) : Principal.Principal{
        return Principal.fromText(bytesToText(_bytes));
    };

flyq · August 6, 2021, 10:12am

great job!

Is there any more info about bytesToNat32

skilesare · August 6, 2021, 11:56am

Sorry about that:

public func bytesToNat32(bytes: [Nat8]) : Nat32{
        (Nat32.fromNat(Nat8.toNat(bytes[0])) << 24) +
        (Nat32.fromNat(Nat8.toNat(bytes[1])) << 16) +
        (Nat32.fromNat(Nat8.toNat(bytes[2])) << 8) +
        (Nat32.fromNat(Nat8.toNat(bytes[3])));
    };

flyq · August 7, 2021, 10:43am

skilesare:

public func bytesToNat32(bytes: [Nat8]) : Nat32{
        (Nat32.fromNat(Nat8.toNat(bytes[0])) << 24) +
        (Nat32.fromNat(Nat8.toNat(bytes[1])) << 16) +
        (Nat32.fromNat(Nat8.toNat(bytes[2])) << 8) +
        (Nat32.fromNat(Nat8.toNat(bytes[3])));
    };

Thanks very much for your help

flyq · August 8, 2021, 7:46am

I failed.

github.com

flyq/ic_codec/blob/master/src/main.rs#L97

    
      
          // Ledger canister id: CanisterId(ryjl3-tyaaa-aaaaa-aaaba-cai),
          // principal id: ryjl3-tyaaa-aaaaa-aaaba-cai,
          // principal id slice: [0, 0, 0, 0, 0, 0, 0, 2, 1, 1],
          // account id: AccountIdentifier { hash: [68, 190, 81, 175, 228, 164, 66, 13, 77, 244, 190, 255, 112, 143, 60, 242, 245, 222, 94, 252, 201, 245, 134, 128, 187, 15, 54, 144] },
          // account id slice: [136, 62, 239, 124, 68, 190, 81, 175, 228, 164, 66, 13, 77, 244, 190, 255, 112, 143, 60, 242, 245, 222, 94, 252, 201, 245, 134, 128, 187, 15, 54, 144],
          // account id hex string: "883eef7c44be51afe4a4420d4df4beff708f3cf2f5de5efcc9f58680bb0f3690",
          // subaccount: Subaccount([10, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
          // subaccount slice: [10, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
          
          
// user principal id: yhy6j-huy54-mkzda-m26hc-yklb3-dzz4l-i2ykq-kr7tx-dhxyf-v2c2g-tae,
          // principal id slice: [152, 239, 24, 172, 140, 12, 215, 142, 44, 41, 97, 216, 243, 158, 45, 26, 194, 160, 168, 254, 119, 25, 239, 130, 215, 66, 209, 166, 2],
          // account id: AccountIdentifier { hash: [67, 29, 107, 111, 105, 22, 6, 139, 87, 132, 162, 65, 115, 13, 46, 52, 82, 174, 101, 0, 37, 180, 191, 122, 151, 90, 129, 240] },
          // account id slice: [7, 60, 163, 53, 67, 29, 107, 111, 105, 22, 6, 139, 87, 132, 162, 65, 115, 13, 46, 52, 82, 174, 101, 0, 37, 180, 191, 122, 151, 90, 129, 240],
          // account id hex string: "073ca335431d6b6f6916068b5784a241730d2e3452ae650025b4bf7a975a81f0",
          // subaccount: Subaccount([29, 152, 239, 24, 172, 140, 12, 215, 142, 44, 41, 97, 216, 243, 158, 45, 26, 194, 160, 168, 254, 119, 25, 239, 130, 215, 66, 209, 166, 2, 0, 0]),
          // subaccount slice: [29, 152, 239, 24, 172, 140, 12, 215, 142, 44, 41, 97, 216, 243, 158, 45, 26, 194, 160, 168, 254, 119, 25, 239, 130, 215, 66, 209, 166, 2, 0, 0],
          
          
// ledger_user: AccountIdentifier { hash: [124, 24, 9, 168, 58, 106, 122, 169, 225, 220, 192, 84, 101, 198, 91, 89, 190, 222, 232, 10, 34, 110, 79, 177, 142, 58, 59, 242] }, ledger_user string: "751915b37c1809a83a6a7aa9e1dcc05465c65b59bedee80a226e4fb18e3a3bf2"

I get a Principal: yhy6j-huy54-mkzda-m26hc-yklb3-dzz4l-i2ykq-kr7tx-dhxyf-v2c2g-tae, and it’s slice is:
[152, 239, 24, 172, 140, 12, 215, 142, 44, 41, 97, 216, 243, 158, 45, 26, 194, 160, 168, 254, 119, 25, 239, 130, 215, 66, 209, 166, 2]

the first 4 bytes: [152,239,24,172] get the Nat32 2_565_806_252, and Char.fromNat32(2_565_806_252) will be trapped, as there is no unicode char in 2_565_806_252:

The Replica returned an error: code 5, message: "IC0503: Canister rwlgt-iiaaa-aaaaa-aaaaa-cai trapped explicitly: codepoint out of range"

the problem is that the Principal’s slice to Principal text, need crc32, base32 and ascii code:

github.com

dfinity/ic/blob/master/rs/types/base_types/src/principal_id.rs#L57

    
      
              let mut hasher = crc32fast::Hasher::new();
              hasher.update(&blob);
              let checksum = hasher.finalize();
          
          
    // ...combine blobs...
              let mut bytes = vec![];
              bytes.extend_from_slice(&(checksum.to_be_bytes()));
              bytes.extend_from_slice(&blob);
          
          
    // ...encode in base32...
              let mut s = base32::encode(base32::Alphabet::RFC4648 { padding: false }, &bytes);
              s.make_ascii_lowercase();
          
          
    // ...write out the string with dashes.
              while s.len() > 5 {
                  let rest = s.split_off(5);
                  write!(f, "{}-", s)?;
                  s = rest;
              }
              write!(f, "{}", s)
          }

flyq · August 9, 2021, 5:31am

Successfully converted on the basis of implementing base32:

github.com

flyq/ic_codec/blob/master/src/convert.mo#L22

    
      
          import Char "mo:base/Char";
          import Array "mo:base/Array";
          import Nat32 "mo:base/Nat32";
          import Nat "mo:base/Nat";
          import Text "mo:base/Text";
          import Base32 "./base32";
          import Crc32 "./crc32";
          
          
module {
              // todo: this should go to Blob once they add Principal.fromBlob
              func bytesToPrincipal(_bytes: [Nat8]) : Principal {
                  var res: [Nat8] = [];
                  res := Array.append(res, Crc32.crc32(_bytes));
                  res := Array.append(res, _bytes);
                  let s = Base32.encode(#RFC4648 {padding=false}, res);
                  let lowercase_s = make_ascii_lowercase(s);
                  let len = lowercase_s.size();
                  let s_slice = Iter.toArray(Text.toIter(lowercase_s));
                  var ret = "";
                  for (i in Iter.range(0, len-1)) {
                      ret := ret # Char.toText(s_slice[i]);

dfx canister --no-wallet call tools subaccountToPrincipal '(vec { 29;152;239;24;172;140;12;215;142;44;41;97;216;243;158;45;26;194;160;168;254;119;25;239;130;215;66;209;166;2;0;0})'
(principal "yhy6j-huy54-mkzda-m26hc-yklb3-dzz4l-i2ykq-kr7tx-dhxyf-v2c2g-tae")

dfx canister --no-wallet call tools subaccountToPrincipal '(vec {10;0;0;0;0;0;0;0;2;1;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;})'
(principal "ryjl3-tyaaa-aaaaa-aaaba-cai")

Ori · August 9, 2021, 8:28am

Unless there’s something extra going on in there you could also simplify the lowercase conversion like this:
https://forum.dfinity.org/t/motoko-type-text-methods-uppercase-and-lowercase/5938/2?u=ori

flyq · August 9, 2021, 1:11pm

Yes, it is effective and will be more concise:

github.com

flyq/ic_codec/blob/master/src/convert.mo#L29

    
      
          import Prim "mo:⛔";
          
          
module {
              // todo: this should go to Blob once they add Principal.fromBlob
              func bytesToPrincipal(_bytes: [Nat8]) : Principal {
                  var res: [Nat8] = [];
                  res := Array.append(res, Crc32.crc32(_bytes));
                  res := Array.append(res, _bytes);
                  let s = Base32.encode(#RFC4648 {padding=false}, res);
                  // let lowercase_s = make_ascii_lowercase(s);
                  let lowercase_s = Text.map(s , Prim.charToLower);
                  let len = lowercase_s.size();
                  let s_slice = Iter.toArray(Text.toIter(lowercase_s));
                  var ret = "";
                  for (i in Iter.range(0, len-1)) {
                      ret := ret # Char.toText(s_slice[i]);
                      if ((i+1) % 5 == 0 and i !=len-1) {
                          ret := ret # "-";
                      };
                  };
                  return Principal.fromText(ret);

Topic		Replies	Views
Random Principals in Motoko - For Testing Language Support Motoko	5	1335	December 23, 2022
ArrayBuffer equivalent in motoko? Developers	10	1320	May 25, 2021
How to convert [Nat8] to [Nat64] Language Support Motoko	3	476	March 16, 2023
Porting SHA512 and learning Motoko along Community Tutorials & Video	4	776	January 16, 2022
Principal.fromBlob Language Support Motoko	2	556	July 27, 2021

Is there any base32 implemented based on Motoko, specifically RFC4648 with no padding?

Related topics