Returning a wrapped Bytes type from contracts

[bitzoic]

Returning of a Bytes type has recently been introduced and is playing a vital part in developer's contracts, libraries, and Fuel standards. This has enabled a number of different features such as the String type.
However, returning a wrapped Bytes type is currently prohibited. This is key for certain features, such as returning a String or Option<Bytes>.

The current definition of the String type is the following. This has enabled UTF-8 encoded strings in the Sway language and opened the possibility for NFT's URIs, Fuel Name Service, and more.

pub struct String {
    bytes: Bytes,
}

An example where this is needed is in the FRC-20 and FRC-721 standards that have been introduced. There has recently been a push to create standards for Fuel and having the ability to return a String is critical. We currently have the following ABI definitions for our standards:

    /// Get the name of the token
    /// Example (with trailing padding): "MY_TOKEN                                                        "
    fn name() -> str[64];

    /// A distinct Uniform Resource Identifier (URI) for a given asset.
    /// URIs are defined in RFC-3986.
    fn uri(token_id: u64) -> str[2048];

These definitions suffer from having a static length, requiring lots of white space or possibly not being long enough in certain cases. Instead, we would like to update these to the following:

    /// Get the name of the token
    fn name() -> String;

    /// A distinct Uniform Resource Identifier (URI) for a given asset.
    /// URIs are defined in RFC-3986.
    fn uri(token_id: u64) -> String;

As of today, we are able to pass a String to a contract by manually constructing the struct and passing it to the contract. While this is less than ideal, it still offers the ability to pass a String to a contract. For example, here we construct the String struct and pass it to the contract. This works as expected.

#[tokio::test]
async fn takes_string_test() {
    let instance = setup().await;

    let string = "Fuel is blazingly fast!";
    let input = String {
        bytes: Bytes(string.as_bytes().to_vec()),
    };

    instance.methods().takes_string(input).call().await.unwrap();
}

However, returning of a String is incompatible with the rust sdk. While the following compiles, it will give a runtime error using the rust sdk:

    fn returns_string() -> String {
        let mut my_string = String::new();

        my_string.bytes.push(0u8);
        my_string.bytes.push(1u8);
        my_string.bytes.push(2u8);

        my_string
    }

    fn returns_bytes_option() -> Option<Bytes> {
        let mut my_bytes = Bytes::new();

        my_bytes.push(0u8);
        my_bytes.push(1u8);
        my_bytes.push(2u8);

        Option::Some(my_bytes)
    }

Returning a wrapped Bytes type is necessary for URIs, token names, FNS, symbols, FRC standards, and more within the Fuel ecosystem.

This has been tested with forc v0.37.0 and fuels-rs v0.41.0