A concept of equilibrium effect previously studied by Uniswap based on a specific N-dimensional surface defining a cost function for exchanging any token pair held in the SFTf Pool is feasible. exam. This decentralized method is called maintaining a steady rate of transactions. Ensure a stable asset value In the asset list of the transaction.
Safetyswap is a protocol for multi-token automated marketplace creation. It allows portfolio owners to create Safety Pools and traders can trade with them. Safety Pools contain two or more tokens, each with an independent weight representing its share of the total pool value. Pools provide liquidity to the Safety Pools Protocol and charge traders a fee to access it. Pools can be considered an automatic market makers, as anyone can swap any two tokens in any pool.
Automated market makers (AMMs) have come around in some forms as long as transactions can be automated, starting with the traditional financial markets. AMMs are essentially automated agents, driven by algorithms, that define rules to match buyers and sellers to facilitate transactions. Usually. AMMs continuously operate in both directions of a trading pair. The liquidity provider's profit comes from the difference between the bid and ask prices.
Smart contract platforms like BSC main net give a new safety word concept a whole new angle. we combine trading algorithms with custody of the underlying assets Safety is a generalization of the constant product rule for pools containing two or more tokens. Additionally, Safety Pools assign a relative weight to each token, to accommodate pools of tokens with significantly different valuations. The weight represents the share of each token in the total. This flexibility greatly expands the utility of these groups and allows for the creation of many interesting strategies and use cases.
Core group: A Safety Pool contract object- this is the "base" pool that actually holds tokens
balance: The total token balance of a pool. No mention of any user balances.
Denorm: Abnormal weight. Weights on Spool, although usually displayed as a percentage, are configured and stored in their denormalized form.
Controller: "Owner" of the lake; an address can call control capabilities.
Factory: Official Safety Pool Factory. Pools deployed from this factory appear on the Safety user interface (e.g.: Exchange and Pool Manager).
Smart group: The ownership contract (i.e. the controller), of the core group.
Pool life cycle: Any user can create a new pool by calling the new Safety Pool on the Factory contract. The caller is set as the controller or the owner of the Liquidity Pool. Pools can exist in one of two states: controlled or perfected. The Pool starts in a controlled state and the controller can choose to make the Pool finalize by calling finalize. Finalize is a one-way transformation. When in a controlled state, external actors cannot add liquidity. A controlled state allows the controller to set the token and weight of the pool.
Controlled pool owned by smart contract ("smart pool")
A very powerful feature of Safety is the concept of smart pools. A fully controlled pool of smart contracts can simulate a mature pool while allowing complex logic to recalibrate balances, weights, and fees. A stable pool of money that carries interest without impermanent loss
The pool adjusts the swap fee as a function of the volatility of the pool's assets.
The team updates the weights to execute a particular market strategy (e.g.: Liquidity Starter Group).
More complex dynamic strategies for asset allocation.
In a nutshell, Safety has implemented Factory contracts to create pools. Users deploy new pool contracts by calling create methods on these factories. In both cases, the actual "pool" visible to traders on public interfaces is a new Safety Pools contract.
If you deploy the Core Pool directly, you are the driver of that pool. If you implement Smart Pool, you need to pass the core SafetyFactory address, as two contracts will be deployed. You are the controller of the Smart Pool - and the Smart Pool itself is the driver of the Pool.
There are three things you can do with the pool
Transaction: use the swap function
Provide liquidity: using group join/exit functions (both single and multi-asset import and export are supported)
Group management: if you are the controller (eg: change its parameters).
Core Pools can only be managed until "complete", after which their parameters are unchanged.
Smart Pool: are managed according to the permissions granted to the controller at creation. Eg: you can create a Smart Pool where weights can be changed, but swap fees and token composition are fixed.
There is a minimum swap fee of 0.0001% (or one percentage basis point) to counter any adverse group rounding.
Maximum swap fee - 10%
This is to prevent malicious group controllers from placing beneficial transaction fees. (Eg: a group controller can pre-run a large transaction and set the fee to 99%.).
The official release is the first of 3 planned releases of the Balanced Protocol. Copper emphasizes code clarity for testing and verification and doesn't go too far for optimization.
Similarly, Smart Pools with configurable permissions have getter functions to return the instance of the Smart Pool Manager, Rights Manager, and Safe Math Libraries they were associated with when deployed. Of course, you can also retrieve the underlying Core Pool controlled by the Smart Pool and call getColor on it.
Configurable permission group
Safety's Configurable Permissions Pool is the reference implementation of the Balanced Permissions Pool controlled by the smart contract. It is flexible enough to be used directly to create a customizable Smart Pool. Like the Core Pool (Spool), it is generated from a factory - and as the name implies, its functionality can be customized to meet the needs of your project.
It is also designed to be easily extensible, and we show examples of the configurable Permissions Group extension In the Smart Group Template. Smart Pool Templates. These are projects with specific needs and custom logic that need to override and change core functionality
Smart-contract display addresses will be updated after the public project develops.
Allows the controller to suspend transactions (swaps) on the underlying core pool. Like mature core pools, Configurable Permission Pools are created when a transaction is allowed. With the swap on hold, the controller (or logic In the smart contract) can turn the transaction on and off. Eg: the controller may want to "shorten" the contract In certain pathological cases, such as a market crash.
Swap fees vary:
Allows the controller to change Swap Fees after contract deployment, Within the limits set by the underlying core team (e.g.: it cannot be zero or greater than 10%). With this permission, it is possible to implement fee optimization strategies (e.g.: maximize profits or minimize impermanent losses).
The controller can call update Weight (to update the weight of a token directly) or updateWeightsGradently (to linearly transform a set of weights over time). This allows for liquidity launch, UMA-style perpetual aggregation and many other strategies. Note that changing the weight changes the balance.
Allows the controller to change the composition of the group. Needless to say, this requires a lot of trust in the Smart Pool owner, but allows for powerful strategies, especially in combination with other permissions. Eg: permanent "rolling" synthesis. Adding tokens is a two-step process aimed at mitigating this risk and reducing the required trust. The protocol emits an event when a token is "committed" (soon to be added) and enforces a minimum timeout before the controller can "apply" (actually add) the token.
When this permission is enabled, no one can add liquidity (not even controllers, other than the initial pool creation), unless the creator whitelists them. This allows private investors, exclusive token launches, etc.