partner_api 0.11.2

data/lib/fab_api/endpoints/exchange_token.rb

@@ -0,0 +1,49 @@
+require 'fab_api/endpoint'
+require 'fab_api/utils/id'
+
+module FabApi
+  module Endpoints
+    class ExchangeToken < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      def initialize(access_token:, system:, transaction_id: Utils::Id.generate)
+        @access_token = access_token
+        @system = system
+        @transaction_id = transaction_id
+      end
+
+      private
+
+      attr_reader :access_token, :system, :transaction_id
+
+      def method
+        "POST"
+      end
+
+      def path
+        "/security/v1/verifytoken"
+      end
+
+      def parameters
+        {
+          "applicationArea": {
+            "transactionId": transaction_id,
+          },
+          "dataArea": {
+            system: system,
+            accessCode: access_token,
+            grantType: 'authorization_code'
+          }
+        }
+      end
+
+      def decode(response)
+        response.parse.dig('dataArea', 'token')
+      end
+
+      def logging_params
+        { transaction_id: transaction_id }
+      end
+    end
+  end
+end

data/lib/fab_api/endpoints/invalidate_token.rb

@@ -0,0 +1,53 @@
+require 'fab_api/endpoint'
+require 'fab_api/utils/id'
+
+module FabApi
+  module Endpoints
+    class InvalidateToken < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      def initialize(
+        partner_user_id:,
+        access_token:,
+        system:,
+        transaction_id: Utils::Id.generate
+      )
+        @partner_user_id = partner_user_id
+        @access_token = access_token
+        @system = system
+        @transaction_id = transaction_id
+      end
+
+      private
+
+      attr_reader :partner_user_id, :access_token, :system, :transaction_id
+
+      def method
+        "POST"
+      end
+
+      def path
+        "/security/v1/invalidatetoken"
+      end
+
+      def parameters
+        {
+          "applicationArea": {
+            "transactionId": transaction_id,
+          },
+          "dataArea": {
+            system: system,
+            accessCode: access_token,
+            userId: partner_user_id
+          }
+        }
+      end
+
+      def decode(_response); end
+
+      def logging_params
+        { transaction_id: transaction_id, user_id: partner_user_id }
+      end
+    end
+  end
+end

data/lib/fab_api/endpoints/refresh_token.rb

@@ -0,0 +1,60 @@
+require 'fab_api/endpoint'
+require 'fab_api/utils/id'
+
+module FabApi
+  module Endpoints
+    class RefreshToken < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      def initialize(
+        access_token:,
+        refresh_token:,
+        system:,
+        transaction_id: Utils::Id.generate,
+        new_token_flag: true
+      )
+        @access_token = access_token
+        @refresh_token = refresh_token
+        @system = system
+        @transaction_id = transaction_id
+        @new_token_flag = new_token_flag
+      end
+
+      private
+
+      attr_reader :access_token, :refresh_token, :system, :transaction_id,
+        :new_token_flag
+
+      def method
+        "POST"
+      end
+
+      def path
+        "/security/v1/verifytoken"
+      end
+
+      def parameters
+        {
+          "applicationArea": {
+            "transactionId": transaction_id,
+          },
+          "dataArea": {
+            system: system,
+            accessCode: access_token,
+            refreshCode: refresh_token,
+            grantType: 'refresh_token',
+            newTokenRequired: new_token_flag
+          }
+        }
+      end
+
+      def decode(response)
+        response.parse.dig('dataArea', 'token')
+      end
+
+      def logging_params
+        { transaction_id: transaction_id }
+      end
+    end
+  end
+end

data/lib/fab_api/failure_response.rb

@@ -0,0 +1,39 @@
+require 'partner_api/errors'
+
+module FabApi
+  class FailureResponse
+    def initialize(response)
+      @response = response
+    end
+
+    def errors
+      if response.status.success?
+        response.parse['responseStatus']['errorDetails'].map do |error|
+          PartnerApi::Errors::RequestError.new(code: error['errorCode'], message: error['errorDesc'])
+        end
+      else
+        [PartnerApi::Errors::RequestError.new(message: "Invalid Response: #{body}")]
+      end
+    end
+
+    def error
+      errors.first
+    end
+
+    def status
+      response.status
+    end
+
+    def body
+      response.body
+    end
+
+    def headers
+      response.headers.to_h
+    end
+
+    private
+
+    attr_reader :response
+  end
+end

data/lib/fab_api/utils/id.rb

@@ -0,0 +1,13 @@
+require 'securerandom'
+
+module FabApi
+  module Utils
+    module Id
+      # Make sure identifier start with AS,
+      # followed by any unique characters and max length of 24 characters.
+      def self.generate
+        "AS#{SecureRandom.hex(11)}"
+      end
+    end
+  end
+end

data/lib/fab_api.rb

