trident_assistant 0.1.0

data/lib/trident_assistant/cli.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "./cli/base"
+require_relative "./cli/collectible"
+require_relative "./cli/collection"
+require_relative "./cli/metadata"
+require_relative "./cli/nfo"
+require_relative "./cli/order"
+require_relative "./cli/utils"
+
+module TridentAssistant
+  # CLI tool
+  module CLI
+    # Main commands of CLI
+    class Command < TridentAssistant::CLI::Base
+      class_option :pretty, type: :boolean, aliases: "-p", default: true, desc: "Print output in pretty"
+      class_option :environment, type: :string, aliases: "-e", default: "prod", desc: "prod | test | dev"
+      class_option :endpoint, type: :string, aliases: "-E", desc: "Specify an endpoint"
+
+      desc "version", "Display TridentAssistant version"
+      def version
+        log VERSION
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "collectible", "commands for collectible"
+      subcommand "collectible", CLI::Collectible
+
+      desc "collection", "commands for collection"
+      subcommand "collection", CLI::Collection
+
+      desc "nfo", "commands for nfo"
+      subcommand "nfo", CLI::NFO
+
+      desc "metadata", "commands for metadata"
+      subcommand "metadata", CLI::Metadata
+
+      desc "order", "commands for order"
+      subcommand "order", CLI::Order
+    end
+  end
+end

data/lib/trident_assistant/client.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module TridentAssistant
+  # HTTP client to trident server
+  class Client
+    class HttpError < TridentAssistant::Error; end
+    class RequestError < TridentAssistant::Error; end
+
+    ENDPOINT = "https://thetrident.one"
+
+    attr_reader :endpoint
+
+    def initialize(**kwargs)
+      @endpoint = URI(kwargs[:endpoint] || ENDPOINT)
+    end
+
+    def get(path, **options)
+      request(:get, path, **options)
+    end
+
+    def post(path, **options)
+      request(:post, path, **options)
+    end
+
+    def put(path, **options)
+      request(:put, path, **options)
+    end
+
+    private
+
+    def request(verb, path, **options)
+      uri = uri_for path
+
+      options[:headers] ||= {}
+      options[:headers]["Content-Type"] ||= "application/json"
+
+      begin
+        response = HTTP.timeout(connect: 5, write: 10, read: 10).request(verb, uri, options)
+      rescue HTTP::Error => e
+        raise HttpError, e.message
+      end
+
+      raise RequestError, response.to_s unless response.status.success?
+
+      parse_response(response) do |parse_as, result|
+        case parse_as
+        when :json
+          break result if result["message"].blank?
+
+          raise result["message"]
+        else
+          result
+        end
+      end
+    end
+
+    def uri_for(path)
+      uri_options = {
+        scheme: endpoint.scheme,
+        host: endpoint.host,
+        port: endpoint.port,
+        path: path
+      }
+      Addressable::URI.new(uri_options)
+    end
+
+    def parse_response(response)
+      content_type = response.headers[:content_type]
+      parse_as = {
+        %r{^application/json} => :json,
+        %r{^image/.*} => :file,
+        %r{^text/html} => :xml,
+        %r{^text/plain} => :plain
+      }.each_with_object([]) { |match, memo| memo << match[1] if content_type =~ match[0] }.first || :plain
+
+      if parse_as == :plain
+        result = JSON.parse(response&.body&.to_s)
+        result && yield(:json, result)
+
+        yield(:plain, response.body)
+      end
+
+      case parse_as
+      when :json
+        result = JSON.parse(response.body.to_s)
+      when :file
+        extension =
+          if response.headers[:content_type] =~ %r{^image/.*}
+            {
+              "image/gif": ".gif",
+              "image/jpeg": ".jpg",
+              "image/png": ".png"
+            }[response.headers["content-type"]]
+          else
+            ""
+          end
+
+        begin
+          file = Tempfile.new(["mixin-file-", extension])
+          file.binmode
+          file.write(response.body)
+        ensure
+          file&.close
+        end
+
+        result = file
+      when :xml
+        result = Hash.from_xml(response.body.to_s)
+      else
+        result = response.body
+      end
+
+      yield(parse_as, result)
+    end
+  end
+end

