trident_assistant 0.1.0

data/lib/trident_assistant/api/order.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module TridentAssistant
+  class API
+    # api for order
+    module Order
+      EXCHANGE_ASSET_ID = "965e5c6e-434c-3fa9-b780-c50f43cd955c"
+      MINIMUM_AMOUNT = 0.000_000_01
+
+      def orders(**kwargs)
+        client.get(
+          "api/orders",
+          headers: {
+            Authorization: "Bearer #{mixin_bot.access_token("GET", "/me")}"
+          },
+          params: {
+            collection_id: kwargs[:collection_id],
+            metahash: kwargs[:metahash],
+            state: kwargs[:state],
+            type: kwargs[:type]
+          }
+        )
+      end
+
+      def order(id)
+        client
+          .get(
+            "api/orders/#{id}",
+            headers: {
+              Authorization: "Bearer #{mixin_bot.access_token("GET", "/me")}"
+            }
+          )
+      end
+
+      def fill_order(order_id)
+        info = order order_id
+        raise "Order state: #{info["state"]}" if info["state"] != "open"
+
+        memo = TridentAssistant::Utils::Memo.new(type: "F", order_id: order_id, token_id: info["token_id"])
+
+        trace_id = SecureRandom.uuid
+        mixin_bot.create_multisig_transaction(
+          keystore[:pin],
+          {
+            asset_id: info["asset_id"],
+            trace_id: trace_id,
+            amount: info["price"],
+            memo: memo.encode,
+            receivers: TridentAssistant::Utils::TRIDENT_MTG[:members],
+            threshold: TridentAssistant::Utils::TRIDENT_MTG[:threshold]
+          }
+        )
+      end
+
+      def cancel_order(order_id)
+        info = order order_id
+        raise "Order maker: #{info["maker"]["id"]}" if info.dig("maker", "id") != mixin_bot.client_id
+        raise "Order state: #{info["state"]}" if info["state"] != "open"
+
+        memo = TridentAssistant::Utils::Memo.new(type: "C", order_id: order_id, token_id: info["token_id"])
+
+        trace_id = SecureRandom.uuid
+        mixin_bot.create_multisig_transaction(
+          keystore[:pin],
+          {
+            asset_id: info["asset_id"],
+            trace_id: trace_id,
+            amount: info["price"],
+            memo: memo.encode,
+            receivers: TridentAssistant::Utils::TRIDENT_MTG[:members],
+            threshold: TridentAssistant::Utils::TRIDENT_MTG[:threshold]
+          }
+        )
+      end
+    end
+  end
+end

data/lib/trident_assistant/api.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "./client"
+require_relative "./api/collection"
+require_relative "./api/collectible"
+require_relative "./api/metadata"
+require_relative "./api/order"
+
+module TridentAssistant
+  # APIs of Trident server
+  class API
+    attr_reader :mixin_bot, :client, :keystore
+
+    def initialize(**args)
+      @client = Client.new endpoint: args[:endpoint]
+      return if args[:keystore].blank?
+
+      @keystore = TridentAssistant::Utils.parse_json args[:keystore]
+      @mixin_bot = TridentAssistant::Utils.mixin_bot_from_keystore args[:keystore]
+    end
+
+    include TridentAssistant::API::Collectible
+    include TridentAssistant::API::Collection
+    include TridentAssistant::API::Metadata
+    include TridentAssistant::API::Order
+  end
+end

data/lib/trident_assistant/cli/base.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../api"
+
+module TridentAssistant
+  module CLI
+    # Base class of CLI
+    class Base < Thor
+      # https://github.com/Shopify/cli-ui
+      UI = ::CLI::UI
+
+      attr_reader :keystore, :bot, :client, :api
+
+      def initialize(*args)
+        super
+
+        endpoint =
+          if options[:endpoint].present?
+            options[:endpoint]
+          else
+            {
+              prod: "https://thetrident.one",
+              test: "https://trident-test.onrender.com",
+              dev: "http://localhost:3000"
+            }[options[:environment].to_sym]
+          end
+        @api =
+          begin
+            TridentAssistant::API.new(
+              endpoint: endpoint,
+              keystore: options[:keystore]
+            )
+          rescue JSON::ParserError
+            log UI.fmt("{{x}} falied to parse keystore.json: #{options[:keystore]}")
+          rescue StandardError => e
+            log UI.fmt "{{x}} Failed to initialize Mixin bot, maybe your keystore is incorrect. #{e.inspect}"
+          end
+      end
+
+      private
+
+      def log(obj)
+        if options[:pretty]
+          if obj.is_a? String
+            puts obj
+          else
+            ap obj
+          end
+        else
+          puts obj.inspect
+        end
+      end
+    end
+  end
+end

