[Ethereum] Returning Struct Array in solidity

contract-debuggingcontract-developmentsolidity

contract TripHistory {
       struct Trip {
           string lat;
           string lon;
       }
        mapping(string => Trip[]) trips;

        function getTrip(string _trip_id) public view returns (Trip[]) {
            return trips[_trip_id];
        }
        function storeTrip(string _trip_id, string _lat, string _lon) public  {
           trips[_trip_id].push(Trip(_lat, _lon));
        }

}

This is my contract code. Here I'm trying to store the coordinates of a particular trip. While storing the information contract executing fine. But When I retrieve the data, It should give the array of coordinates. But it is throwing an error.

reason: 'insufficient data for uint256 type'

What I'm missing here. Is there any other way to achieve what I'm trying here. Kindly help me out.

P.S: I'm new to solidity.

Best Answer

Return an array of struct from a function

contract TripHistory {
  struct Trip {
    string lat;
    string lon;
  }
  mapping (string => Trip) public trips;
  uint public tripcount;

  constructor() public {
    tripcount = 0;
    storeTrip("let0","long0");
    storeTrip("let1","long1");
  }
  function storeTrip(string memory _lat, string memory _lon) public  {
    trips[tripcount] = Trip(_lat, _lon);
    tripcount++;
  }
  //return Array of structure
  function getTrip() public view returns (Trip[] memory){
      Trip[] memory trrips = new Trip[](tripcount);
      for (uint i = 0; i < tripcount; i++) {
          Trip storage trrip = trips[i];
          trrips[i] = trrip;
      }
      return trrips;
  }
}

Related Solutions

Solidity – How to Return Structs and Lists in Smart Contracts

You can return arrays. What you can't do is return arrays of arrays, including string[] or bytes[] (because a string or bytes is already an array).

The reason is just a limitation of the ABI (Application Binary Interface). When you try to do it, you should see a warning from the compiler that says:

This type is only supported in the new experimental ABI encoder. Use "pragma experimental ABIEncoderV2;" to enable the feature.

If you can get away with limiting your strings to length 32, you could use bytes32 instead. This code works fine:

pragma solidity ^0.4.24;

contract Test {
    function test() public pure returns (bytes32[]) {
        bytes32[] memory foo = new bytes32[](2);
        foo[0] = "hello";
        foo[1] = "goodbye";

        return foo;
    }
}

Solidity – How to Resolve Remix Compilation Error: Invalid Array Length, Expected Integer Literal or Constant Expression

I changed your smart contract implementation with this smart contract.

I put notes just so you'd know your errors.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// NOTE: Import IERC20 contract
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// NOTE: You must to implement IERC20 for override ERC20 methods!
contract NewToken is IERC20 {

  string public constant name = "NewToken";
  string public constant symbol = "NTKN";
  uint8 public constant decimals = 18;
  uint256 totalSupply_ = 10000000000000000000000000; 

  mapping(address => uint256) public balances;
  mapping(address => mapping (address => uint256)) allowed;

  // NOTE: I removed the events because it already defined into IERC20
  
  constructor() { 
    balances[msg.sender] = totalSupply_;
  }

  function totalSupply() public override view returns (uint256) {
    return totalSupply_;
  }

  // NOTE: You must to change signature function adding address parameter
  function balanceOf(address _address) public override view returns(uint256) {
    return balances[_address];
  }

  function transfer(address to, uint256 value) public override returns (bool) {
      require(value <= balances[msg.sender]);
      balances[msg.sender] = balances[msg.sender]-value;
      balances[to] = balances[to]+value;
      // NOTE: The event is called  Transfer not 'transfer'
      emit Transfer(msg.sender, to, value);
      return true;
  }

  function approve(address spender, uint256 value) public override returns (bool) {
      allowed[msg.sender][spender] = value;
      emit Approval(msg.sender, spender, value);
      return true;
  }

  function allowance(address owner, address spender) public override view returns (uint) {
      return allowed[owner][spender];
  }

  function transferFrom(address from, address to, uint256 value) public override returns (bool) {
      require(value <= balances[from]);
      require(value <= allowed[from][msg.sender]);

      balances[from] = balances[from]-value;
      allowed[from][msg.sender] = allowed[from][msg.sender]+value;
      balances[to] = balances[to]+value;
      emit Transfer(from, to, value);
      return true;
  }
}

Best Answer

Related Solutions

Solidity – How to Return Structs and Lists in Smart Contracts

Solidity – How to Resolve Remix Compilation Error: Invalid Array Length, Expected Integer Literal or Constant Expression

Related Topic