Solidity Guide – Accessing and Storing a Struct from External Contract in Solidity

errorsoliditystoragestruct

I was trying to access and store a Struct from an external contract. Is there a way with which this is possible. This would be a simple PoC where I am trying to access a Struct from Student contract in ClassRoom Contract but keep getting:

TypeError: Type tuple(string memory,uint256,bool) is not implicitly convertible to expected type struct stu storage ref.
  --> contracts/TestContract.sol:32:16:
   |
32 |         test = student.studentNames(ID);
   |

Contracts:

SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
struct stu {
    string name;
    uint age;
    bool tookTest;
}
contract Student{
    mapping(uint => stu) public studentNames;
    function addStudent (uint ID, string memory _name, uint _age) public {
        studentNames[ID] = stu(_name, _age, false);
    }
    function updateStudent (uint ID) public {
        studentNames[ID].tookTest = true;
    }
}
contract ClassRoom {
    address studentAddr;
    Student student;
    stu public test;
    function classRoom(address addr) public {
        studentAddr = addr;
        student = Student(addr);
    }

    //some function that performs a check on student obj and updates the tookTest status to true
    function updateTookTest (uint ID) public {
        student.updateStudent(ID);
    }
    //if you want to access the public mapping
    function readStudentStruct (uint ID) public {
        test = student.studentNames(ID);
    }
}

I can see the call resolves correctly so it's not an issue accessing the mapping and the struct, just storing it. Any ideas?

Best Answer

The issue is that structures are tuples, so you must read them as tuples. The following code will works.

contract ClassRoom{

Student studentContract;
stu public test;

constructor(address _addr) {
    studentContract = Student(_addr);
}

function updateTookTest (uint ID) public {
}

function readStudentStruct (uint ID) public view returns(string memory, 
uint, bool) {

    stu memory student;
    (student.name, student.age, student.tookTest) = 
    studentContract.studentNames(ID);
    return (student.name, student.age, student.tookTest);
}
}

Related Solutions

Solidity Contract Development – Accessing a Public Mapping from a Different Contract

Main issue is you're calling a function in the foreign contract, so you use () instead of [].

Changed string to bytes32 so contracts can communicate. Also various touchups while I debugged it. bytes32 is more "native" and efficient, so it's generally best to do type conversion in the front-end.

I noticed the original concept was "ListProducts". Seems to be leading toward an indexed list of the mapped structs, so this might help: Are there well-solved and simple storage patterns for Solidity?

pragma solidity ^0.4.6;

contract Product{ 

  struct ProductStruct {  
    bytes32 name;  
    bool status;  
  }  

  mapping(uint => ProductStruct) public productStructs;

  function updateProduct(bytes32 name, uint ID) returns(bool success) {

  // following seems more like the intent. p[ID].n isn't valid

    productStructs[ID].name = name;
    productStructs[ID].status = true;
    return true;
  }
}

contract External {

  Product p;

  function External(address addr) {
    p = Product(addr);
  }

  function readProduct(uint u) constant returns(bytes32 name, bool status) {
    return(p.productStructs(u));
  }
}

Hope it helps.

Solidity – How to Use Array of Structs Inside a Struct for Smart Contracts

For work around this issue you can modify your ChildTokenDetails[] inside ParentTokenDetails using a mapping. In your case, I thougth that you can use the tokenId for key in this second mapping and ChildTokensDetails[] for values.

At this point, you must change your ParentTokenDetails struct in this way:

struct ParentTokenDetails{
   TokenType _tokenType;
   address _tokenOwner;
   mapping(uint => ChildTokenDetails[]) children;
}

And then, you must update your mintNonFungibleTokenEnum function in this way:

function mintNonFungibleTokenEnum(uint256 tokenID)
    public
    returns (uint256)
{
    uint256 newItemId = 1;
    ParentTokenDetails storage ptd = tokenEnums[tokenID];
    ptd._tokenType = TokenType.NON_FUNGIBLE;
    ptd._tokenOwner = msg.sender;
    ptd.children[tokenID].push(ChildTokenDetails(TokenType.NULL, msg.sender, false));
    ptd.children[tokenID].push(ChildTokenDetails(TokenType.FUNGIBLE, msg.sender, false));
    return newItemId;
}

In the following line, I put your smart contract modified:

//SPDX-License-Identifier:MIT
pragma solidity 0.8.13;

import "hardhat/console.sol";

contract TestEnum {
    enum TokenType { FUNGIBLE, NON_FUNGIBLE, NULL }
    address public owner;

    struct ParentTokenDetails{
        TokenType _tokenType;
        address _tokenOwner;
        mapping(uint => ChildTokenDetails[]) children;
    }

    struct ChildTokenDetails{
        TokenType _tokenType;
        address _tokenOwner;
        bool _locked;
    }

    mapping(uint256 => ParentTokenDetails) public tokenEnums;

    constructor(){
        owner = msg.sender;
    }
    
    function mintNonFungibleTokenEnum(uint256 tokenID)
        public
        returns (uint256)
    {
        uint256 newItemId = 1;
        ParentTokenDetails storage ptd = tokenEnums[tokenID];
        ptd._tokenType = TokenType.NON_FUNGIBLE;
        ptd._tokenOwner = msg.sender;
        ptd.children[tokenID].push(ChildTokenDetails(TokenType.NULL, msg.sender, false));
        ptd.children[tokenID].push(ChildTokenDetails(TokenType.FUNGIBLE, msg.sender, false));
        return newItemId;
    }

    // Getter Child tokens 
    function getChildTokens(uint tokenId) external view returns(ChildTokenDetails[] memory _tokens) {
        ChildTokenDetails[] storage ctdS = tokenEnums[tokenId].children[tokenId];
        return ctdS;
    }
}

Best Answer

Related Solutions

Solidity Contract Development – Accessing a Public Mapping from a Different Contract

Solidity – How to Use Array of Structs Inside a Struct for Smart Contracts

Related Topic