[experiments, wip] Adds an abstract implementation of the regulated currency

[damirka]

This PR is built on top of the #1573.

What's inside:

• a regulated coin implementation which is built on top of the existing coin
• each transfer needs to be authorized through a shared Registry governed by 1 user (for now)
• transfer can only be accepted if none of the involved parties is banned
• a borrow method which enables external actions and custom implementations (how to convert/exchange/transform balances, maybe minting NFTs as usual 😆 )

Open to comments!

[Clay-Mysten]

Markdown looks good with some small changes I made directly.

[sblackshear]

I think this is an interesting piece of code and perhaps worth checking in as an example. However, I would be reluctant to implement a regulated stablecoin this way because I think it will make it impossible to use the stablecoin in DeFi etc. (or indeed, for anything except payments becase of the lack of store).

If you imagine the type of a key component in a Uniswap 1.0-style DEX, it would probably be something like struct Pool<T1, T2> { t1: Balance<T2>, t2: Balance<T2> }. This would preclude using the regulated coin as one of the pairings in a EX, which would be unfortunate.

[sblackshear]

Nit: let's use RegulatedCoin or PermissionedCoin everywhere?

[sblackshear]

Could we put this example into examples/fungible_tokens?

[damirka]

I wasn't going to add it anywhere actually. The whole idea was to poc.

[sblackshear]

+1 :)

[sblackshear]

Trying to understand the Abstract part of this name...

[damirka]

Oh. Yeah, it's still in development, and the initial idea was to showcase basic types but then I got carried away.

[sblackshear]

However, I think there is a very similar approach that would work:

// Instantiate Balance<T>/Coin<T> with me. Used in DeFi and other places Balance and Coin are expected
struct WRegulatedStable {}

/// Always encapsulated inside an `OwnedBalance`
struct RegulatedStable {}

struct OwnedBalance has key, store {
  id: VersionedID,
  balance: Balance<RegulatedStable>,
  owner: address,
}

/// Checks banned list + owner
public fun wrap(registry: &mut Registry, bal: OwnedBalance): Coin<WRegulatedStable>

/// Checks banned list
public fun unwrap(registry: &mut Registry, wrapped: Coin<WRegulatedStable>): OwnedBalance

/// Checks banned list, owner
public fun transfer(registry: &mut Registry, bal: OwnedBalance, recipient: address): OwnedBalance

• Only the stablecoin issuer can mint/burn RegulatedStable's.
• Only wrap/unwrap can mint/burn WRegulatedStables, and they are always encapsulated in an OwnedBalance
• Anyone can transfer an OwnedBalance via polymorphic transfer or by wrapping it in another object. But the recipient will only be able to spend it if the provided transfer function is used.
• Exchanges will likely only deal in RegulatedStable's

[damirka]

If you imagine the type of a key component in a Uniswap 1.0-style DEX, it would probably be something like struct Pool<T1, T2> { t1: Balance, t2: Balance }. This would preclude using the regulated coin as one of the pairings in a EX, which would be unfortunate.

If we shaped regulated coin into something worth including to the framework, people could consider using special type for stable coins. Also, inside an OwnedObject is the very same Balance, so I think it is technically possible to implement safety ops on the level of Liquidity Pool contracts. But of course this is merely a PoC, and not a candidate anywhere yet.

[damirka]

Closing it for now until I sort out how to use shared balances.