@@ -0,0 +1,18 @@
+require 'forwardable'
+require 'concurrent-ruby'
+
+require 'fab_api/client'
+require 'fab_api/configuration'
+
+module FabApi
+  extend self
+  extend Forwardable
+
+  @configuration = Concurrent::Hash.new
+
+  def_delegators 'configuration(:default)', :config, :configure
+
+  def configuration(key)
+    @configuration[key] ||= Configuration.new
+  end
+end

data/lib/gemini_api/address.rb

@@ -0,0 +1,23 @@
+module GeminiApi
+  Address = Struct.new(
+    :network,
+    :scope,
+    :label,
+    :status,
+    :created_at,
+    :address,
+    :raw_data,
+    keyword_init: true
+  ) do
+    def self.build(raw_data)
+      new(
+        network: raw_data['network'],
+        scope: raw_data['scope'],
+        label: raw_data['label'],
+        status: raw_data['status'],
+        created_at: Time.at(raw_data['createdAt'].to_f / 1000),
+        address: raw_data['address']
+      )
+    end
+  end
+end

data/lib/gemini_api/balance.rb

@@ -0,0 +1,24 @@
+require 'bigdecimal'
+
+module GeminiApi
+  Balance = Struct.new(
+    :type,
+    :currency,
+    :amount,
+    :available,
+    :available_for_withdrawal,
+    :raw_data,
+    keyword_init: true
+  ) do
+    def self.build(raw_data)
+      new(
+        type: raw_data['type'],
+        currency: raw_data['currency'],
+        amount: BigDecimal(raw_data['amount']),
+        available: BigDecimal(raw_data['available']),
+        available_for_withdrawal: BigDecimal(raw_data['availableForWithdrawal']),
+        raw_data: raw_data
+      )
+    end
+  end
+end

data/lib/gemini_api/client.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'hanami/utils/string'
+require 'hanami/utils/class'
+
+require 'gemini_api/endpoints/create_address_request'
+require 'gemini_api/endpoints/view_approved_addresses'
+require 'gemini_api/endpoints/withdraw_crypto_fund'
+require 'gemini_api/endpoints/get_available_balances'
+require 'gemini_api/endpoints/view_transfers'
+
+module GeminiApi
+  class Client
+    def self.endpoint(name)
+      define_method(name) do |**args|
+        klass_name = Hanami::Utils::String.classify(name)
+        endpoint_klass = Hanami::Utils::Class.load!("GeminiApi::Endpoints::#{klass_name}")
+
+        endpoint_klass.(config, **args)
+      end
+    end
+
+    endpoint :create_address_request
+    endpoint :view_approved_addresses
+    endpoint :withdraw_crypto_fund
+    endpoint :get_available_balances
+    endpoint :view_transfers
+
+    def initialize(config: GeminiApi.config)
+      @config = config
+    end
+
+    private
+
+    attr_reader :config
+  end
+end

data/lib/gemini_api/endpoint.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'partner_api/endpoints/base'
+require 'gemini_api/failure_response'
+
+module GeminiApi
+  class Endpoint < PartnerApi::Endpoints::Base
+    HMAC_ALGORITHM = 'SHA384'
+
+    private
+
+    def request_options
+      { headers: combined_headers }
+    end
+
+    def connection_options
+      {}
+    end
+
+    def default_headers
+      {
+        'Content-Type' => 'text/plain',
+        'Content-Length' => '0',
+        'Cache-Control' => 'no-cache',
+        'X-GEMINI-APIKEY' => config.api_key,
+        'X-GEMINI-PAYLOAD' => base64_payload,
+        'X-GEMINI-SIGNATURE' => signature
+      }
+    end
+
+    def default_parameters
+      {
+        'request' => path,
+        'nonce' => Time.now.to_i
+      }
+    end
+
+    def base64_payload
+      Base64.urlsafe_encode64(combined_payload.to_json)
+    end
+
+    def signature
+      OpenSSL::HMAC.hexdigest(HMAC_ALGORITHM, config.api_secret, base64_payload)
+    end
+
+    def successful?(response)
+      response.status.success?
+    end
+
+    def decode(response)
+      response.parse
+    end
+
+    def decode_error(response)
+      FailureResponse.new(response)
+    end
+
+    def logging_params
+      {}
+    end
+  end
+end

data/lib/gemini_api/endpoints/create_address_request.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'gemini_api/endpoint'
+
+module GeminiApi
+  module Endpoints
+    class CreateAddressRequest < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      # See https://docs.gemini.com/rest-api/#create-an-address-request
+      def initialize(network:, address:, label:, account: nil)
+        @network = network
+        @address = address
+        @label = label
+        @account = account
+      end
+
+      private
+
+      attr_reader :network, :address, :label, :account
+
+      def method
+        'POST'
+      end
+
+      def path
+        "/v1/approvedAddresses/#{network}/request"
+      end
+
+      def parameters
+        {
+          address: address,
+          label: label,
+          account: account
+        }.compact
+      end
+    end
+  end
+end