data/lib/trident_assistant/cli/collectible.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+
+module TridentAssistant
+  module CLI
+    # CLI to query Trident and Mixin APIs
+    class Collectible < Base
+      desc "index", "query collectibles in wallet"
+      option :state, type: :string, aliases: "s", required: false, default: :unspent,
+                     desc: "keystore or keystore.json file of Mixin bot"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def index
+        r = api.mixin_bot.collectibles state: options[:state]
+
+        log r["data"]
+      end
+
+      desc "show COLLECTION TOKEN", "query collectible"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def show(collection, token)
+        token_id = MixinBot::Utils::Nfo.new(collection: collection, token: token).unique_token_id
+        r = api.mixin_bot.collectible token_id
+
+        log r["data"]
+      end
+
+      desc "deposit COLLECTION TOKEN", "deposit NFT"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def deposit(collection, token)
+        log api.deposit collection, token
+        log UI.fmt("{{v}} successfully transfer NFT")
+      rescue StandardError => e
+        log UI.fmt("{{x}} failed: #{e.inspect} #{e.backtrace.join("\n")}")
+      end
+
+      desc "airdrop COLLECTION, TOKEN", "airdrop NFT"
+      option :receiver, type: :string, aliases: "r", required: false, desc: "receiver ID of airdrop"
+      option :start, type: :string, aliases: "s", required: false, desc: "start time of airdrop"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def airdrop(collection, token)
+        log api.airdrop collection, token, receiver_id: options[:receiver], start_at: options[:start]
+        log UI.fmt("{{v}} successfully transfer NFT")
+      rescue StandardError => e
+        log UI.fmt("{{x}} failed: #{e.inspect} #{e.backtrace.join("\n")}")
+      end
+
+      desc "withdraw COLLECTION TOKEN", "withdraw NFT"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def withdraw(collection, token)
+        log api.withdraw collection, token
+        log UI.fmt("{{v}} successfully invoked withdraw")
+      rescue StandardError => e
+        log UI.fmt("{{x}} failed: #{e.inspect} #{e.backtrace.join("\n")}")
+      end
+
+      desc "bulkairdrop DIR", "Airdrop NFT in bulk"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def bulkairdrop(dir)
+        raise "#{dir} is not a directory" unless Dir.exist?(dir)
+
+        Dir.glob("#{dir}/*.json").each do |file|
+          log UI.fmt("{{v}} found #{file}")
+          data = TridentAssistant::Utils.parse_json file
+          metadata = TridentAssistant::Utils.parse_metadata data
+          log UI.fmt("{{v}} metadata parsed")
+          metadata.validate!
+          log UI.fmt("{{v}} metadata validated")
+
+          if data.dig("_airdrop", "hash").present?
+            log UI.fmt("{{v}} NFT already transferred")
+            next
+          end
+
+          receiver_id = data.dig("_airdrop", "receiver_id")
+          start_at = data.dig("_airdrop", "start_at")
+          log UI.fmt("{{v}} airdrop receiver_id: #{receiver_id}")
+          log UI.fmt("{{v}} airdrop start_at: #{start_at}")
+
+          r = api.airdrop metadata.collection["id"], metadata.token["id"], receiver_id: receiver_id, start_at: start_at
+          log r["data"]
+          data["_airdrop"] ||= {}
+          data["_airdrop"]["hash"] = r["data"]["hash"]
+          log UI.fmt("{{v}} successfully transfer NFT ##{metadata.token["id"]} #{metadata.collection["id"]}")
+        rescue TridentAssistant::Utils::Metadata::InvalidFormatError, JSON::ParserError, Client::RequestError,
+               MixinBot::Error, RuntimeError => e
+          log UI.fmt("{{x}} #{file} failed to airdrop: #{e.inspect}")
+          next
+        ensure
+          File.write file, data.to_json
+        end
+      end
+
+      private
+
+      def _airdrop
+      end
+    end
+  end
+end

