@bananapus/core-v6 0.0.1

package/src/structs/JBAfterPayRecordedContext.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBTokenAmount} from "./JBTokenAmount.sol";
+
+/// @custom:member payer The address the payment originated from.
+/// @custom:member projectId The ID of the project being paid.
+/// @custom:member rulesetId The ID of the ruleset the payment is being made during.
+/// @custom:member amount The payment's token amount. Includes the token being paid, the value, the number of decimals
+/// included, and the currency of the amount.
+/// @custom:member forwardedAmount The token amount being forwarded to the pay hook. Includes the token
+/// being paid, the value, the number of decimals included, and the currency of the amount.
+/// @custom:member weight The current ruleset's weight (used to determine how many tokens should be minted).
+/// @custom:member newlyIssuedTokenCount The number of project tokens minted for the beneficiary.
+/// @custom:member beneficiary The address which receives any tokens this payment yields.
+/// @custom:member hookMetadata Extra data specified by the data hook, which is sent to the pay hook.
+/// @custom:member payerMetadata Extra data specified by the payer, which is sent to the pay hook.
+struct JBAfterPayRecordedContext {
+    address payer;
+    uint256 projectId;
+    uint256 rulesetId;
+    JBTokenAmount amount;
+    JBTokenAmount forwardedAmount;
+    uint256 weight;
+    uint256 newlyIssuedTokenCount;
+    address beneficiary;
+    bytes hookMetadata;
+    bytes payerMetadata;
+}

package/src/structs/JBBeforeCashOutRecordedContext.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBTokenAmount} from "./JBTokenAmount.sol";
+
+/// @notice Context sent from the terminal to the ruleset's data hook upon cash out.
+/// @custom:member terminal The terminal that is facilitating the cash out.
+/// @custom:member holder The holder of the tokens being cashed out.
+/// @custom:member projectId The ID of the project whose tokens are being cashed out.
+/// @custom:member rulesetId The ID of the ruleset the cash out is being made during.
+/// @custom:member cashOutCount The number of tokens being cashed out, as a fixed point number with 18 decimals.
+/// @custom:member totalSupply The total token supply being used for the calculation, as a fixed point number with 18
+/// decimals.
+/// @custom:member surplus The surplus amount used for the calculation, as a fixed point number with 18 decimals.
+/// Includes the token of the surplus, the surplus value, the number of decimals
+/// included, and the currency of the surplus.
+/// @custom:member useTotalSurplus If surplus across all of a project's terminals is being used when making cash outs.
+/// @custom:member cashOutTaxRate The cash out tax rate of the ruleset the cash out is being made during.
+/// @custom:member metadata Extra data provided by the casher.
+struct JBBeforeCashOutRecordedContext {
+    address terminal;
+    address holder;
+    uint256 projectId;
+    uint256 rulesetId;
+    uint256 cashOutCount;
+    uint256 totalSupply;
+    JBTokenAmount surplus;
+    bool useTotalSurplus;
+    uint256 cashOutTaxRate;
+    bytes metadata;
+}

package/src/structs/JBBeforePayRecordedContext.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBTokenAmount} from "./JBTokenAmount.sol";
+
+/// @notice Context sent from the terminal to the ruleset's data hook upon payment.
+/// @custom:member terminal The terminal that is facilitating the payment.
+/// @custom:member payer The address that the payment originated from.
+/// @custom:member amount The payment's token amount, including the token being paid, the value, the number of decimals
+/// included, and the currency of the amount.
+/// @custom:member projectId The ID of the project being paid.
+/// @custom:member rulesetId The ID of the ruleset the payment is being made during.
+/// @custom:member beneficiary The specified address that should be the beneficiary of anything that this payment
+/// yields.
+/// @custom:member weight The weight of the ruleset during which the payment is being made.
+/// @custom:member reservedPercent The reserved percent of the ruleset the payment is being made during.
+/// @custom:member metadata Extra data specified by the payer.
+struct JBBeforePayRecordedContext {
+    address terminal;
+    address payer;
+    JBTokenAmount amount;
+    uint256 projectId;
+    uint256 rulesetId;
+    address beneficiary;
+    uint256 weight;
+    uint256 reservedPercent;
+    bytes metadata;
+}

package/src/structs/JBCashOutHookSpecification.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBCashOutHook} from "../interfaces/IJBCashOutHook.sol";
+
+/// @notice A cash out hook specification sent from the ruleset's data hook back to the terminal. This specification is
+/// fulfilled by the terminal.
+/// @custom:member hook The cash out hook to use when fulfilling this specification.
+/// @custom:member amount The amount to send to the hook.
+/// @custom:member metadata Metadata to pass to the hook.
+struct JBCashOutHookSpecification {
+    IJBCashOutHook hook;
+    uint256 amount;
+    bytes metadata;
+}

