📄Storage and types overview

Contract typings and storage

Base types

type token_id_t        is nat

type pool_id_t         is nat

type token_pool_idx_t  is nat

type fa12_token_t      is address

type fa2_token_t       is [@layout:comb] record[ 
    token_address        : address; 
    token_id             : token_id_t; 
]

type token_t           is 
| Fa12                   of fa12_token_t 
| Fa2                    of fa2_token_t

type tokens_map_t      is map(nat, token_t);

Staker accumulator - accumulator of QUIPU staking rewards.

Field	Type	Hint	Description
accumulator	map(token_pool_idx_t, nat)	For better accuracy, stored with multiplication by $10^{10}$.	Mapping of token index and corresponding underlying accumulated balance of token
total_staked	nat		balance of staked QUIPU tokens to current pool

type staker_accum_t     is [@layout:comb] record [
  accumulator             : map(token_pool_idx_t, nat);
  total_staked            : nat;
]

Fee storage - fee rates record

Field	Type	Hint	Description
lp	nat	Decimal value. Multiplied by $10^{10}$.	Percent of fee goes to liquidity providers. This fee stays in liquidity pool to increase LP token price.
stakers	nat	Decimal value. Multiplied by $10^{10}$.	Percent of fee goes to QUIPU token stakers of pool. This fee goes to staking accumulator and spreads between users who staked QUIPU token to pool. If noone staked this fee part goes to liquidity pool as additional fee.
ref	nat	Decimal value. Multiplied by $10^{10}$.	Percent of fee goes to referral of DEX call. This fee goes to referral address passed to DEX call. If referral not passed, fee goes to default referral.

type fees_storage_t     is [@layout:comb] record [
  lp                      : nat;
  stakers                 : nat;
  ref                     : nat;
]

Token information type - pool underlying token info

Field	Type	Hint	Description
rate	nat	Calculates with pecisions. By default LP precision is 1e18. Rate is the value allowing to set custom exchange ratios between underlying tokens	Indicates how much LP token belongs to each underlying stablecoin
precision_multiplier	nat	By default LP precision is 1e18. Than precision_multiplier is $10^{decimals_{LP} - decimals_{token}}$	value that underlying token reserves are multiplied by in order to adjust their precision to LP decimal places
reserves	nat		balance of underlying token, locked in pool

type token_info_t       is  [@layout:comb] record [
  rate                    : nat;
  precision_multiplier    : nat;
  reserves                : nat;
]

Pool type - DEX pool storage

Field	Type	Hint	Description
initial_A	nat	A constant stores as multiplied value. $A * n^{n-1} * 10^2$(10^2 is precision)	Start value of ramping A contant.
initial_A_time	timestamp	Timestamp in seconds	Time when ramping A constant was started.
future_A	nat	A constant stores as multiplied value. $A * n^{n-1} * 10^2$(10^2 is precision)	End value of ramping A contant.
future_A_time	timestamp	Timestamp in seconds	Time when ramping A constant will be finished
tokens_info	map(token_pool_idx_t, token_info_t)		Token information type - pool underlying token info
fee	fees_storage_t		Fee storage - fee rates record
staker_accumulator	staker_accum_t		Storage and types overview
total_supply	nat		Total supply of LP token.

type pool_t             is [@layout:comb] record [
  initial_A               : nat;
  initial_A_time          : timestamp;
  future_A                : nat;
  future_A_time           : timestamp;
  tokens_info             : map(token_pool_idx_t, token_info_t);
  fee                     : fees_storage_t;
  staker_accumulator      : staker_accum_t;
  total_supply            : nat;
]

Storage - main contract storage

Field	Type	Hint	Description
admin	address		Administator of current contract
default_referral	address		Default referral address to apply fees
managers	set(address)	Manager could edit LP token metadata.	Set of managers addresses
pools_count	nat	Counter	Amount of pools created inside current contract.
tokens	big_map(pool_id_t, tokens_map_t)		Mapping of tokens, that exchanges inside created pool.
pool_to_id	big_map(bytes, nat)	Bytes - packed by Bytes.pack(tokens) where tokens is valid tokens_map_t (sorted tokens).	Mapping that allows finding pool id by packed bytes of tokens_map_t
pools	big_map(pool_id_t, pool_t)		Mapping of pool to it's corresponding pool Pool type - DEX pool storage
ledger	big_map( (address * pool_id_t), nat)		Mapping of user's LP token balance related to pool
allowances	big_map( (address * pool_id_t), allowances_data_t)		Storage of operators allowed to transfer LP tokens of user's behalf.
dev_rewards	big_map(token_t, nat)		Mapping of accrued developer rewards by each token.
referral_rewards	big_map( (address * token_t), nat)		Mapping of accrued referral rewards by each user-token key.
stakers_balance	big_map( (address * pool_id_t), staker_info_t)		Mapping of accrued staking rewards by each user-token key.
quipu_token	fa2_token_t		QUIPU token address and token ID
dev_store	dev_storage_t		Developer storage

type storage_t          is [@layout:comb] record [
  (* Management *)
  admin                   : address;
  default_referral        : address;
  managers                : set(address);

  (* Pools data *)
  pools_count             : nat; (* total pools count *)
  tokens                  : big_map(pool_id_t, tokens_map_t); (* all the tokens list *)
  pool_to_id              : big_map(bytes, nat); (* all the tokens list *)
  pools                   : big_map(pool_id_t, pool_t); (* pool info per token id *)

  (* FA2 data *)
  ledger                  : big_map((address * pool_id_t), nat); (* account info per address *)
  allowances              : big_map((address * pool_id_t), allowances_data_t); (* account info per each lp provider *)

  (* Rewards and accumulators *)
  dev_rewards             : big_map(token_t, nat);
  referral_rewards        : big_map((address * token_t), nat);
  stakers_balance         : big_map((address * pool_id_t), staker_info_t);
  quipu_token             : fa2_token_t;
  (* dev storage params *)
  dev_store               : dev_storage_t;
]

Full storage type - storage root

Field	Type	Hint	Description
storage	storage_t	Storage - main contract storage	Indicates how much LP token belongs to each underlying stablecoin
metadata	big_map(string, bytes)	TZIP-016	contract metadata by TZIP-016
token_metadata	big_map(token_id_t, token_meta_info_t)	TZIP-016, TZIP-012	mapping each token metadata by TZIP-012
admin_lambdas	big_map(nat, bytes)		Administrative lambda-methods storage
dex_lambdas	big_map(nat, bytes)		DEX stable swap protocol lambda-methods storage
token_lambdas	big_map(nat, bytes)		FA2 lambda-methods storage

type full_storage_t     is [@layout:comb] record [
  storage                 : storage_t; (* real dex storage_t *)
  (* Token Metadata *)
  metadata                : big_map(string, bytes); (* metadata storage_t according to TZIP-016 *)
  token_metadata          : big_map(token_id_t, token_meta_info_t);
  (* Contract lambdas storage *)
  admin_lambdas           : big_map(nat, bytes); (* map with admin-related functions code *)
  dex_lambdas             : big_map(nat, bytes); (* map with exchange-related functions code *)
  token_lambdas           : big_map(nat, bytes); (* map with token-related functions code *)
]