data/lib/trident_assistant/cli/collection.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+
+module TridentAssistant
+  module CLI
+    # CLI tool of collection
+    class Collection < Base
+      class InvalidError < TridentAssistant::Error; end
+
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      desc "index", "query all collections"
+      def index
+        log api.collections
+      end
+
+      option :name, type: :string, aliases: "n", desc: "collection Name"
+      option :description, type: :string, aliases: "d", desc: "collection Description"
+      option :icon, type: :string, aliases: "i", desc: "collection Icon"
+      option :url, type: :string, aliases: "u", desc: "collection External URL"
+      option :split, type: :string, aliases: "s", desc: "collection Split"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      desc "create", "create a new collection"
+      def create
+        name = options[:name] || UI.ask("Please input collection name")
+        raise InvalidError, "Name cannot be blank" if name.blank?
+
+        description = options[:description] || UI.ask("Please input collection description")
+        raise InvalidError, "Description cannot be blank" if description.blank?
+
+        icon = options[:icon] || UI.ask("Please input icon file or icon url")
+        icon_file = File.open(icon) if File.exist? icon
+
+        external_url = options[:url] || UI.ask("Please input collection external url, start with https:// or http://")
+        split = options[:split] || UI.ask("Please input collection split", default: "0.0")
+        payload = {
+          name: name,
+          description: description,
+          external_url: external_url,
+          split: split
+        }
+
+        if icon_file.present?
+          payload[:icon_base64] = Base64.strict_encode64(icon_file.read)
+        else
+          payload[:icon_url] = icon
+        end
+
+        log api.create_collection(**payload)
+      rescue InvalidError => e
+        log UI.fmt("{{x}} failed: #{e.inspect}")
+      ensure
+        icon_file&.close
+      end
+
+      desc "update ID", "update collection"
+      option :description, type: :string, aliases: "d", desc: "collection Description"
+      option :icon, type: :string, aliases: "i", desc: "collection Icon"
+      option :url, type: :string, aliases: "u", desc: "collection External URL"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def update(id)
+        payload = {}
+        payload[:description] = options[:description] if options[:description].present?
+        payload[:external_url] = options[:url] if options[:url].present?
+        if options[:icon].present? && File.exist?(options[:icon])
+          icon = File.open options[:icon]
+          payload[:icon_base64] = Base64.strict_encode64(icon.read)
+        end
+        log api.update_collection(id, **payload)
+      ensure
+        icon&.close
+      end
+
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      desc "show ID", "query a collection"
+      def show(id)
+        log api.collection id
+      end
+    end
+  end
+end