package/src/structs/JBCurrencyAmount.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member amount The amount of the currency.
+/// @custom:member currency The currency. By convention, this is `uint32(uint160(tokenAddress))` for tokens, or a
+/// constant ID from e.g. `JBCurrencyIds` for other currencies.
+struct JBCurrencyAmount {
+    uint224 amount;
+    uint32 currency;
+}

package/src/structs/JBFee.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member amount The total amount the fee was taken from, as a fixed point number with the same number of
+/// decimals as the terminal in which this struct was created.
+/// @custom:member beneficiary The address that will receive the tokens that are minted as a result of the fee payment.
+/// @custom:member unlockTimestamp The timestamp at which the fee is unlocked and can be processed.
+struct JBFee {
+    uint256 amount;
+    address beneficiary;
+    uint48 unlockTimestamp;
+}

package/src/structs/JBFundAccessLimitGroup.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBCurrencyAmount} from "./JBCurrencyAmount.sol";
+
+/// @dev Payout limit example: if the `amount` is 5, the `currency` is 1 (USD), and the terminal's token is ETH, then
+/// the project can pay out 5 USD worth of ETH during a ruleset.
+/// @dev Surplus allowance example: if the `amount` is 5, the `currency` is 1 (USD), and the terminal's token is ETH,
+/// then the project can pay out 5 USD worth of ETH from its surplus during a ruleset. A project's surplus is its
+/// balance minus its current combined payout limit.
+/// @dev If a project has multiple payout limits or surplus allowances, they are all available. They can all be used
+/// during a single ruleset.
+/// @dev The payout limits' and surplus allowances' fixed point amounts have the same number of decimals as the
+/// terminal.
+/// @custom:member terminal The terminal that the payout limits and surplus allowances apply to.
+/// @custom:member token The token that the payout limits and surplus allowances apply to within the `terminal`.
+/// @custom:member payoutLimits An array of payout limits. The payout limits cumulatively dictate the maximum value of
+/// `token`s a project can pay out from its balance in a terminal during a ruleset. Each payout limit can have a unique
+/// currency and amount.
+/// @custom:member surplusAllowances An array of surplus allowances. The surplus allowances cumulatively dictates the
+/// maximum value of `token`s a project can pay out from its surplus (balance less payouts) in a terminal during a
+/// ruleset. Each surplus allowance can have a unique currency and amount.
+struct JBFundAccessLimitGroup {
+    address terminal;
+    address token;
+    JBCurrencyAmount[] payoutLimits;
+    JBCurrencyAmount[] surplusAllowances;
+}

package/src/structs/JBPayHookSpecification.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBPayHook} from "../interfaces/IJBPayHook.sol";
+
+/// @notice A pay hook specification sent from the ruleset's data hook back to the terminal. This specification is
+/// fulfilled by the terminal.
+/// @custom:member hook The pay hook to use when fulfilling this specification.
+/// @custom:member amount The amount to send to the hook.
+/// @custom:member metadata Metadata to pass the hook.
+struct JBPayHookSpecification {
+    IJBPayHook hook;
+    uint256 amount;
+    bytes metadata;
+}

package/src/structs/JBPermissionsData.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member operator The address that permissions are being given to.
+/// @custom:member projectId The ID of the project the operator is being given permissions for. Operators only have
+/// permissions under this project's scope. An ID of 0 is a wildcard, which gives an operator permissions across all
+/// projects.
+/// @custom:member permissionIds The IDs of the permissions being given. See the `JBPermissionIds` library.
+struct JBPermissionsData {
+    address operator;
+    uint64 projectId;
+    uint8[] permissionIds;
+}

