mapping one id to multiple addresses

Question

Suppose I have a product with a specific id for sale(so I am the owner) and someone wants to buy the product from me. When he pays the price he will become the new owner of that product.

How can I record multiple owners for one specific asset?

I want to have a result like this (get all the addresses with the id)

56 => [0xcc6Bfe0C579416A6cC8532e984af0e6a, 0xcc6Bfe0C579416A12C8532e984th0e6a,...]

This is the way I did it which is not working as it should.

I summarized it to make it easier to understand.

Thanks in advance.

contract transfer{

  mapping(uint => address[]) public owners;

  function createAsset(string name, uint price) public
  {
      uint id = getRandom(); //I use a random generator function for id

      Asset memory newAsset = Asset(name, price); //struct to create a new product

      owners[id].push(msg.sender);

    }

  function transferProduct(uint id) public payable {
    owners[id].push(address((msg.sender)));

  }
}

Answer 1

As already said by Gabriel G., randomness should be avoided or well coded, read this importing randomness.

Anyway, your code is working, how are you getting all the addresses?

I wrote a simplified version of your summarized code with tests(using truffle suite) that pass and prove that the addresses are correctly stored

Transfer.sol:

pragma solidity >=0.4.21 <0.7.0;

contract Transfer {
    uint256 public idCounter;
    mapping(uint256 => address[]) public owners;
    event NewAsset(uint256 id);

    function createAsset() public {
        owners[idCounter].push(msg.sender);
        emit NewAsset(idCounter);
        idCounter++;
    }

    function transferProduct(uint256 id) public {
        owners[id].push(msg.sender);
    }
}

transfer.test.js:

const Transfer = artifacts.require('Transfer')

contract('Transfer', (accounts) => {
  const foo = accounts[0]
  const alice = accounts[1]
  const bob = accounts[2]
  let transfer
  let id

  before('Setup contract', async () => {
    transfer = await Transfer.deployed()
  })

  it('should add foo', async () => {
    const txFoo = await transfer.createAsset({ from: foo, value: 0 })
    // id = (await transfer.idCounter.call()).toNumber()

    if (txFoo.logs[0].event) {
      id = txFoo.logs[0].args[0].toString(10)
    }

    const resultFoo = await transfer.owners.call(id, 0)
    assert.equal(resultFoo, foo, `First: foo`)
  })

  it('should add Alice', async () => {
    const txAlice = await transfer.transferProduct(id, {
      from: alice,
      value: 0,
    })
    const resultAlice = await transfer.owners.call(id, 1)
    assert.equal(resultAlice, alice, `Second: alice`)
  })

  it('should add Bob', async () => {
    const txBob = await transfer.transferProduct(id, {
      from: bob,
      value: 0,
    })
    const resultBob = await transfer.owners.call(id, 2)
    assert.equal(resultBob, bob, `Third: bob`)
  })
})

Answer 2

I want to answer it with another answer, my previous answer is half correct, because if you want to save the array you must use .push with +size, your sample code is wrong. below is my sample code, you can try it and change it yourself:

pragma solidity >=0.4.22 <0.6.0;
contract example{
    uint lastcount; //define data input couter on global
    struct fileDetail{ //define struct for asset on global
        string name;
        uint price;
    }

    mapping (uint => address[]) fileOwner; //define mapping for fileOwner on id
    mapping (uint => fileDetail) fileDetails; //define mapping for file asset detail on id
    uint[] saveId; //save all generated id here

    function getFileDetails(uint id) view public returns(string memory, uint){ //this function for return struct fileDetail
        fileDetail storage up = fileDetails[id]; //read data from id in fileDetails
        return(up.name, up.price); //get data from fileDetails and return as struct
    }

    function getAllSavedID() view public returns(uint[] memory){ //this function for get all saved id and return list of uint[] or it will appear all saved id
        return saveId; //get data saveId and return as uint[]
    }

    function getOwners(uint id) view public returns(address[] memory){ //this function for return list of address[] or it will appear all owner
        return fileOwner[id]; //get data fileOwner and return as address[]
    }

    function getOwnersSize(uint id) view public returns(uint){ //this function will get address[] size from mapping (this is a counter for owner)
        return fileOwner[id].length; //get fileOwner[id] length for address[]
    }

    function createAsset(string memory name, uint price) public{
        uint id = now + lastcount;  //now will generate some number based time and plus latest count data input

        fileDetail storage up = fileDetails[id]; //call struct fileDetail, and used for save data to fileDetails with based id
        up.name = name; //set name for item id based
        up.price = price; //set price for item id based

        saveId.push(id) -1; // save id to saveId, it will use for view all saved id

        fileOwner[id].push(msg.sender); //save first owner for id

        lastcount = lastcount + 1; //count latest data input for next input
    }

    function addNewOwner(uint id) public{
        uint size = getOwnersSize(id); //call function for count owners
        fileOwner[id].push(msg.sender)+size; //add new array for address[], you need define size because it is important
    }
}

and below is a screenshot of the result you want :

Answer 3

I think struct can help you out to achieve what you have stated in your question:

I want to have a result like this (get all the addresses with the id) 56 => [0xcc6Bfe0C579416A6cC8532e984af0e6a, 0xcc6Bfe0C579416A12C8532e984th0e6a,...]

pragma solidity >=0.4.16 <0.6.0;

contract transfer {

    struct Asset {
        string name;
        uint price;
    }

    // define an address array inside struct to hold addresses
    struct Owner {
        address[] ownerAddresses;
    }

    // define mapping to map id to owners
    mapping(uint => Owner) owners;

    function createAsset(string memory name, uint price) public {
        //I use a random generator function for id
        uint id = getRandom();

        //struct to create a new product
        Asset memory newAsset = Asset(name, price);

        // store owner addresses for id
        owners[id].ownerAddresses.push(msg.sender);
    }

    function transferProduct(uint id) public payable {
        owners[id].ownerAddresses.push(msg.sender);
    }

    // getter function to get owners array for a given id
    function getOwners(uint id) public view returns (address[] memory) {
        return (owners[id].ownerAddresses);
    }

}

Hope it will help.

Answer 4

Just at + in your transferProduct(), but you need some counter for your mapping, because length not work on mapping. I think code will like this :

contract transfer{

  uint lenghtcounter;
  mapping(uint => address[]) public owners;

  function createAsset(string name, uint price) public
  {
      uint id = getRandom(); //I use a random generator function for id

      Asset memory newAsset = Asset(name, price); //struct to create a new product

      owners[id].push(msg.sender);
    }

  function transferProduct(uint id) public payable {
    uint temp = lenghtcounter + 1;
    owners[id].push(msg.sender)+temp ;
    lenghtcounter = temp;
  }
}

Answer 5

Fistly, how did you implement that getRandom(). Every code running under EVM needs to be fully deterministic it means randomness is not allowed. Besides that your code looks correct.

The only assumption I can make for this error to happen is that when you are calling getRandom() returns a uint (uint256), which is a BigInteger, and then when you can transferProduct() you are not passing a uint32 as argument which is automatically converted and it does not hit the same index. Therefore I would recommend you to do the following:

contract transfer{

  uint nextItemId;
  mapping(uint32 => address[]) public owners;

  function createAsset(string name, uint256 price) public
  {
      Asset memory newAsset = Asset(name, price); //struct to create a new product
      owners[nextItemId].push(msg.sender);
      nextItemId = nextItemId + 1;
    }

  function transferProduct(uint32 id) public payable {
    owners[id].push(address((msg.sender)));

  }
}

Remember that in Solidity EVM execution txs are being executed iteratively.