data/lib/trident_assistant/cli/metadata.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+
+module TridentAssistant
+  module CLI
+    # CLI to generate metadata
+    class Metadata < Base
+      class InvalidError < TridentAssistant::Error; end
+
+      desc "new", "generate a new metadata"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def new
+        creator_id = api.mixin_bot.client_id
+        creator_name = api.mixin_bot.me["full_name"]
+        creator_royalty = UI.ask("Please input creator royalty, 0.0 ~ 0.1", default: "0.0")
+        raise InvalidError, "Royalty must in 0.0 ~ 0.1" unless (0..0.1).include?(creator_royalty.to_f)
+
+        collection_id = UI.ask("Please input collection ID")
+        collection = api.collection collection_id
+        raise InvalidError, "Cannot find collection #{collection_id}" if collection.blank?
+
+        if collection["creator"]&.[]("id") != api.mixin_bot.client_id
+          raise InvalidError,
+                "Unauthorized to mint in #{collection_id}"
+        end
+
+        token_id = UI.ask("Please input token ID", default: "1")
+        token_name = UI.ask("Please input token name")
+        token_description = UI.ask("Please input token description")
+
+        token_icon_url = UI.ask("Please input token icon url or local file dir")
+        if File.file? token_icon_url
+          begin
+            file = File.open token_icon_url
+            res = api.mixin_bot.upload_attachment file
+            token_icon_url = res["view_url"]
+          ensure
+            file&.close
+          end
+        end
+
+        token_media_url = UI.ask("Please input token media url or local file dir")
+        if File.file? token_media_url
+          begin
+            file = File.open token_media_url
+            res = api.mixin_bot.upload_attachment file
+            token_media_url = res["view_url"]
+            token_media_hash = SHA3::Digest::SHA256.hexdigest file.read
+          ensure
+            file&.close
+          end
+        elsif token_media_url =~ URI::DEFAULT_PARSER.make_regexp
+          token_media_hash = TridentAssistant::Utils.hash_from_url(token_media_url)
+        end
+
+        metadata = TridentAssistant::Utils::Metadata.new(
+          creator: {
+            id: creator_id,
+            name: creator_name,
+            royalty: creator_royalty
+          },
+          collection: {
+            id: collection_id,
+            name: collection["name"],
+            description: collection["description"],
+            icon: {
+              url: collection["icon"]&.[]("url")
+            },
+            split: collection["split"].to_s
+          },
+          token: {
+            id: token_id,
+            name: token_name,
+            description: token_description,
+            icon: {
+              url: token_icon_url
+            },
+            media: {
+              url: token_media_url,
+              hash: token_media_hash.to_s
+            }
+          },
+          checksum: {
+            fields: ["creator.id", "creator.royalty", "collection.id", "collection.name",
+                     "collection.split", "token.id", "token.name", "token.media.hash"],
+            algorithm: "sha256"
+          }
+        )
+
+        File.write "#{token_id}_#{collection_id}.json", metadata.json.to_json
+        log metadata.json
+      end
+
+      desc "show METAHASH", "query metadata via metahash"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def show(metahash)
+        log api.metadata metahash
+      end
+
+      desc "upload", "upload metadata to Trident"
+      option :metadata, type: :string, aliases: "m", required: true, desc: "metadata or metadata.json file"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def upload
+        metadata = TridentAssistant::Utils.parse_metadata options[:metadata]
+        log UI.fmt("{{v}} metadata parsed")
+
+        metadata.validate!
+        log UI.fmt("{{v}} metadata validated")
+
+        # upload metadata
+        api.upload_metadata metadata: metadata.json, metahash: metadata.metahash
+        log UI.fmt("{{v}} metadata uploaded: #{options[:endpoint]}/api/collectibles/#{metadata.metahash}")
+      rescue JSON::ParserError, Client::RequestError, InvalidError => e
+        log UI.fmt("{{x}} #{e.inspect}")
+      end
+    end
+  end
+end

data/lib/trident_assistant/cli/nfo.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+
+module TridentAssistant
+  module CLI
+    # CLI to mint NFTs
+    class NFO < Base
+      desc "mint", "Mint NFT from NFO"
+      option :metadata, type: :string, aliases: "m", required: true, desc: "metadata or metadata.json file"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def mint
+        _mint options[:metadata]
+      rescue JSON::ParserError, Client::RequestError, TridentAssistant::Utils::Metadata::InvalidFormatError,
+             MixinBot::Error, RuntimeError => e
+        log UI.fmt("{{x}} #{e.inspect}")
+      end
+
+      desc "bulkmint DIR", "Mint NFT in bulk"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def bulkmint(dir)
+        raise "#{dir} is not a directory" unless Dir.exist?(dir)
+
+        Dir.glob("#{dir}/*.json").each do |file|
+          log UI.fmt("{{v}} found #{file}")
+          _mint file
+        rescue TridentAssistant::Utils::Metadata::InvalidFormatError, JSON::ParserError, Client::RequestError,
+               MixinBot::Error, RuntimeError => e
+          log UI.fmt("{{x}} #{file} failed: #{e.inspect}")
+          next
+        end
+      end
+
+      private
+
+      def _mint(raw)
+        # parse metadata
+        data = TridentAssistant::Utils.parse_json raw
+        metadata = TridentAssistant::Utils.parse_metadata data
+        log UI.fmt("{{v}} metadata parsed")
+
+        # validate metadata
+        metadata.validate!
+        log UI.fmt("{{v}} metadata validated")
+
+        raise "Creator ID incompatible with keystore" if metadata.creator[:id] != api.mixin_bot.client_id
+
+        token_id = MixinBot::Utils::Nfo.new(collection: metadata.collection[:id],
+                                            token: metadata.token[:id]).unique_token_id
+        collectible =
+          begin
+            api.mixin_bot.collectible token_id
+          rescue MixinBot::NotFoundError
+            nil
+          end
+        if collectible.present?
+          log UI.fmt("{{v}} already minted: #{token_id}")
+          return
+        end
+
+        # upload metadata
+        if data.dig("_mint", "metahash").blank?
+          api.upload_metadata metadata: metadata.json, metahash: metadata.metahash
+          data["_mint"] ||= {}
+          data["_mint"]["metahash"] = metadata.metahash
+        end
+        log UI.fmt("{{v}} metadata uploaded: #{options[:endpoint]}/api/collectibles/#{metadata.metahash}")
+
+        # pay to NFO
+        trace_id = data.dig("_mint", "trace_id") || SecureRandom.uuid
+        memo = api.mixin_bot.nft_memo metadata.collection[:id], metadata.token[:id].to_i, metadata.metahash
+        payment =
+          api.mixin_bot.create_multisig_transaction(
+            api.keystore[:pin],
+            {
+              asset_id: TridentAssistant::Utils::MINT_ASSET_ID,
+              trace_id: trace_id,
+              amount: TridentAssistant::Utils::MINT_AMOUNT,
+              memo: memo,
+              receivers: TridentAssistant::Utils::NFO_MTG[:members],
+              threshold: TridentAssistant::Utils::NFO_MTG[:threshold]
+            }
+          )
+
+        data["_mint"]["trace_id"] = trace_id
+        if payment["errors"].blank?
+          log UI.fmt("{{v}} NFT mint payment paid: #{payment["data"]}")
+          data["_mint"]["token_id"] = token_id
+        end
+
+        log UI.fmt("{{v}} NFT successfully minted")
+      ensure
+        if File.file? raw
+          File.write raw, data.to_json
+        else
+          log data
+        end
+      end
+    end
+  end
+end