package/src/structs/JBRuleset.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBRulesetApprovalHook} from "./../interfaces/IJBRulesetApprovalHook.sol";
+
+/// @dev `JBRuleset` timestamps are unix timestamps (seconds since 00:00 January 1st, 1970 UTC).
+/// @custom:member cycleNumber The ruleset's cycle number. Each ruleset's `cycleNumber` is the previous ruleset's
+/// `cycleNumber` plus one. Each project's first ruleset has a `cycleNumber` of 1.
+/// @custom:member id The ruleset's ID, which is a timestamp of when this ruleset's rules were initialized. The
+/// `rulesetId` stays the same for rulesets that automatically cycle over from a manually queued ruleset.
+/// @custom:member basedOnId The `rulesetId` of the ruleset which was active when this ruleset was created.
+/// @custom:member start The timestamp from which this ruleset is considered active.
+/// @custom:member duration The number of seconds the ruleset lasts for. After this duration, a new ruleset will start.
+/// The project owner can queue new rulesets at any time, which will take effect once the current ruleset's duration is
+/// over. If the `duration` is 0, newly queued rulesets will take effect immediately. If a ruleset ends and there are no
+/// new rulesets queued, the current ruleset cycles over to another one with the same properties but a new `start`
+/// timestamp and a `weight` reduced by the ruleset's `weightCutPercent`.
+/// @custom:member weight A fixed point number with 18 decimals which is typically used by payment terminals to
+/// determine how many tokens should be minted when a payment is received. This can be used by other contracts for
+/// arbitrary calculations.
+/// @custom:member weightCutPercent The percentage by which to reduce the `weight` each time a new ruleset starts.
+/// `weight`
+/// is
+/// a percentage out of `JBConstants.MAX_WEIGHT_CUT_PERCENT`. If it's 0, the next ruleset will have the same `weight` by
+/// default. If it's 90%, the next ruleset's `weight` will be 10% smaller. If a ruleset explicitly sets a new `weight`,
+/// the `weightCutPercent` doesn't apply.
+/// @custom:member approvalHook An address of a contract that says whether a queued ruleset should be approved or
+/// rejected. If a
+/// ruleset is rejected, it won't go into effect. An approval hook can be used to create rules which dictate how a
+/// project owner can change their ruleset over time.
+/// @custom:member metadata Extra data associated with a ruleset which can be used by other contracts.
+struct JBRuleset {
+    uint48 cycleNumber;
+    uint48 id;
+    uint48 basedOnId;
+    uint48 start;
+    uint32 duration;
+    uint112 weight;
+    uint32 weightCutPercent;
+    IJBRulesetApprovalHook approvalHook;
+    uint256 metadata;
+}

package/src/structs/JBRulesetConfig.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBRulesetApprovalHook} from "../interfaces/IJBRulesetApprovalHook.sol";
+import {JBFundAccessLimitGroup} from "./JBFundAccessLimitGroup.sol";
+import {JBRulesetMetadata} from "./JBRulesetMetadata.sol";
+import {JBSplitGroup} from "./JBSplitGroup.sol";
+
+/// @custom:member mustStartAtOrAfter The earliest time the ruleset can start.
+/// @custom:member duration The number of seconds the ruleset lasts for, after which a new ruleset will start. A
+/// duration of 0 means that the ruleset will stay active until the project owner explicitly issues a reconfiguration,
+/// at which point a new ruleset will immediately start with the updated properties. If the duration is greater than 0,
+/// a project owner cannot make changes to a ruleset's parameters while it is active – any proposed changes will apply
+/// to the subsequent ruleset. If no changes are proposed, a ruleset rolls over to another one with the same properties
+/// but new `start` timestamp and a cut `weight`.
+/// @custom:member weight A fixed point number with 18 decimals that contracts can use to base arbitrary calculations
+/// on. For example, payment terminals can use this to determine how many tokens should be minted when a payment is
+/// received.
+/// @custom:member weightCutPercent A percent by how much the `weight` of the subsequent ruleset should be reduced, if
+/// the
+/// project owner hasn't queued the subsequent ruleset with an explicit `weight`. If it's 0, each ruleset will have
+/// equal weight. If the number is 90%, the next ruleset will have a 10% smaller weight. This weight is out of
+/// `JBConstants.MAX_WEIGHT_CUT_PERCENT`.
+/// @custom:member approvalHook An address of a contract that says whether a proposed ruleset should be accepted or
+/// rejected. It
+/// can be used to create rules around how a project owner can change ruleset parameters over time.
+/// @custom:member metadata Metadata specifying the controller-specific parameters that a ruleset can have. These
+/// properties cannot change until the next ruleset starts.
+/// @custom:member splitGroups An array of splits to use for any number of groups while the ruleset is active.
+/// @custom:member fundAccessLimitGroups An array of structs which dictate the amount of funds a project can access from
+/// its balance in each payment terminal while the ruleset is active. Amounts are fixed point numbers using the same
+/// number of decimals as the corresponding terminal. The `_payoutLimit` and `_surplusAllowance` parameters must fit in
+/// a `uint232`.
+struct JBRulesetConfig {
+    uint48 mustStartAtOrAfter;
+    uint32 duration;
+    uint112 weight;
+    uint32 weightCutPercent;
+    IJBRulesetApprovalHook approvalHook;
+    JBRulesetMetadata metadata;
+    JBSplitGroup[] splitGroups;
+    JBFundAccessLimitGroup[] fundAccessLimitGroups;
+}

