gate.rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97a150ad280b246d59dce0e7e011ae8faeaf9f3c743b726ae931a7353457e5b3
+  data.tar.gz: a530909743923390245e633b04703c81fe9d78d10387118c959cea4d59a94e41
+SHA512:
+  metadata.gz: e05641f6589dd90c24b86779b8845309da739e3fc662712c43b9ac49c00abd0097a45b17f77378ef94d943566da09b03519792e5b9d965d9e7ac953bdc6bd252
+  data.tar.gz: a40ba066ccc2aeeea27067601a0d91bd5f41ac5c5843c599efa58c69bd5b71bde598fec6979efdab6582d8ff634d1c02aa815d0de91050425ff90ef685e35cf4

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'http.rb'
+
+group :development, :test do
+  gem 'rake'
+  gem 'minitest'
+  gem 'minitest-spec-context'
+  gem 'vcr'
+  gem 'webmock'
+end

data/README.md

@@ -0,0 +1,88 @@
+# gate.rb
+
+Access the Gate API with Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gate.rb'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install gate.rb
+```
+
+## Usage
+
+```ruby
+client = Gate::Client.new(
+  api_key: 'your_api_key',
+  api_secret: 'your_api_secret',
+)
+```
+
+### Public API Methods
+
+```ruby
+# Get all currencies
+client.spot_currencies
+
+# Get specific currency
+client.spot_currencies('BTC')
+
+# Get all symbol/currency pairs
+client.currency_pairs
+
+# Get one symbol/currency pair
+client.currency_pairs('BTC_USDT')
+
+# Get all ticker
+client.spot_tickers
+
+# Get ticker for one symbol/currency pair
+client.spot_tickers(currency_pair: 'BTC_USDT')
+
+# Get order book for a symbol/currency pair
+client.spot_order_book(currency_pair: 'BTC_USDT')
+
+# Get order book for a symbol/currency pair
+client.spot_trades(currency_pair: 'BTC_USDT')
+
+# Get OHLC for a symbol/currency pair
+client.spot_candlesticks(currency_pair: 'BTC_USDT')
+
+# Get OHLC for a symbol for specific period
+client.spot_candlesticks('BTC_USDT', interval: '1d', start_time: 1648995780000, end_time: 1649082180000)
+
+# Get server time
+client.spot_time
+```
+
+### A Private API Method
+
+```ruby
+# Get the authenticated user's trades for specific symbol/currency pair
+client.spot_orders(currency_pair: 'BTC_USDT')
+```
+
+## Contributing
+
+1. Fork it (https://github.com/thoran/gate.rb/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new pull request
+
+## License
+
+The gem is available as open source under the terms of the [Ruby License](https://opensource.org/licenses/MIT).

data/gate.rb.gemspec

@@ -0,0 +1,28 @@
+require_relative './lib/Gate/VERSION'
+
+Gem::Specification.new do |spec|
+  spec.name = 'gate.rb'
+
+  spec.version = Gate::VERSION
+  spec.date = '2025-07-14'
+
+  spec.summary = "Access the Gate API with Ruby."
+  spec.description = "Access the Gate API with Ruby."
+
+  spec.author = 'thoran'
+  spec.email = 'code@thoran.com'
+  spec.homepage = 'http://github.com/thoran/gate.rb'
+  spec.license = 'Ruby'
+
+  spec.required_ruby_version = '>= 2.7'
+
+  spec.add_dependency('http.rb')
+  spec.files = [
+    'gate.rb.gemspec',
+    'Gemfile',
+    Dir['lib/**/*.rb'],
+    'README.md',
+    Dir['test/**/*.rb']
+  ].flatten
+  spec.require_paths = ['lib']
+end

data/lib/Gate/Client.rb

@@ -0,0 +1,8 @@
+# Gate/Client.rb
+# Gate::Client
+
+require_relative './V4/Client'
+
+module Gate
+  class Client < Gate::V4::Client; end
+end

data/lib/Gate/Error.rb

@@ -0,0 +1,30 @@
+# Gate/Error.rb
+# Gate::Error
+
+module Gate
+  class Error < RuntimeError
+    attr_reader\
+      :code,
+      :message,
+      :body
+
+    def to_s
+      "#{self.class} (#{@code}): #{@message}"
+    end
+
+    private
+
+    def initialize(code:, message:, body:)
+      @code = code
+      @message = message
+      @body = body
+      super(message)
+    end
+  end
+
+  class APIError < Error; end
+  class AuthenticationError < Error; end
+  class InvalidRequestError < Error; end
+  class NetworkError < Error; end
+  class RateLimitError < Error; end
+end

data/lib/Gate/V4/Client.rb

@@ -0,0 +1,254 @@
+# Gate/V4/Client.rb
+# Gate::V4::Client
+
+# 20250714
+# 0.1.0
+
+# Notes:
+# 1. API methods appear in the order in which they appear in the documentation.
+
+gem 'http.rb'; require 'http.rb'
+require 'json'
+require 'openssl'
+
+require 'Gate/Error'
+require 'Hash/stringify_values'
+require 'Hash/x_www_form_urlencode'
+
+module Gate
+  module V4
+    class Client
+
+      API_HOST = 'api.gateio.ws'
+
+      class << self
+        def path_prefix
+          '/api/v4'
+        end
+      end # class << self
+
+      # Public endpoints
+
+      def spot_currencies(currency = nil)
+        response = get(
+          path: "/spot/currencies/#{currency}"
+        )
+        handle_response(response)
+      end
+
+      def spot_currency_pairs(currency_pair = nil)
+        response = get(
+          path: "/spot/currency_pairs/#{currency_pair}"
+        )
+        handle_response(response)
+      end
+
+      def spot_tickers(currency_pair: nil, timezone: nil)
+        response = get(
+          path: '/spot/tickers',
+          args: {currency_pair: currency_pair, timezone: timezone}
+        )
+        handle_response(response)
+      end
+
+      def spot_order_book(
+        currency_pair:,
+        interval: nil,
+        limit: nil,
+        with_id: nil
+      )
+        response = get(
+          path: '/spot/order_book',
+          args: {
+            currency_pair: currency_pair,
+            interval: interval,
+            limit: limit,
+            with_id: with_id
+          }
+        )
+        handle_response(response)
+      end
+
+      def spot_trades(
+        currency_pair:,
+        limit: nil,
+        last_id: nil,
+        reverse: nil,
+        from: nil,
+        to: nil,
+        page: nil
+      )
+        response = get(
+          path: '/spot/trades',
+          args: {
+            currency_pair: currency_pair,
+            limit: limit,
+            last_id: last_id,
+            reverse: reverse,
+            from: from,
+            to: to,
+            page: page
+          }
+        )
+        handle_response(response)
+      end
+
+      def spot_candlesticks(
+        currency_pair:,
+        limit: nil,
+        from: nil,
+        to: nil,
+        interval: nil
+      )
+        response = get(
+          path: '/spot/candlesticks',
+          args: {
+            currency_pair: currency_pair,
+            limit: limit,
+            from: from,
+            to: to,
+            interval: interval
+          }
+        )
+        handle_response(response)
+      end
+
+      def spot_time
+        response = get(
+          path: '/spot/time'
+        )
+        handle_response(response)
+      end
+
+      def spot_orders(
+        text: nil,
+        currency_pair:,
+        type: nil,
+        account: nil,
+        side:,
+        amount:,
+        price: nil,
+        time_in_force: nil,
+        iceberg: nil
+      )
+        args = {
+          text: text,
+          currency_pair: currency_pair,
+          type: type,
+          account: account,
+          side: side,
+          amount: amount,
+          price: price,
+          time_in_force: time_in_force,
+          iceberg: iceberg
+        }.reject{|k,v| v.nil?}.stringify_values
+        response = post(
+          path: '/spot/orders',
+          args: args
+        )
+        handle_response(response)
+      end
+
+      private
+
+      def initialize(api_key:, api_secret:)
+        @api_key = api_key.encode('UTF-8')
+        @api_secret = api_secret.encode('UTF-8')
+      end
+
+      def full_path(path)
+        self.class.path_prefix + path
+      end
+
+      def encoded_payload(args)
+        args.reject!{|k,v| v.nil?}
+        OpenSSL::Digest::SHA512.hexdigest(JSON.dump(args))
+      end
+
+      def timestamp
+        @timestamp ||= Time.now.to_i.to_s
+      end
+
+      def message(verb:, path:, args:)
+        query_string = (
+          case verb
+          when 'GET'
+            args.x_www_form_urlencode
+          when 'POST'
+            nil
+          else
+            raise "The verb, #{verb}, is not acceptable."
+          end
+        )
+        [verb, full_path(path), query_string, encoded_payload(args), timestamp].join("\n")
+      end
+
+      def signature(message)
+        OpenSSL::HMAC.hexdigest('SHA512', @api_secret, message)
+      end
+
+      def request_string(path)
+        "https://#{API_HOST}#{self.class.path_prefix}#{path}"
+      end
+
+      def headers(signature)
+        {
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/json',
+          'KEY' => @api_key,
+          'SIGN' => signature,
+          'Timestamp' => timestamp,
+        }
+      end
+
+      def do_request(verb:, path:, args: {})
+        message = message(verb: verb, path: path, args: args)
+        signature = signature(message)
+        response = HTTP.send(verb.to_s.downcase, request_string(path), args, headers(signature))
+        @timestamp = nil
+        response
+      end
+
+      def get(path:, args: {})
+        do_request(verb: 'GET', path: path, args: args)
+      end
+
+      def post(path:, args: {})
+        do_request(verb: 'POST', path: path, args: args)
+      end
+
+      def handle_response(response)
+        if response.success?
+          JSON.parse(response.body)
+        else
+          case response.code.to_i
+          when 400
+            raise Gate::InvalidRequestError.new(
+              code: response.code,
+              message: response.message,
+              body: response.body
+            )
+          when 401
+            raise Gate::AuthenticationError.new(
+              code: response.code,
+              message: response.message,
+              body: response.body
+            )
+          when 429
+            raise Gate::RateLimitError.new(
+              code: response.code,
+              message: response.message,
+              body: response.body
+            )
+          else
+            raise Gate::APIError.new(
+              code: response.code,
+              message: response.message,
+              body: response.body
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/Gate/VERSION.rb

@@ -0,0 +1,6 @@
+# Gate/VERSION.rb
+# Gate::VERSION
+
+module Gate
+  VERSION = '0.1.0'
+end

data/lib/Hash/stringify_values.rb

@@ -0,0 +1,14 @@
+# Hash/stringify_values.rb
+# Hash#stringify_values
+
+# 20250425
+# 0.0.0
+
+class Hash
+  def stringify_values
+    self.inject({}) do |a,e|
+      a[e.first] = e.last.to_s
+      a
+    end
+  end
+end

data/lib/Hash/x_www_form_urlencode.rb

@@ -0,0 +1,7 @@
+# Hash/x_www_form_urlencode.rb
+# Hash#x_www_form_urlencode
+
+# 20241009
+# 0.1.0
+
+require 'Thoran/Hash/XWwwFormUrlencode/x_www_form_urlencode'

data/lib/Thoran/Hash/XWwwFormUrlencode/x_www_form_urlencode.rb

@@ -0,0 +1,26 @@
+# Thoran/Hash/XWwwFormUrlEncode/x_www_form_urlencode.rb
+# Thoran::Hash::XWwwFormUrlEncode#x_www_form_urlencode
+
+# 20241009
+# 0.2.0
+
+# Changes since 0.1:
+# -/0: (The class name and the snake case name are consistent now.)
+# 1. /XWWWFormUrlEncode/XWwwFormUrlEncode/
+
+require 'Thoran/String/UrlEncode/url_encode'
+
+module Thoran
+  module Hash
+    module XWwwFormUrlEncode
+
+      def x_www_form_url_encode(joiner = '&')
+        inject([]){|a,e| a << "#{e.first.to_s.url_encode}=#{e.last.to_s.url_encode}" unless e.last.nil?; a}.join(joiner)
+      end
+      alias_method :x_www_form_urlencode, :x_www_form_url_encode
+
+    end
+  end
+end
+
+Hash.send(:include, Thoran::Hash::XWwwFormUrlEncode)

data/lib/Thoran/String/UrlEncode/url_encode.rb

@@ -0,0 +1,26 @@
+# Thoran/String/UrlEncode/url_encode.rb
+# Thoran::String::UrlEncode#url_encode
+
+# 20160505
+# 0.3.0
+
+# Acknowledgements: I've simply ripped off and refashioned the code from the CGI module!...
+
+# Changes since 0.2:
+# 1. + Thoran namespace.
+
+module Thoran
+  module String
+    module UrlEncode
+
+      def url_encode
+        self.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
+          '%' + $1.unpack('H2' * $1.size).join('%').upcase
+        end.tr(' ', '+')
+      end
+
+    end
+  end
+end
+
+String.send(:include, Thoran::String::UrlEncode)

data/lib/gate.rb

@@ -0,0 +1,9 @@
+# gate.rb
+
+lib_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+module Gate; end
+
+require 'Gate/Client'
+require 'Gate/VERSION'

data/test/Gate/V4/Client/test_private_endpoints.rb

@@ -0,0 +1,43 @@
+require_relative '../../../helper'
+
+describe Gate::V4::Client do
+  let(:api_key){ENV.fetch('GATE_API_KEY', '<API_KEY>')}
+  let(:api_secret){ENV.fetch('GATE_API_SECRET', '<API_SECRET>')}
+
+  subject do
+    Gate::V4::Client.new(
+      api_key: api_key,
+      api_secret: api_secret
+    )
+  end
+
+  describe "#spot_orders" do
+    let(:amount){0.0001}
+    let(:price){100_000}
+    let(:side){'buy'}
+
+    context "success" do
+      it "fetches my orders for a specific market" do
+        VCR.use_cassette('v4/spot/orders') do
+          response = subject.spot_orders(currency_pair: 'BTC_USDT', side: side, amount: amount, time_in_force: 'gtc', price: price)
+          _(response).must_be_kind_of(Hash)
+          assert(response['id'])
+          assert(response['create_time'])
+          _(response['amount']).must_equal(amount.to_s)
+          _(response['price']).must_equal(price.to_s)
+          _(response['side']).must_equal(side)
+        end
+      end
+    end
+
+    context "invalid key" do
+      it "fetches my orders for a specific market" do
+        VCR.use_cassette('v4/spot/orders_with_an_invalid_key') do
+          assert_raises do
+            subject.spot_orders(currency_pair: 'BTC_USDT', side: side, amount: amount, time_in_force: 'gtc', price: price)
+          end
+        end
+      end
+    end
+  end
+end

data/test/Gate/V4/Client/test_public_endpoints.rb

@@ -0,0 +1,147 @@
+require_relative '../../../helper'
+
+describe Gate::V4::Client do
+  let(:api_key){ENV.fetch('GATE_API_KEY', '<API_KEY>')}
+  let(:api_secret){ENV.fetch('GATE_API_SECRET', '<API_SECRET>')}
+
+  subject do
+    Gate::V4::Client.new(
+      api_key: api_key,
+      api_secret: api_secret
+    )
+  end
+
+  describe "#spot_currencies" do
+    context "no currency specified" do
+      it "fetches all currencies" do
+        VCR.use_cassette('v4/spot/currencies') do
+          response = subject.spot_currencies
+          _(response).must_be_kind_of(Array)
+          assert(response.size > 4000)
+          _(response[0]['currency']).must_equal('BBC')
+        end
+      end
+    end
+
+    context "currency specified" do
+      it "fetches one currency" do
+        VCR.use_cassette('v4/spot/currencies_btc') do
+          response = subject.spot_currencies('BTC')
+          _(response).must_be_kind_of(Hash)
+          _(response.size).must_equal(10)
+          _(response['currency']).must_equal('BTC')
+        end
+      end
+    end
+  end
+
+  describe "#spot_currency_pairs" do
+    context "no pair specified" do
+      it "fetches data for all markets" do
+        VCR.use_cassette('v4/spot/currency_pairs') do
+          response = subject.spot_currency_pairs
+          _(response).must_be_kind_of(Array)
+          assert(response.size > 2000)
+          _(response[0]['id']).must_equal('ALEPH_USDT')
+          _(response[0]['base']).must_equal('ALEPH')
+          _(response[0]['quote']).must_equal('USDT')
+        end
+      end
+    end
+
+    context "pair specified" do
+      it "fetches data for one market" do
+        VCR.use_cassette('v4/spot/currency_pairs_btc') do
+          response = subject.spot_currency_pairs('BTC_USDT')
+          _(response).must_be_kind_of(Hash)
+          _(response.size).must_equal(18)
+          _(response['id']).must_equal('BTC_USDT')
+          _(response['base']).must_equal('BTC')
+          _(response['quote']).must_equal('USDT')
+        end
+      end
+    end
+  end
+
+  describe "#spot_tickers" do
+    context "no ticker specified" do
+      it "fetches tickers for all markets" do
+        VCR.use_cassette('v4/spot/tickers') do
+          response = subject.spot_tickers
+          _(response).must_be_kind_of(Array)
+          assert(response.size > 2000)
+          _(response[0]['currency_pair']).must_equal('BAND_USDT')
+          assert(response[0]['last'].match(/\d+\.\d*/))
+          assert(response[0]['change_percentage'].match(/\d+\.\d*/))
+        end
+      end
+    end
+
+    context "ticker specified" do
+      it "fetches ticker for a specific market" do
+        VCR.use_cassette('v4/spot/tickers_btc') do
+          response = subject.spot_tickers(currency_pair: 'BTC_USDT')
+          _(response).must_be_kind_of(Array)
+          _(response[0]['currency_pair']).must_equal('BTC_USDT')
+          assert(response[0]['last'].match(/\d+\.\d*/))
+          assert(response[0]['change_percentage'].match(/\d+\.\d*/))
+        end
+      end
+    end
+  end
+
+  describe "#spot_order_book" do
+    it "retrieves order book for a specific market" do
+      VCR.use_cassette('v4/spot/order_book') do
+        response = subject.spot_order_book(currency_pair:'BTC_USDT', limit: 10)
+        _(response).must_be_kind_of(Hash)
+        _(response['asks'].size).must_equal(10)
+        _(response['bids'].size).must_equal(10)
+        _(response['asks']).must_be_kind_of(Array)
+        _(response['bids']).must_be_kind_of(Array)
+        assert(response['asks'].first.first.match(/\d+\.*\d*/))
+        assert(response['asks'].first.last.match(/\d+\.*\d*/))
+        assert(response['bids'].first.first.match(/\d+\.*\d*/))
+        assert(response['bids'].first.last.match(/\d+\.*\d*/))
+      end
+    end
+  end
+
+  describe "#spot_trades" do
+    it "fetches recent trades for a given market" do
+      VCR.use_cassette('v4/spot/trades') do
+        response = subject.spot_trades(currency_pair: 'BTC_USDT', limit: 10)
+        _(response).must_be_kind_of(Array)
+        _(response.size).must_equal(10)
+        assert(response[0]['id'].match(/\d+\.*\d*/))
+        assert(response[0]['side'] == 'buy' || response[0]['side'] == 'sell')
+        assert(response[0]['amount'].match(/\d+\.*\d*/))
+        assert(response[0]['price'].match(/\d+\.*\d*/))
+      end
+    end
+  end
+
+  describe "#spot_candlesticks" do
+    it "fetches candlestick data for a specific market" do
+      VCR.use_cassette('v4/spot/candlesticks') do
+        response = subject.spot_candlesticks(currency_pair: 'BTC_USDT', interval: '1h', limit: 10)
+        _(response).must_be_kind_of(Array)
+        _(response.size).must_equal(10)
+        _(response[0].size).must_equal(8)
+        assert(response[0][0].match(/\d+\.*\d*/))
+        assert(response[0][1].match(/\d+\.*\d*/)) # open
+        assert(response[0][4].match(/\d+\.*\d*/)) # close
+      end
+    end
+  end
+
+  describe "#spot_time" do
+    it "fetches candlestick data for a specific market" do
+      VCR.use_cassette('v4/spot/time') do
+        response = subject.spot_time
+        _(response).must_be_kind_of(Hash)
+        assert(response['server_time'].to_s.match(/\d+\.*\d*/))
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,32 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest-spec-context'
+require 'vcr'
+require 'webmock'
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'gate'
+
+VCR.configure do |config|
+  config.cassette_library_dir = 'test/fixtures/vcr_cassettes'
+
+  config.hook_into :webmock
+
+  config.filter_sensitive_data('<API_KEY>'){ENV['GATE_API_KEY']}
+  config.filter_sensitive_data('<API_SECRET>'){ENV['GATE_API_SECRET'] }
+
+  # Allow localhost connections for debugging
+  config.ignore_localhost = true
+
+  config.default_cassette_options = {
+    record: :new_episodes,
+    match_requests_on: [:method, :uri]
+  }
+end
+
+class Minitest::Test
+  def before_setup
+    super
+    Gate.reset_configuration!
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: gate.rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- thoran
+bindir: bin
+cert_chain: []
+date: 2025-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Access the Gate API with Ruby.
+email: code@thoran.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- gate.rb.gemspec
+- lib/Gate/Client.rb
+- lib/Gate/Error.rb
+- lib/Gate/V4/Client.rb
+- lib/Gate/VERSION.rb
+- lib/Hash/stringify_values.rb
+- lib/Hash/x_www_form_urlencode.rb
+- lib/Thoran/Hash/XWwwFormUrlencode/x_www_form_urlencode.rb
+- lib/Thoran/String/UrlEncode/url_encode.rb
+- lib/gate.rb
+- test/Gate/V4/Client/test_private_endpoints.rb
+- test/Gate/V4/Client/test_public_endpoints.rb
+- test/helper.rb
+homepage: http://github.com/thoran/gate.rb
+licenses:
+- Ruby
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Access the Gate API with Ruby.
+test_files: []