Sponsored TXN - permit function payload creation

thellecodes · January 18, 2024, 1:57pm

Hi all,

I’m trying to sponsor a txn on the backend. The example from https://github.com/Concordium/concordium-dapp-examples/tree/main/sponsoredTransactions is what I have been using.

I need to create a payload for the message. The example from the repo doesn’t show how to create one directly for the permit function.

Thanks.

Doris · January 19, 2024, 12:50pm

The parameter for the permit function is created at the backend of the server. The server sends the transaction to the chain (the transaction is not send via the Browser wallet at the front end). E.g. here is the line for how to create the Transfer payload.

github.com

Concordium/concordium-dapp-examples/blob/main/sponsoredTransactions/backend/src/handlers.rs#L85


      
          log::debug!("Create payload.");
          
          let transfer = Transfer {
              from: Address::Account(request.from),
              to: Receiver::Account(request.to),
              token_id: request.token_id,
              amount: TokenAmount::from_str("1").map_err(|_| LogError::TokenAmountError)?,
              data: AdditionalData::new(vec![]).map_err(|_| LogError::AdditionalDataError)?,
          };
          
          let payload = TransferParams(vec![transfer]);
          
          log::debug!("Create PermitMessage.");
          
          let message: PermitMessage = PermitMessage {
              contract_address: ContractAddress {
                  index: smart_contract_index,
                  subindex: 0,
              },
              nonce: request.nonce,
              timestamp: request.timestamp,

thellecodes · January 19, 2024, 6:00pm

Hey @Doris,

I appreciate your effort. But the example above is for a semi-fungible token. please provide me an example of creating a mint payload through the permit function.

Doris · January 20, 2024, 7:12pm

The sponsored transaction example in our repo showcases how you can use the transfer or the updateOperator entry points via the permit function (only these two entry points are supported in the contract to keep the example simple). I linked the NFT token contract and backend from our example here:
Smart Contract:

github.com

Concordium/concordium-rust-smart-contracts/blob/main/examples/cis3-nft-sponsored-txs/src/lib.rs

//! A NFT smart contract example using the Concordium Token Standard CIS2 with
//! sponsored transactions (CIS3).
//!
//! # Description
//! An instance of this smart contract can contain a number of different tokens
//! each identified by a token ID. A token is then globally identified by the
//! contract address together with the token ID.
//!
//! In this example the contract is initialized with no tokens, and tokens can
//! be minted through a `mint` contract function. No functionality to burn a
//! token is defined in this example.
//!
//! Note: The word 'address' refers to either an account address or a
//! contract address.
//!
//! This contract implements the Concordium Token Standard CIS2. In addition, it
//! implements the CIS3 standard which includes features for sponsored
//! transactions.
//!
//! The use case for this smart contract is for third-party service providers

This file has been truncated. show original

Backend:

github.com

Concordium/concordium-dapp-examples/blob/main/sponsoredTransactions/backend/src/handlers.rs#L85


      
          log::debug!("Create payload.");
          
          let transfer = Transfer {
              from: Address::Account(request.from),
              to: Receiver::Account(request.to),
              token_id: request.token_id,
              amount: TokenAmount::from_str("1").map_err(|_| LogError::TokenAmountError)?,
              data: AdditionalData::new(vec![]).map_err(|_| LogError::AdditionalDataError)?,
          };
          
          let payload = TransferParams(vec![transfer]);
          
          log::debug!("Create PermitMessage.");
          
          let message: PermitMessage = PermitMessage {
              contract_address: ContractAddress {
                  index: smart_contract_index,
                  subindex: 0,
              },
              nonce: request.nonce,
              timestamp: request.timestamp,

It seems you want in addition to mint tokens via the sponsored transaction mechanism.
We have a semi-fungible token contract that showcases how you can set up the mint function in the smart contract to do that:

github.com

Concordium/concordium-rust-smart-contracts/blob/main/examples/cis2-multi/src/lib.rs#L1373


      
                  update_operator(
                      update.update,
                      concordium_std::Address::Account(param.signer),
                      update.operator,
                      state,
                      builder,
                      logger,
                  )?;
              }
          }
          MINT_ENTRYPOINT => {
              // Mint tokens.
              // ATTENTION: Can be called by anyone. You should add your
              // custom access control here.
              let params: MintParams = from_bytes(&message.payload)?;
          
              // // Check that only the MINTER can authorize to mint. (comment in if you want
              // // only the MINTER role having the authorization to mint)
              // ensure!(
              //     host.state().has_role(&Address::from(param.signer), Roles::MINTER),
              //     ContractError::Unauthorized

Then you can set the payload (at the backend) equal to the MintParams. For the cis2_multi smart contract (the above contract) it would look like this:

   let payload =  MintParams {
        owner:        <Address>,
        metadata_url: <MetadataUrl>,
        token_id:     <ContractTokenId>,
   };

   let message: PermitMessage = PermitMessage {
        contract_address: ContractAddress {
            index: smart_contract_index,
            subindex: 0,
        },
        nonce: request.nonce,
        timestamp: request.timestamp,
        entry_point: OwnedEntrypointName::new_unchecked("mint".into()),
        payload: concordium_rust_sdk::smart_contracts::common::to_bytes(&payload),
    };

thellecodes · January 22, 2024, 8:09am

Hey @Doris,

Thank you so much for this, Is there any frontend integration for this? Just curious to know if any

Doris · January 22, 2024, 11:08am

Currently, we don’t have a front-end example that showcases the requested mint entrypoint out of the box. But I am confident that you can use the sponsored transaction example front end and adjust it for the mint entrypoint. Feel free to reach out if you have difficulties to do that.

thellecodes · January 23, 2024, 7:47pm

I encountered this error when the txn is to simulate.

Error: Unable to submit transfer: {"code":500,"message":"Transaction simulation error. Your transaction would revert with the given input parameters: reason: InvalidAccountReference { contents: AccountAddress([165, 44, 226, 8, 186, 20, ...) }"}

Below is my permit message

    let mint_params = MintParams {
        owner: request.to,
        metadata_url: MetadataParams {
            url:  "https://gateway.pinata.cloud/ipfs/QmZ3939dLLFzvYZjFnkdqACe2n9TQA8Rx4efbjaYTXteeu".to_string(),
            hash: Some(vec![
                "f982b4603b9c116598d381d1aee90a7b5332377b209b6bbd8d7a4dfab18f2a80".to_string(),
            ]),
        },
        token_id: "1000".to_string(),
    };

I’m unable to trace this, what could be the possible reason?

Doris · January 23, 2024, 8:56pm

The error comes from the rust-sdk: It means that your account does not exist on chain. Did you deploy/create the account [165, 44, 226, 8, 186, 20, …] on Concordium testnet?

thellecodes · January 23, 2024, 10:38pm

Thank you @Doris , I just encountered a strange error.

Error: Unable to submit transfer: {"code":500,"message":"Transaction simulation error. Your transaction would revert with the given input parameters: reason: InvalidContractAddress { contents: ContractAddress { index: 7754, subindex: 0 } }"}

The contract was deployed using the https://sctools.mainnet.concordium.software/.

The smart contract is deployed and has been used correctly. What could be the cause of this error?

thellecodes · January 24, 2024, 7:38am

Hi @Doris, from the rejection reasons, the reason for the invalid contract address is that a contract was not initialized. However on using the https://sctools.mainnet.concordium.software/., the contract was initialized in other to return its index. On my backend, we can also see from {"code":500,"message":"Transaction simulation error. Your transaction would revert with the given input parameters: reason: InvalidContractAddress { contents: ContractAddress { index: 7760, subindex: 0 } }"} that the index and the subindex are added properly. In my attempts to resolve this, I don’t seem to get hold of what the actual reason for this could be.

Doris · January 24, 2024, 4:26pm

Maybe your backend is not connected to an up-to-date testnet node if it cannot find the contractAddress 7760 even it is initialized on testnet.