package/src/structs/JBRulesetMetadata.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member reservedPercent The reserved percent of the ruleset. This number is a percentage calculated out of
+/// `JBConstants.MAX_RESERVED_PERCENT`.
+/// @custom:member cashOutTaxRate The cash out tax rate of the ruleset. This number is a percentage calculated out of
+/// `JBConstants.MAX_CASH_OUT_TAX_RATE`.
+/// @custom:member baseCurrency The currency on which to base the ruleset's weight. By convention, this is
+/// `uint32(uint160(tokenAddress))` for tokens, or a constant ID from e.g. `JBCurrencyIds` for other currencies.
+/// @custom:member pausePay A flag indicating if the pay functionality should be paused during the ruleset.
+/// @custom:member pauseCreditTransfers A flag indicating if the project token transfer functionality should be paused
+/// during the funding cycle.
+/// @custom:member allowOwnerMinting A flag indicating if the project owner or an operator with the `MINT_TOKENS`
+/// permission from the owner should be allowed to mint project tokens on demand during this ruleset.
+/// @custom:member allowTerminalMigration A flag indicating if migrating terminals should be allowed during this
+/// ruleset.
+/// @custom:member allowSetTerminals A flag indicating if a project's terminals can be added or removed.
+/// @custom:member allowSetController A flag indicating if a project's controller can be changed.
+/// @custom:member allowAddAccountingContext A flag indicating if a project can add new accounting contexts for its
+/// terminals to use.
+/// @custom:member allowAddPriceFeed A flag indicating if a project can add new price feeds to calculate exchange rates
+/// between its tokens.
+/// @custom:member ownerMustSendPayouts A flag indicating if privileged payout distribution should be
+/// enforced, otherwise payouts can be distributed by anyone.
+/// @custom:member holdFees A flag indicating if fees should be held during this ruleset.
+/// @custom:member useTotalSurplusForCashOuts A flag indicating if cash outs should use the project's balance held
+/// in all terminals instead of the project's local terminal balance from which the cash out is being fulfilled.
+/// @custom:member useDataHookForPay A flag indicating if the data hook should be used for pay transactions during this
+/// ruleset.
+/// @custom:member useDataHookForCashOut A flag indicating if the data hook should be used for cash out transactions
+/// during
+/// this ruleset.
+/// @custom:member dataHook The data hook to use during this ruleset.
+/// @custom:member metadata Metadata of the metadata, only the 14 least significant bits can be used, the 2 most
+/// significant bits are disregarded.
+struct JBRulesetMetadata {
+    uint16 reservedPercent;
+    uint16 cashOutTaxRate;
+    uint32 baseCurrency;
+    bool pausePay;
+    bool pauseCreditTransfers;
+    bool allowOwnerMinting;
+    bool allowSetCustomToken;
+    bool allowTerminalMigration;
+    bool allowSetTerminals;
+    bool allowSetController;
+    bool allowAddAccountingContext;
+    bool allowAddPriceFeed;
+    bool ownerMustSendPayouts;
+    bool holdFees;
+    bool useTotalSurplusForCashOuts;
+    bool useDataHookForPay;
+    bool useDataHookForCashOut;
+    address dataHook;
+    uint16 metadata;
+}

package/src/structs/JBRulesetWeightCache.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member weight The cached weight value.
+/// @custom:member weightCutMultiple The weight cut multiple that produces the given weight.
+struct JBRulesetWeightCache {
+    uint112 weight;
+    uint168 weightCutMultiple;
+}

package/src/structs/JBRulesetWithMetadata.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBRuleset} from "./JBRuleset.sol";
+import {JBRulesetMetadata} from "./JBRulesetMetadata.sol";
+
+/// @custom:member ruleset The ruleset.
+/// @custom:member metadata The ruleset's metadata.
+struct JBRulesetWithMetadata {
+    JBRuleset ruleset;
+    JBRulesetMetadata metadata;
+}

package/src/structs/JBSingleAllowance.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member sigDeadline Deadline on the permit signature.
+/// @custom:member amount The maximum amount allowed to spend.
+/// @custom:member expiration Timestamp at which a spender's token allowances become invalid.
+/// @custom:member nonce An incrementing value indexed per owner,token,and spender for each signature.
+/// @custom:member signature The signature over the permit data. Supports EOA signatures, compact signatures defined by
+/// EIP-2098, and contract signatures defined by EIP-1271.
+struct JBSingleAllowance {
+    uint256 sigDeadline;
+    uint160 amount;
+    uint48 expiration;
+    uint48 nonce;
+    bytes signature;
+}

