convexity.con

(def convexity
  (deploy
   '(do
      (import convex.trust :as trust)
      (import currency.GBP :as GBP)
      (import currency.USD :as USD)
      (import currency.MYR :as MYR)
      (import currency.CHF :as CHF)
      (import currency.JPY :as JPY)
      (import currency.EUR :as EUR)
      (import currency.HKD :as HKD)
      (import currency.VND :as VND)
      (import currency.THB :as THB)

      (def trust-monitor
        (deploy (trust/build-whitelist {:controller *caller* :whitelist [*caller*]})))

      (def registry
        {GBP {:type :fungible
              :symbol "GBP"
              :name "Pound Sterling"
              :description "UK National Currency"
              :currency-symbol "£"
              :decimals 2}
         USD {:type :fungible
              :symbol "USD"
              :name "US Dollar"
              :description "US National Currency"
              :currency-symbol "$"
              :decimals 2}
         MYR {:type :fungible
              :symbol "MYR"
              :name "Malaysian Ringgit"
              :description "Malaysian National Currency"
              :currency-symbol "RM"
              :decimals 2}
         CHF {:type :fungible
              :symbol "CHF"
              :name "Swiss Franc"
              :description "Swiss National Currency"
              :currency-symbol "Fr."
              :decimals 2}
         JPY {:type :fungible
              :symbol "JPY"
              :name "Japanese Yen"
              :description "Japanese National Currency"
              :currency-symbol "¥"
              :decimals 0}
         EUR {:type :fungible
              :symbol "EUR"
              :name "Euro"
              :description "European Union Currency"
              :currency-symbol "€"
              :decimals 2}
         HKD {:type :fungible
              :symbol "HKD"
              :name "Hong Kong Dollar"
              :description "Hong Kong Currency"
              :currency-symbol "HK$"
              :decimals 2}
         VND {:type :fungible
              :symbol "VND"
              :name "Vietnamese Dong"
              :description "Vietnamese National Currency"
              :currency-symbol "₫"
              :decimals 2}
         THB {:type :fungible
              :symbol "THB"
              :name "Thai Baht"
              :description "Thai National Currency"
              :currency-symbol "฿"
              :decimals 2}})

      (defn all-assets
        ^{:callable? true
          :doc
          {:description "Returns a mapping of Address to metadata."}}
        []
        registry)

      (defn asset-metadata
        ^{:callable? true
          :doc
          {:signature [{:params [addr]}]
           :description "Returns metadata for a particular Asset."}}
        [addr]
        (get registry (address addr)))

      (defn register-asset
        ^{:callable? true
          :doc
          {:signature [{:params [addr metadata]}]
           :description "Registers metadata for a particular Asset. Returns registry.

                         Metadata is an open map and its keys will be different depending on its type.

                         NOTE: It's very important to *always* set the `type` key.

                         A Fungible Asset might have these keys:
                          - name            : string
                          - description     : string
                          - type            : keyword fungible | non-fungible
                          - symbol          : string
                          - currency-symbol : string
                          - decimals        : number"}}

        [addr metadata]
        (if (trust/trusted? trust-monitor *caller*)
          (def registry (assoc registry (address addr) metadata))
          (fail :unauthorized "You're not authorized to modify the registry.")))

      ;; TODO
      (defn request-registry
        ^{:callable? true
          :doc
          {:signature [{:params [address metadata]}]
           :description "Requests to register metadata for a particular Asset."}}
        [addr metadata]
        (def registry (assoc registry (address addr) metadata)))

      (defn unregister-asset
        ^{:callable? true
          :doc
          {:signature [{:params [address]}]
           :description "Unregisters metadata for a particular Asset."}}
        [addr]
        (if (trust/trusted? trust-monitor *caller*)
          (def registry (dissoc registry (address addr)))
          (fail :unauthorized "You're not authorized to modify the registry."))))))

(import asset.nft.tokens :as nft)

(call convexity (register-asset nft {:name "NFTs"
                                     :description "Convex NFT Library"
                                     :type :non-fungible}))
convexity