data/lib/trident_assistant/cli/order.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+
+module TridentAssistant
+  module CLI
+    # CLI to transfer to Trident MTG
+    class Order < Base
+      EXCHANGE_ASSET_ID = "965e5c6e-434c-3fa9-b780-c50f43cd955c"
+      MINIMUM_AMOUNT = 0.000_000_01
+
+      desc "index", "list orders"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      option :collection, type: :string, aliases: "c", required: false, desc: "collection ID"
+      option :metahash, type: :string, aliases: "m", required: false, desc: "metahash"
+      option :type, type: :string, aliases: "t", required: false, desc: "ask | bid | auction"
+      option :state, type: :string, aliases: "s", required: false, desc: "open | completed"
+      def index
+        log api.orders(
+          collection_id: options[:collection],
+          metahash: options[:metahash],
+          state: options[:state],
+          type: options[:type]
+        )
+      end
+
+      desc "show ID", "query order"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def show(id)
+        log api.order id
+      end
+
+      desc "sell", "sell NFT at fixed price"
+      def ask; end
+
+      desc "auction", "auction NFT"
+      def auction; end
+
+      desc "bid", "bid NFT"
+      def bid; end
+
+      desc "fill ID", "fill order"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def fill(id)
+        log api.fill_order id
+      end
+
+      desc "cancel ID", "cancel order"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def cancel(id)
+        log api.cancel_order id
+      end
+
+      desc "deposit TOKEN", "deposit NFT"
+      def deposit(token)
+        log api.deposit_nft token
+      end
+
+      desc "withdraw TOKEN", "withdraw NFT"
+      option :keystore, type: :string, aliases: "k", required: true, desc: "keystore or keystore.json file of Mixin bot"
+      def withdraw(token)
+        payment =
+          api.mixin_bot.create_multisig_transaction(
+            keystore[:pin],
+            asset_id: EXCHANGE_ASSET_ID,
+            amount: MINIMUM_AMOUNT,
+            receivers: TridentAssistant::Utils::TRIDENT_MTG[:members],
+            threshold: TridentAssistant::Utils::TRIDENT_MTG[:threshold],
+            memo: TridentAssistant::Utils::Memo.new(type: "W", token_id: token).encode,
+            trace_id: SecureRandom.uuid
+          )
+
+        log UI.fmt("{{v}} payment: #{payment}")
+      end
+    end
+  end
+end

data/lib/trident_assistant/cli/utils.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+
+module TridentAssistant
+  module CLI
+    # CLI for utils
+    class Utils < Base
+      desc "hash INPUT", "Hash a string or file using sha256"
+      option :file, type: :boolean, aliases: "f", default: false, desc: "Hash a file"
+      def hash(_input)
+        content =
+          if options[:file]
+            File.read options[:input]
+          else
+            options[:input].to_s
+          end
+
+        log SHA3::Digest::SHA256.hexdigest(content)
+      end
+    end
+  end
+end