package/src/structs/JBSplit.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBSplitHook} from "./../interfaces/IJBSplitHook.sol";
+
+/// @notice Splits are used to send a percentage of a total token amount to a specific contract, project, or address.
+/// Splits are used to send payouts and reserved tokens.
+/// @dev 1. If a non-zero split hook contract is specified, this split's tokens are sent there along with this split's
+/// properties.
+/// @dev 2. Otherwise, if a non-zero project ID is specified, this split's tokens are used to `pay` it through its
+/// terminal if possible, or sent to the project's owner if not. If this payment yields tokens, those go to the split's
+/// `beneficiary`.
+/// @dev 3. Otherwise, this split's tokens are sent directly to the `beneficiary`.
+/// @dev To summarize, this split's tokens are sent according to the following priority: `split hook` > `projectId` >
+/// `beneficiary`.
+/// @custom:member percent The percent of the total token amount that this split sends. This number is out of
+/// `JBConstants.SPLITS_TOTAL_PERCENT`.
+/// @custom:member projectId The ID of a project to `pay`, if applicable. Resulting tokens will be routed to the
+/// `beneficiary`.
+/// @custom:member beneficiary Receives this split's tokens if the `hook` and `projectId` are zero. If the `projectId`
+/// is specified, the `beneficiary` receives any project tokens minted by this split. If `beneficiary` is `address(0)`,
+/// the application processing the split decides on the recipient. For example, the terminal uses `msg.sender` for
+/// payout splits, and the controller uses `msg.sender` for reserved token splits.
+/// @custom:member preferAddToBalance If this split were to `pay` a project through its terminal, this flag indicates
+/// whether it should prefer using the terminal's `addToBalance` function instead.
+/// @custom:member lockedUntil The split cannot be changed until this timestamp. The `lockedUntil` timestamp can be
+/// increased while a split is locked. If `lockedUntil` is zero, this split can be changed at any time.
+/// @custom:member hook A contract which will receive this split's tokens and properties, and can define custom
+/// behavior.
+struct JBSplit {
+    uint32 percent;
+    uint64 projectId;
+    address payable beneficiary;
+    bool preferAddToBalance;
+    uint48 lockedUntil;
+    IJBSplitHook hook;
+}

package/src/structs/JBSplitGroup.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBSplit} from "./JBSplit.sol";
+
+/// @custom:member groupId An identifier for the group. By convention, this ID is `uint256(uint160(tokenAddress))` for
+/// payouts and `1` for reserved tokens.
+/// @custom:member splits The splits in the group.
+struct JBSplitGroup {
+    uint256 groupId;
+    JBSplit[] splits;
+}

package/src/structs/JBSplitHookContext.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBSplit} from "./JBSplit.sol";
+
+/// @custom:member token The token being sent to the split hook.
+/// @custom:member amount The amount being sent to the split hook, as a fixed point number.
+/// @custom:member decimals The number of decimals in the amount.
+/// @custom:member projectId The project the split belongs to.
+/// @custom:member groupId The group the split belongs to. By convention, this ID is `uint256(uint160(tokenAddress))`
+/// for payouts and `1` for reserved tokens.
+/// @custom:member split The split which specified the hook.
+struct JBSplitHookContext {
+    address token;
+    uint256 amount;
+    uint256 decimals;
+    uint256 projectId;
+    uint256 groupId;
+    JBSplit split;
+}

package/src/structs/JBTerminalConfig.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBAccountingContext} from "./JBAccountingContext.sol";
+import {IJBTerminal} from "./../interfaces/IJBTerminal.sol";
+
+/// @custom:member terminal The terminal to configure.
+/// @custom:member accountingContextsToAccept The accounting contexts to accept from the terminal.
+struct JBTerminalConfig {
+    IJBTerminal terminal;
+    JBAccountingContext[] accountingContextsToAccept;
+}

package/src/structs/JBTokenAmount.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member token The token the payment was made in.
+/// @custom:member decimals The number of decimals included in the value fixed point number.
+/// @custom:member currency The currency. By convention, this is `uint32(uint160(tokenAddress))` for tokens, or a
+/// constant ID from e.g. `JBCurrencyIds` for other currencies.
+/// @custom:member value The amount of tokens that was paid, as a fixed point number.
+struct JBTokenAmount {
+    address token;
+    uint8 decimals;
+    uint32 currency;
+    uint256 value;
+}