ERC-721 – How to Return an Array of Structs from Solidity Contracts

arrayserc-721mappingstakingstruct

i'm having an issue when trying to return an array of structs from a getter function i've made.

The smart contract is an ERC721 Staking Contract.

This is the getter function:

function getNftInfo(uint256[] calldata tokenIds) public view returns (uint256[] memory){
     
      uint256 tokenId;
      uint256[] memory tmp = new uint256[](tokenIds.length);
      for (uint i = 0; i < tokenIds.length; i++) {
          tokenId = tokenIds[i];
          Stake storage staked = vault[tokenId];
          tmp[i] = staked;
      }

      return tmp;
  }

This is the struct and the mapping:

 struct Stake {
        uint256 tokenId;
        uint256 lockPeriod;
        uint256 startDate;
        address owner;
    }
   
    mapping(uint256 => Stake) public vault;

When a user insert the staked tokenIds (ex. [1,345,10]) the return should be =>

[
  {1, lockperiod,StartDate,owner},
  {245, lockperiod,StartDate,owner},
  {10, lockperiod,StartDate,owner},
]

This is the error:

from solidity:
TypeError: Type struct CustomStakingV2.Stake storage pointer is not implicitly convertible to expected type uint256.
   --> CustomStakingV2.sol:109:20:
    |
109 |           tmp[i] = staked;
    |                    ^^^^^^

Someone could help me please?
Thank you

Best Answer

You are trying to assign 'Stake' which is a struct to tmp which is a uint256. That is not possible.

Instead of doing this, you can try

  function getNftInfo(uint256[] calldata tokenIds) public view returns (Stake[] memory){

  uint256 tokenId;
  Stake[] memory tmp = new Stake[](tokenIds.length);
  for (uint i = 0; i < tokenIds.length; i++) {
      tokenId = tokenIds[i];
      Stake storage staked = vault[tokenId];
      tmp[i] = staked;
  }
  return tmp;

Related Solutions

Solidity – Initializing Structs to Storage Variables

The former doesn't work because a SomeStruct storage is a pointer to the contract's storage space, and the way Solidity handles storage requires deriving that address from the organization of the structs you're writing it to - that is, its address in storage is directly dependent on the variable you're going to store it in. Without knowing what variable it's going in, it can't write to storage.

Your second snippet works because it first copies the data into a known location in storage, then copies it a second time to a new location, but as you'd expect, that's very inefficient. A better approach is to make your temporary struct in memory:

contract StructExample {

    struct SomeStruct {
        int someNumber;
        string someString;
    }

    SomeStruct[] someStructs;

    function addSomeStruct() {
        SomeStruct memory someStruct = SomeStruct(123, "test");
        someStructs.push(someStruct);
    }
}

Solidity will automatically generate code that copies the struct data from memory into storage.

Solidity Mapping – How to Return a Mapping Type

You need to break the interface down into smaller chunks. In practice, you'll want to extend the internal storage pattern a little, I think.

Iterable mapping comes to mind. You keep lists of keys to mappings in arrays. Something like this:

  struct VoterStruct {
    address voterAddress;
    uint256 tokensBought;
    mapping (bytes32 => uint256) tokensUsed;
    bytes32[] tokenIndex; // a list of mapping keys that exist for the voter
  }

  mapping (address => VoterStruct) public voterStructs;

Then you can expose functions that allow iterating over lists while the contract returns one set of values at a time. Very sketchy to inspire some ideas:

// client can discover how may tokens are in the list for one voter
function getVoterTokenCount(address voter) returns(uint tokenCount) {
    return voterStructs[voter].tokenIndex.length;}

// client can discover the tokenId for a voter in a given row
function getVoterTokenAtIndex(address voter, uint index) returns(bytes32 tokenId) {
    return voterStructs[voter].tokenIndex[index];}

// client can discover token used by voter and tokenId
function getVoterTokenUsed(address voter, bytes32 tokenId) returns(uint tokensUsed) {
    return voterStructs[voter].tokensUsed[tokenId];}

// append keys to the list as you go
function insertVoterToken(address voter, bytes32 tokenId) returns(bool success) {
    voterStructs[voter].tokenIndex.push(tokenId);
    return true;}

Hope I didn't flub the syntax. It might be possible to sketch out the contract a little more. Would need a general description of what it's going to do. When I use this pattern, I always add some rules to ensure there are no duplicate keys, and so on.

Anyway, possibly the hints will inspire some ideas.

Hope it helps.

Best Answer

Related Solutions

Solidity – Initializing Structs to Storage Variables

Solidity Mapping – How to Return a Mapping Type

Related Topic