data/lib/trident_assistant/utils/memo.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module TridentAssistant
+  module Utils
+    # build metadata of NFT
+    class Memo
+      attr_accessor :type, :token_id, :asset_id, :order_id, :price, :reserve_price, :receiver_id, :start_at,
+                    :expire_at, :encoded, :decoded
+
+      def initialize(**kwargs)
+        @type = kwargs[:type]
+        @token_id = kwargs[:token_id]
+        @asset_id = kwargs[:asset_id]
+        @order_id = kwargs[:order_id]
+        @price = kwargs[:price]
+        @reserve_price = kwargs[:reserve_price]
+        @receiver_id = kwargs[:receiver_id]
+        @start_at = kwargs[:start_at]
+        @expire_at = kwargs[:expire_at]
+        @encoded = kwargs[:encoded]
+      end
+
+      def json
+        {
+          T: type,
+          N: token_id,
+          A: asset_id,
+          O: order_id,
+          P: price,
+          R: reserve_price,
+          RC: receiver_id,
+          S: start_at,
+          E: expire_at
+        }.compact
+      end
+
+      def encode
+        hash = {
+          T: type,
+          N: token_id && MixinBot::Utils::UUID.new(hex: token_id).packed,
+          A: asset_id && MixinBot::Utils::UUID.new(hex: asset_id).packed,
+          O: order_id && MixinBot::Utils::UUID.new(hex: order_id).packed,
+          P: price && format("%.8f", price.to_f).gsub(/(0)+\z/, ""),
+          R: reserve_price && format("%.8f", reserve_price.to_f).gsub(/(0)+\z/, ""),
+          RC: receiver_id && MixinBot::Utils::UUID.new(hex: receiver_id).packed,
+          S: start_at && Time.parse(start_at).to_i,
+          E: expire_at && Time.parse(start_at).to_i
+        }.compact
+
+        @encoded =
+          Base64.urlsafe_encode64(
+            MessagePack.pack(hash),
+            padding: false
+          )
+      end
+
+      def decode
+        json
+      end
+    end
+  end
+end

data/lib/trident_assistant/utils/metadata.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module TridentAssistant
+  module Utils
+    # build metadata of NFT
+    class Metadata
+      class InvalidFormatError < TridentAssistant::Error; end
+
+      attr_reader :creator, :collection, :token, :checksum
+
+      def initialize(**kwargs)
+        @creator = kwargs[:creator] || {}
+        @collection = kwargs[:collection] || {}
+        @token = kwargs[:token] || {}
+        @checksum = kwargs[:checksum] || {}
+      end
+
+      def json
+        {
+          creator: creator,
+          collection: collection,
+          token: token,
+          checksum: checksum
+        }.compact.with_indifferent_access
+      end
+
+      def validate!
+        raise InvalidFormatError, creator unless creator_valid?
+        raise InvalidFormatError, collection unless collection_valid?
+        raise InvalidFormatError, token unless token_valid?
+        raise InvalidFormatError, checksum unless checksum_valid?
+        raise InvalidFormatError, "failed to validate hash" unless all_hash_valid?
+
+        true
+      end
+
+      def valid?
+        creator_valid? && collection_valid? && token_valid? && checksum_valid? && all_hash_valid?
+      end
+
+      def creator_valid?
+        return false unless creator.is_a?(Hash)
+
+        @creator = creator.with_indifferent_access
+        creator["id"].present? && creator["name"].present?
+      end
+
+      def collection_valid?
+        return false unless collection.is_a?(Hash)
+
+        @collection = collection.with_indifferent_access
+        return false unless collection["id"].match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/)
+        return false if collection["name"].blank?
+
+        true
+      end
+
+      def token_valid?
+        return false unless token.is_a?(Hash)
+
+        @token = token.with_indifferent_access
+        return false unless token["id"].match?(/\A(?!0)\d+\z/)
+        return false if token["id"].to_i > 8**64
+        return false if token["name"].blank?
+
+        true
+      end
+
+      def checksum_valid?
+        return false unless checksum.is_a?(Hash)
+
+        @checksum = checksum.with_indifferent_access
+        checksum["algorithm"] && checksum["fields"].is_a?(Array)
+      end
+
+      def all_hash_valid?
+        checksum["fields"].each do |field|
+          value = json
+
+          field.split(".").each do |key|
+            next unless value.is_a?(Hash)
+
+            return false if key == "hash" && value["hash"] != TridentAssistant::Utils.hash_from_url(value["url"])
+
+            value = value[key]
+          end
+        end
+
+        true
+      end
+
+      def checksum_content
+        return unless checksum_valid?
+
+        checksum["fields"].map do |field|
+          value = json
+          field.split(".").each do |key|
+            value = (value[key] if value.is_a?(Hash))
+          end
+          value.to_s
+        end.join
+      end
+
+      def metahash
+        return unless valid?
+
+        alg = checksum["algorithm"]
+        case alg
+        when "sha256", "sha3-256"
+          SHA3::Digest::SHA256.hexdigest checksum_content
+        else
+          raise "algorithm #{alg} not supported!"
+        end
+      end
+    end
+  end
+end