data/lib/gemini_api/endpoints/get_available_balances.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'gemini_api/endpoint'
+require 'gemini_api/balance'
+
+module GeminiApi
+  module Endpoints
+    class GetAvailableBalances < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      # See https://docs.gemini.com/rest-api/#get-available-balances
+      def initialize(account: nil)
+        @account = account
+      end
+
+      private
+
+      attr_reader :account
+
+      def method
+        'POST'
+      end
+
+      def path
+        "/v1/balances"
+      end
+
+      def parameters
+        { account: account }.compact
+      end
+
+      def decode(response)
+        response.parse.map do |balance|
+          Balance.build(balance)
+        end
+      end
+    end
+  end
+end

data/lib/gemini_api/endpoints/view_approved_addresses.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'gemini_api/endpoint'
+require 'gemini_api/address'
+
+module GeminiApi
+  module Endpoints
+    class ViewApprovedAddresses < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      # See https://docs.gemini.com/rest-api/#view-approved-addresses
+      def initialize(network: :gusd, account: nil)
+        @network = network
+        @account = account
+      end
+
+      private
+
+      attr_reader :network, :account
+
+      def method
+        'POST'
+      end
+
+      def path
+        "/v1/approvedAddresses/account/#{network}"
+      end
+
+      def parameters
+        { account: account }.compact
+      end
+
+      def decode(response)
+        response.parse['approvedAddresses'].map do |address|
+          Address.build(address)
+        end
+      end
+    end
+  end
+end

data/lib/gemini_api/endpoints/view_transfers.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'gemini_api/endpoint'
+require 'gemini_api/transfer'
+
+module GeminiApi
+  module Endpoints
+    class ViewTransfers < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      # See: https://docs.gemini.com/rest-api/#transfers
+      def initialize(currency:, timestamp:, limit_transfers: 50, account: nil, show_completed_deposit_advances: false)
+        @currency = currency
+        @timestamp = timestamp
+        @limit_transfers = limit_transfers
+        @account = account
+        @show_completed_deposit_advances = show_completed_deposit_advances
+      end
+
+      private
+
+      attr_reader :currency, :timestamp, :limit_transfers, :account, :show_completed_deposit_advances
+
+      def method
+        'POST'
+      end
+
+      def path
+        '/v1/transfers'
+      end
+
+      def parameters
+        {
+          currency: currency,
+          timestamp: timestamp,
+          limit_transfers: limit_transfers,
+          account: account,
+          show_completed_deposit_advances: show_completed_deposit_advances
+        }.compact
+      end
+
+      def decode(response)
+        response.parse.map do |transfer|
+          Transfer.build(transfer)
+        end
+      end
+    end
+  end
+end

data/lib/gemini_api/endpoints/withdraw_crypto_fund.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'gemini_api/endpoint'
+require 'gemini_api/transaction'
+
+module GeminiApi
+  module Endpoints
+    class WithdrawCryptoFund < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      # By default, we allow withdrawing USD as GUSD
+      # See: https://docs.gemini.com/rest-api/#withdraw-usd-as-gusd
+      # For other currency, see
+      # https://docs.gemini.com/rest-api/#withdraw-crypto-funds
+      def initialize(address:, amount:, currency: :usd, account: nil, client_transfer_id: nil)
+        @currency = currency.to_sym
+        @address = address
+        @amount = amount
+        @account = account
+        @client_transfer_id = client_transfer_id
+      end
+
+      private
+
+      attr_reader :address, :amount, :account, :currency, :client_transfer_id
+
+      def method
+        'POST'
+      end
+
+      def path
+        "/v1/withdraw/#{currency}"
+      end
+
+      def parameters
+        {
+          address: address,
+          amount: amount,
+          account: account,
+          clientTransferId: client_transfer_id
+        }.compact
+      end
+
+      def decode(response)
+        Transaction.build(response.parse)
+      end
+    end
+  end
+end

data/lib/gemini_api/failure_response.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module GeminiApi
+  class FailureResponse
+    def initialize(response)
+      @response = response
+    end
+
+    def errors
+      if json?
+        parsed_response = response.parse
+        [
+          PartnerApi::Errors::RequestError.new(
+            code: parsed_response['reason'],
+            message: parsed_response['message']
+          )
+        ]
+      else
+        [PartnerApi::Errors::RequestError.new(message: "Invalid Response: #{body}")]
+      end
+    end
+
+    def error
+      errors.first
+    end
+
+    def status
+      response.status
+    end
+
+    def body
+      response.body
+    end
+
+    def headers
+      response.headers.to_h
+    end
+
+    private
+
+    attr_reader :response
+
+    def json?
+      response.content_type.mime_type == 'application/json'
+    end
+  end
+end

data/lib/gemini_api/transaction.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module GeminiApi
+  Transaction = Struct.new(:address, :amount, :withdrawal_id, :raw_data, keyword_init: true) do
+    def self.build(raw_data)
+      new(
+        address: raw_data['address'],
+        amount: raw_data['amount'].to_f,
+        withdrawal_id: raw_data['withdrawalId'],
+        raw_data: raw_data
+      )
+    end
+  end
+end