Swap contract Demo

{- The validator argument contains information about the assets involved in the trade, the datum represents the unit type, the redeemer specifies the quantity of assets to be exchanged by the user, and the context provides transaction-related information.
-}
{-# INLINABLE mkSwapValidator #-}
mkSwapValidator
    :: Swap
    -> ()
    -> SwapRedeemer
    -> ScriptContext
    -> Bool
mkSwapValidator Swap{..} _ (SwapA amountA) ctx =
    mkSwapXValidator checkExchangeA coinB oracle amountA ctx
mkSwapValidator Swap{..} _ (SwapB amountB) ctx =
    mkSwapXValidator checkExchangeB coinA oracle amountB ctx
mkSwapValidator swap _ AddLiquidity ctx =
    mkAddLiqValidator swap ctx

BLOCKFROST_PROJECT_ID = "BLOCKFROST_API_PROJECT_ID"
BLOCKFROST_BASE_URL = "https://cardano-preprod.blockfrost.io/api"

asset_name = "SWAP"                           #Token Name
nft_swap = MultiAsset.from_primitive(
       {
           policy_id.payload: {
               bytes(asset_name, "utf-8"): 1, #Amount to mint
           }
        }
)

swap_utxo_nft = Mint(...)            #Mint class (Hidden arguments)
swap_utxo_nft.mint_nft_with_script() #Creation of swap UTXO with NFT

swapInstance = SwapContract(...)              #Swap contract class (Hidden args)
swapInstance.add_liquidity(amountA, amountB, ...) #The user's wallet associated must cover the asset amount expected by the liquidity function.

# Charli3's oracle contract address
oracle_address = Address.from_primitive(
    "addr_test1wz58xs5ygmjf9a3p6y3qzmwxp7cyj09zk90rweazvj8vwds4d703u"
)
 
# Custom contract address (swap contract)
swap_address = Address.from_primitive(
    "addr_test1wqhsrhfqs6xv9g39mraau2jwnaqd7utt9x50d5sfmlz972spwd66j"
)
 
# Oracle feed nft identity
oracle_nft = MultiAsset.from_primitive(
    {
        "8fe2ef24b3cc8882f01d9246479ef6c6fc24a6950b222c206907a8be": {
            b"InlineOracleFeed": 1
        }
    }
)
 
# Swap nft identity
swap_nft = MultiAsset.from_primitive(
    {"ce9d1f8f464e1e930f19ae89ccab3de93d11ee5518eed15d641f6693": {b"SWAP": 1}}
)
 
# Swap asset information
tUSDT = MultiAsset.from_primitive(
    {"c6f192a236596e2bbaac5900d67e9700dec7c77d9da626c98e0ab2ac": {b"USDT": 1}}
)
 
#User's wallet addressython
user_address = w.user_address()

mOracleFeed :: Maybe OracleFeed
mOracleFeed =
 case txInfoReferenceInputs $ scriptContextTxInfo ctx of
   [txIn] -> case txOutDatum $ txInInfoResolved txIn of
               NoOutputDatum       -> Nothing
               OutputDatumHash odh ->
                  case findDatum odh (scriptContextTxInfo ctx) of
                    Just dv -> PlutusTx.fromBuiltinData . getDatum $ dv
                    Nothing -> Nothing
               OutputDatum dv      ->
                 PlutusTx.fromBuiltinData . getDatum $ dv
   []     -> traceError
                 "mkSwapXValidator: Empty reference input list"
   _      -> traceError
                 "mkSwapXValidator: Only one reference input is allowed"
 

def get_oracle_utxo(self) -> pyc.UTxO:
    """Get oracle's feed UTXO using NFT idenfier"""
    oracle_utxos = self.context.utxos(str(self.oracle_addr))
    oracle_utxo_nft = next((x for x in oracle_utxos if x.output.amount.multi_asset >= self.oracle_nft), None)
    if oracle_utxo_nft is None:
        raise ValueError("Oracle UTXO not found with NFT identifier")
    return oracle_utxo_nft
 
def get_oracle_exchange_rate(self) -> int:
    """Get the oracle's feed exchange rate"""
    oracle_feed_utxo = self.get_oracle_utxo()
    oracle_inline_datum: GenericData = GenericData.from_cbor(
         oracle_feed_utxo.output.datum.cbor
    )
    return oracle_inline_datum.price_data.get_price()
 

oracle_inline_datum: GenericData = GenericData.from_cbor(
         oracle_feed_utxo.output.datum.cbor
)

@dataclass
class GenericData(PlutusData):
    CONSTR_ID = 0
    price_data: PriceData
@dataclass
class PriceData(PlutusData):
    """represents cip oracle datum PriceMap(Tag +2)"""
 
    CONSTR_ID = 2
    price_map: dict
 
    def get_price(self) -> int:
        """get price from price map"""
        return self.price_map[0]
 
    def get_timestamp(self) -> int:
        """get timestamp of the feed"""
        return self.price_map[1]
 
    def get_expiry(self) -> int:
        """get expiry of the feed"""
        return self.price_map[2]
 
    @classmethod
    def set_price_map(cls, price: int, timestamp: int, expiry: int):
        """set price_map"""
        price_map = {0: price, 1: timestamp, 2: expiry}
        return cls(price_map)

"""Exchange of asset B  with A"""
amountA = self.swap_b_with_a(amountB)
 
def swap_b_with_a(self, amount_b: int) -> int:
    """Operation for swaping coin B with A"""
    exchange_rate_price = self.get_oracle_exchange_rate()
    return (amount_b * self.coin_precision) // exchange_rate_price

"""Exchange of asset A  with B"""
amountB = self.swap_a_with_b(amountA)
 
def swap_a_with_b(self, amount_a: int) -> int:
    """Operation for swaping coin A with B"""
    exchange_rate_price = self.get_oracle_exchange_rate()
    return (amount_a * exchange_rate_price) // self.coin_precision

class SwapContract:
    """SwapContact to interact with the swap smart contract
 
    Attributes:
        context: Blockfrost class
        oracle_nft: The NFT identifier of the oracle feed utxo
        oracle_addr: Address of the oracle contract
        swap_addr: Address of the swap contract
    """
 
    def __init__(
        self,
        context: ChainQuery,
        oracle_nft: pyc.MultiAsset,
        oracle_addr: pyc.Address,
        swap_addr: pyc.Address,
        swap: Swap,
    ) -> None:
        self.context = context
        self.oracle_addr = oracle_addr
        self.swap_addr = swap_addr
        self.coin_precision = 1000000
        self.swap = swap
        self.oracle_nft = oracle_nft

class Swap:
    """Class Swap for interact with the assets in the swap operation
    and identify the Swap's NFTs
 
    Attribures:
        swap_nft: The NFT identifier of the swap utxo
        coinA: Asset
    """
 
    def __init__(
        self,
        swap_nft: pyc.MultiAsset,
        coinA: pyc.MultiAsset,
    ) -> None:
        self.swap_nft = swap_nft
        self.coinA = coinA

"""Exchange of asset B  with A"""
oracle_feed_utxo = self.get_oracle_utxo()  #Oracle's feed UTXO
swap_utxo = self.get_swap_utxo()           #Swap's UTXO
amountA = self.swap_b_with_a(amountB)      #Assets exchange

#Query the available amount of assetB (tADA) at the swap address UTXO
amountB_at_swap_utxo = swap_utxo.output.amount.coin
 
#We multiply the user's asset by the lovelace rate and add it to the UTXO for the swap
updated_amountB_for_swap_utxo = amountB_at_swap_utxo + (amountB * 1000000)
 
#Additionally, we need to decrease the amount of tUSDT sent to the user's wallet.
updated_massetA_for_swap_utxo = self.decrease_asset_swap(amountA)
 
#We create a new value type with the updated asset values
amount_swap = pyc.transaction.Value(
    coin=updated_amountB_for_swap_utxo,
    multi_asset=updated_massetA_for_swap_utxo,
)
 
#Finally, we add the updated value, unit type and the swap's address to the output UTXO for the swap"
new_output_swap = pyc.TransactionOutput(
    address=swap_address, amount=amount_swap, datum=pyc.PlutusData()
)

#The user asset quantity to be added to the wallet (tUSDT received).
multi_asset_for_the_user = self.take_multi_asset_user(amountA)
 
#We create a value type with the user asset quantity (without tADA).
min_lovelace_amount_for_the_user = pyc.transaction.Value(
multi_asset=multi_asset_for_the_user
)
#Next, we creates an output UTXO using the previous value at the user's wallet.
min_lovelace_output_utxo_user = pyc.TransactionOutput(
address=user_address,
amount=min_lovelace_amount_for_the_user
)
#The pycardano utils function min_lovelace_post_alonzo calculate minimum Lovelace to attach to the previous created UTXO.
min_lovelace = pyc.utils.min_lovelace_post_alonzo(
min_lovelace_output_utxo_user, self.context
)
#Now, we create a value type with the minumum tADA amount.
amount_for_the_user = pyc.transaction.Value(
coin=min_lovelace, multi_asset=multi_asset_for_the_user
)
#Finally, we add the calculated minimum tADA amount to the previously generated output UTXO on line 4.
new_output_utxo_user = pyc.TransactionOutput(
address=user_address,
amount=amount_for_the_user
)

builder = pyc.TransactionBuilder(self.context) #Pyacardano builder
(
    builder.add_script_input(
        utxo=swap_utxo, script=script, redeemer=swap_redeemer
    )
    .add_input_address(user_address)           #User's wallet address
    .add_output(new_output_utxo_user)          #UTXO paying to the user
    .add_output(new_output_swap)               #UTXO paying to the swap contract
    .reference_inputs.add(oracle_feed_utxo.input) #Oracle's reference UTXO
)
 
self.submit_tx_builder(builder, sk, user_address)  #Sign and submission

usage: python main.py [-h] {trade,user,swap-contract,oracle-contract} ...
 
The swap python script is a demonstrative smart contract (Plutus v2) featuring the interaction with a charli3's
oracle. This script uses the inline oracle feed as reference input simulating the exchange rate between tADA and tUSDT
to sell or buy assets from a swap contract in the test environment of preproduction.
 
positional arguments:
  {trade,user,swap-contract,oracle-contract}
    trade               Call the trade transaction to exchange a user asset with another asset at the swap contract.
                        Supported assets tADA and tUSDT.
    user                Obtain information about the wallet of the user who participate in the trade transaction.
    swap-contract       Obtain information about the SWAP smart contract.
    oracle-contract     Obtain information about the ORACLE smart contract.
 
options:
  -h, --help            show this help message and exit
 
Copyrigth: (c) 2020 - 2023 Charli3

python main.py oracle-contract --feed
 
Oracle feed:
* Exchange rate tADA/tUSDt 2.4
* Generated data at: 2022-12-01 14:06:58
* Expiration data at: 2023-12-01 15:06:04

def mint_nft_with_script(self):
    """mint tokens with plutus v2 script"""
    policy_id = plutus_script_hash(self.minting_script_plutus_v2)
    asset_name = "SWAP"                           #Token Name
    nft_swap = MultiAsset.from_primitive(
        {
            policy_id.payload: {
                bytes(asset_name, "utf-8"): 1,
            }
        }
    )
    metadata = {
        0: {
            policy_id.payload.hex(): {
                "Swap": {
                    "description": "This is a test token",
                    "name": asset_name,
                }
            }
        }
    }
 

python main.py swap-contract --start-swap
 
Swap's NFT information:                         #New NFT information
Currency Symbol (Policy ID): c6f192a236596e2bbaac5900d67e9700dec7c77d9da626c98e0ab2ac
Token Name: SWAP

swap_nft = MultiAsset.from_primitive(
    {"c6f192a236596e2bbaac5900d67e9700dec7c77d9da626c98e0ab2ac": {b"SWAP": 1}}
) #Variable to update with the new NFT information