Storage Patterns: Transforming multiple mappings -> structs with mapping

Question

Currently I have quiet a few mappings which I believe overall could be reduced to a struct with internal mappings and one overall mapping, however, I'm not sure how to do this myself and are therefore looking for guidance.

mapping(address => uint256)    public proposedOfferings;
mapping(address => uint256)    public receivedOfferings;
mapping(address => uint256)    public acceptedOfferings;
mapping(address => uint256)    public rejectedOfferings;

How can I re-structure above to below, keeping in mind each mapping consist of two separate uint256 variables (e.g. uint256 amount and uint256 percentageBonus).

struct offerings {
mapping(address=> uint256) proposed;
mapping(address=> uint256) received;
mapping(address=> uint256) accepted;
mapping(address=> uint256) rejected;
}

mapping(address => offerings) offeringData;

also, some information on the related design paradigm would be highly appreciated. thanks!

Answer 1

struct param {
    uint256 amount;
    uint256 percentageBonus;
}

struct offerings {
    param proposed;
    param received;
    param accepted;
    param rejected;
}

mapping(address => offerings) public offeringData;

Like this, you will be mapping each address to a structure with four fields (proposed, received... etc) each of these fields have two fields (amount and percentageBonus)

you can use it like this, assume the user address is A:

offeringData[A].proposed.amount will give you the amount proposed by the user with address A.

offeringData[A].proposed.percentageBonus give you the percentage bonus. Same for the other variables.

You can set these doing, for instance,: offeringData[A].proposed.amount = value

Hope this helps.

Answer 2

Your offering should be a struct:

struct offering {
    uint256 amount;
    uint256 percentageBonus;
}

After this, you can do:

mapping(address => offering) public proposedOfferings;
mapping(address => offering) public receivedOfferings;
mapping(address => offering) public acceptedOfferings;
mapping(address => offering) public rejectedOfferings;

Or even:

struct offerings {  /* please note that is plural */
    mapping(address => offering) proposed;
    mapping(address => offering) received;
    mapping(address => offering) accepted;
    mapping(address => offering) rejected;
}

mapping(address => offerings) offeringData;

It will help to understand more about the business logic behind this, because it seems your offerings can be on different states, and an alternative approach could be to use an enum to describe such states:

enum offeringState { Received, Proposed, Accepted, Rejected }

struct offering {
    uint256 amount;
    uint256 percentageBonus;
    offeringState state;
}

But I'm really taking a wild guess now.