data/lib/trident_assistant/utils.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "./utils/memo"
+require_relative "./utils/metadata"
+
+module TridentAssistant
+  # Some useful methods
+  module Utils
+    MINT_ASSET_ID = "c94ac88f-4671-3976-b60a-09064f1811e8"
+    MINT_AMOUNT = 0.001
+    NFO_MTG = {
+      members: %w[
+        047061e6-496d-4c35-b06b-b0424a8a400d
+        4b188942-9fb0-4b99-b4be-e741a06d1ebf
+        50115496-7247-4e2c-857b-ec8680756bee
+        a51006d0-146b-4b32-a2ce-7defbf0d7735
+        acf65344-c778-41ee-bacb-eb546bacfb9f
+        cf4abd9c-2cfa-4b5a-b1bd-e2b61a83fabd
+        dd655520-c919-4349-822f-af92fabdbdf4
+      ].sort,
+      threshold: 5
+    }.freeze
+    TRIDENT_MTG = {
+      members: %w[
+        6f5a84ce-d663-451e-b413-2d0c84b7629d
+        99216bb5-9787-49b6-b251-537362ce23eb
+        fcc1e3ec-97f1-41a7-89a3-20a0ec30a31f
+        1a361145-66a7-48cd-ab6c-db9a42da4074
+        9ba50819-159c-45e6-9bed-1eb2dded3360
+      ].sort,
+      threshold: 3
+    }.freeze
+
+    class << self
+      def hash_from_url(url)
+        return if url.to_s.blank?
+
+        content =
+          begin
+            URI.parse(url).open(&:read)
+          rescue OpenURI::HTTPError
+            ""
+          end
+
+        SHA3::Digest::SHA256.hexdigest content
+      end
+
+      def mixin_bot_from_keystore(keystore)
+        keystore = parse_json keystore if keystore.is_a?(String)
+
+        MixinBot::API.new(
+          client_id: keystore["client_id"],
+          session_id: keystore["session_id"],
+          pin_token: keystore["pin_token"],
+          private_key: keystore["private_key"]
+        )
+      end
+
+      def parse_metadata(input)
+        metadata =
+          case input
+          when String
+            TridentAssistant::Utils.parse_json input
+          when Hash
+            input
+          else
+            {}
+          end
+        TridentAssistant::Utils::Metadata.new(
+          creator: metadata["creator"],
+          collection: metadata["collection"],
+          token: metadata["token"],
+          checksum: metadata["checksum"]
+        )
+      end
+
+      def parse_json(input)
+        input =
+          if File.file? input
+            File.read input
+          else
+            input
+          end
+        JSON.parse(input).with_indifferent_access
+      end
+    end
+  end
+end

data/lib/trident_assistant/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TridentAssistant
+  VERSION = "0.1.0"
+end

data/lib/trident_assistant.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "mixin_bot"
+require "open-uri"
+
+# Trident SDK
+module TridentAssistant
+  class Error < StandardError; end
+
+  def self.api
+    TridentAssistant::API.new
+  end
+end
+
+require_relative "trident_assistant/api"
+require_relative "trident_assistant/cli"
+require_relative "trident_assistant/utils"
+require_relative "trident_assistant/version"

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: trident_assistant
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- an-lee
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mixin_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: A simple program to use Trident NFT
+email:
+- an.lee.work@gmail.com
+executables:
+- ta
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/ta
+- lib/trident_assistant.rb
+- lib/trident_assistant/api.rb
+- lib/trident_assistant/api/collectible.rb
+- lib/trident_assistant/api/collection.rb
+- lib/trident_assistant/api/metadata.rb
+- lib/trident_assistant/api/order.rb
+- lib/trident_assistant/cli.rb
+- lib/trident_assistant/cli/base.rb
+- lib/trident_assistant/cli/collectible.rb
+- lib/trident_assistant/cli/collection.rb
+- lib/trident_assistant/cli/metadata.rb
+- lib/trident_assistant/cli/nfo.rb
+- lib/trident_assistant/cli/order.rb
+- lib/trident_assistant/cli/utils.rb
+- lib/trident_assistant/client.rb
+- lib/trident_assistant/utils.rb
+- lib/trident_assistant/utils/memo.rb
+- lib/trident_assistant/utils/metadata.rb
+- lib/trident_assistant/version.rb
+homepage: https://github.com/TheTridentOne/trident_assistant
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/TheTridentOne/trident_assistant
+  source_code_uri: https://github.com/TheTridentOne/trident_assistant
+  changelog_uri: https://github.com/TheTridentOne/trident_assistant
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.4
+signing_key:
+specification_version: 4
+summary: A simple program to use Trident NFT
+test_files: []