COULD WE MAKE BYTES() IMPLICITLY MORE FLEXIBLE WITHOUT ADDITIONAL COMPLEXITY?

[kcelestinomaria]

Hello Reach Fam,

Could we make the Bytes( ) Reach data structure more liberal in the strings it accepts? And if it is to be restricted because of storage costs, can it at least be explicit on the maximum? I am having trouble trying to define the Bytes( ) data structure on my contract and then easily provide some random string on the frontend. The docs says I should use the Data ( ) to substitute for it but it is hard to construct that because one way or another I will still have to define Bytes ( ) as a value to a variant. It just gets way more complicated than needed IMHO.

Check this as an example:

I have a use case where I want users to publish assets that they have, so I create this:

const AssetPublisherInteract = {
  ...hasRandom, // needed because making a hash of the asset details requires randomization
  assetName: Bytes(32),
  assetType: UInt,
  assetValue: UInt,
  originatorAddress: Address,
  published: Fun([], Null) // Signals successful publication on-chain
}

The error I get is:

Error: Protect failed: expected Bytes(32) but got () => 'LagosBar': for Tokenizer's interact field assetName
Error: Bytes expected string, but got () => 'Volvo'

from my frontend interaction:

const AssetPublisherInteract = { 
  ...stdlib.hasRandom,
  assetName: () => 'LagosBar',
  assetType: () => stdlib.bigNumberify(20),
  assetValue: () => convertFromMicroUnits(100000),
  originatorAddress: () => accTokenizer.networkAccount.addr,
  published: () => {
    console.log("Asset successfully published");
    stdlib.disconnect(null);
  },
};

As you can see I assigned assetName to Bytes(32), I am not allowed to have it open to say Bytes(WhateverSizeIsProvidedOnFrontend) . The docs however is clear,
and quote:

For example, 'You win!' and 'You lose!' cannot both be provided to an [interact](https://docs.reach.sh/rsh/local/#rsh_interact) function, because the second is one character longer. Most of the time this is good, because it is a signal that you should use a [Data](https://docs.reach.sh/rsh/compute/#rsh_Data) type instead, so that the formatting and display logic is entirely controlled by the frontend.[109](https://docs.reach.sh/rsh/compute/#p_109)

There is also the idea of padding, but if you are adding the padding process and check(assuring it does not go beyond or below size) e.g [https://github.com/reach-sh/reach-lang/blob/master/examples/dan-storage/index.rsh] to an old smart contract that holds your application's business logic then it makes your smart contract even more complex than needed, you get to debug new problems now.

I honestly think having some implicit functionality built into the Bytes() data type that is in some way liberal to the size of bytes, would really make life easier for Reach devs, especially myself and the use case I am working to deploy using Reach.

I know one would think, why should there be freedom in making the Bytes() open, blockchains aren't built for storage after all, IMHO, for some applications, especially when you are doing something like NFTs, even the name of the NFT, though the name's size could be very long/short, still that name regardless of size will make the NFT or its computation(if we were hashing its details etc.) unique on-chain/off-chain, so we cannot risk the Byte size by making it rigid(i.e I have to explicitly define the byte length).

As you see in my use case, a plethora of names with different byte sizes for your asset can be provided e.g 'Real Estate', 'Cars', 'Tesla Stock', 'Mercedes-2769309v', 'Meaty-Borana-Cattle-From-MaasaiLand' etc. With the limited byte size, it limits the application's scope unnecessarily. At least another solution is also one could have an implicit maximum byte length below which they can provide any asset name, at least in this case the developer can work out policies to name, and trim those asset's names before they get to the Reach backend.

Thanks!

[jeapostrophe]

The first and second halves of your message are about very different things.

For the first, the error Error: Bytes expected string, but got () => 'Volvo' is because you didn't give "Volvo", but you gave a function that returns "Volvo". You wrote

  assetName: () => 'LagosBar',

and not

  assetName: 'LagosBar',

For the second, Reach guarantees that your program will always be able to run. The only way it can do this is if it can determine how much state your program uses. If you run out of state, then the program will crash. For example, there is a limit to how many bytes can be given to a log opcode on Algorand. We are able to enforce this because we know how long every data value is. That is why it is necessary to provide a bound for strings. Reach will automatically pad strings that are shorter than the bound, for you.

[kcelestinomaria]

So the best way for me to get at this is to have a Byte size that is long enough, right? @jeapostrophe

[jeapostrophe]

Yup