cryptopay-ruby 0.1.0

data/lib/cryptopay/api/channels.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class Channels
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # Create a channel
+    # @param channel_params [ChannelParams]
+    # @param [Hash] opts the optional parameters
+    # @return [ChannelResult]
+    def create(channel_params, _opts = {})
+      path = '/api/channels'
+
+      req = Request.new(
+        method: :post,
+        path: path,
+        body_params: channel_params
+      )
+
+      connection.call(req, return_type: ChannelResult)
+    end
+
+    # List channels
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :customer_id The internal ID of your customer that the transaction relates to
+    # @option opts [String] :starting_after Pagination parameter. ID to start after
+    # @return [ChannelListResult]
+    def list(opts = {})
+      path = '/api/channels'
+
+      query_params = {}
+      query_params[:customer_id] = opts[:customer_id] unless opts[:customer_id].nil?
+      query_params[:starting_after] = opts[:starting_after] unless opts[:starting_after].nil?
+
+      req = Request.new(
+        method: :get,
+        path: path,
+        query_params: query_params
+      )
+
+      connection.call(req, return_type: ChannelListResult)
+    end
+
+    # List channel payments
+    # @param channel_id [String] Channel ID
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :starting_after Pagination parameter. ID to start after
+    # @return [ChannelPaymentListResult]
+    def list_payments(channel_id, opts = {})
+      path = '/api/channels/{channel_id}/payments'
+      path = path.sub('{channel_id}', CGI.escape(channel_id.to_s))
+
+      query_params = {}
+      query_params[:starting_after] = opts[:starting_after] unless opts[:starting_after].nil?
+
+      req = Request.new(
+        method: :get,
+        path: path,
+        query_params: query_params
+      )
+
+      connection.call(req, return_type: ChannelPaymentListResult)
+    end
+
+    # Retrieve a channel
+    # @param channel_id [String] Channel ID
+    # @param [Hash] opts the optional parameters
+    # @return [ChannelResult]
+    def retrieve(channel_id, _opts = {})
+      path = '/api/channels/{channel_id}'
+      path = path.sub('{channel_id}', CGI.escape(channel_id.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: ChannelResult)
+    end
+
+    # Retrieve a channel by custom id
+    # @param custom_id [String]
+    # @param [Hash] opts the optional parameters
+    # @return [ChannelResult]
+    def retrieve_by_custom_id(custom_id, _opts = {})
+      path = '/api/channels/custom_id/{custom_id}'
+      path = path.sub('{custom_id}', CGI.escape(custom_id.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: ChannelResult)
+    end
+
+    # Retrieve a channel payment
+    # @param channel_id [String] Channel ID
+    # @param channel_payment_id [String] Channel payment ID
+    # @param [Hash] opts the optional parameters
+    # @return [ChannelPaymentResult]
+    def retrieve_payment(channel_id, channel_payment_id, _opts = {})
+      path = '/api/channels/{channel_id}/payments/{channel_payment_id}'
+      path = path.sub('{channel_id}', CGI.escape(channel_id.to_s))
+      path = path.sub('{channel_payment_id}', CGI.escape(channel_payment_id.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: ChannelPaymentResult)
+    end
+
+    # Update a channel
+    # @param channel_id [String] Channel ID
+    # @param channel_update_params [ChannelUpdateParams]
+    # @param [Hash] opts the optional parameters
+    # @return [ChannelResult]
+    def update(channel_id, channel_update_params, _opts = {})
+      path = '/api/channels/{channel_id}'
+      path = path.sub('{channel_id}', CGI.escape(channel_id.to_s))
+
+      req = Request.new(
+        method: :patch,
+        path: path,
+        body_params: channel_update_params
+      )
+
+      connection.call(req, return_type: ChannelResult)
+    end
+
+    private
+
+    attr_reader :connection
+  end
+end

data/lib/cryptopay/api/coin_withdrawals.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class CoinWithdrawals
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # Commit a withdrawal
+    # @param coin_withdrawal_id [String] Coin withdrawal ID
+    # @param [Hash] opts the optional parameters
+    # @return [CoinWithdrawalResult]
+    def commit(coin_withdrawal_id, _opts = {})
+      path = '/api/coin_withdrawals/{coin_withdrawal_id}/commit'
+      path = path.sub('{coin_withdrawal_id}', CGI.escape(coin_withdrawal_id.to_s))
+
+      req = Request.new(
+        method: :post,
+        path: path
+      )
+
+      connection.call(req, return_type: CoinWithdrawalResult)
+    end
+
+    # Create a withdrawal
+    # @param coin_withdrawal_params [CoinWithdrawalParams]
+    # @param [Hash] opts the optional parameters
+    # @return [CoinWithdrawalResult]
+    def create(coin_withdrawal_params, _opts = {})
+      path = '/api/coin_withdrawals'
+
+      req = Request.new(
+        method: :post,
+        path: path,
+        body_params: coin_withdrawal_params
+      )
+
+      connection.call(req, return_type: CoinWithdrawalResult)
+    end
+
+    # List withdrawals
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :customer_id The internal ID of your customer that the transaction relates to
+    # @option opts [String] :starting_after Pagination parameter. ID to start after
+    # @return [CoinWithdrawalListResult]
+    def list(opts = {})
+      path = '/api/coin_withdrawals'
+
+      query_params = {}
+      query_params[:customer_id] = opts[:customer_id] unless opts[:customer_id].nil?
+      query_params[:starting_after] = opts[:starting_after] unless opts[:starting_after].nil?
+
+      req = Request.new(
+        method: :get,
+        path: path,
+        query_params: query_params
+      )
+
+      connection.call(req, return_type: CoinWithdrawalListResult)
+    end
+
+    # List network fees
+    # @param [Hash] opts the optional parameters
+    # @return [NetworkFeeListResult]
+    def list_network_fees(_opts = {})
+      path = '/api/coin_withdrawals/network_fees'
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: NetworkFeeListResult)
+    end
+
+    # Retrieve a withdrawal
+    # @param coin_withdrawal_id [String] Coin withdrawal ID
+    # @param [Hash] opts the optional parameters
+    # @return [CoinWithdrawalResult]
+    def retrieve(coin_withdrawal_id, _opts = {})
+      path = '/api/coin_withdrawals/{coin_withdrawal_id}'
+      path = path.sub('{coin_withdrawal_id}', CGI.escape(coin_withdrawal_id.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: CoinWithdrawalResult)
+    end
+
+    # Retrieve a withdrawal by custom id
+    # @param custom_id [String]
+    # @param [Hash] opts the optional parameters
+    # @return [CoinWithdrawalResult]
+    def retrieve_by_custom_id(custom_id, _opts = {})
+      path = '/api/coin_withdrawals/custom_id/{custom_id}'
+      path = path.sub('{custom_id}', CGI.escape(custom_id.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: CoinWithdrawalResult)
+    end
+
+    private
+
+    attr_reader :connection
+  end
+end

data/lib/cryptopay/api/customers.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class Customers
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # Create a customer
+    # @param customer_params [CustomerParams]
+    # @param [Hash] opts the optional parameters
+    # @return [CustomerResult]
+    def create(customer_params, _opts = {})
+      path = '/api/customers'
+
+      req = Request.new(
+        method: :post,
+        path: path,
+        body_params: customer_params
+      )
+
+      connection.call(req, return_type: CustomerResult)
+    end
+
+    # List customers
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :starting_after Pagination parameter. ID to start after
+    # @return [CustomerListResult]
+    def list(opts = {})
+      path = '/api/customers'
+
+      query_params = {}
+      query_params[:starting_after] = opts[:starting_after] unless opts[:starting_after].nil?
+
+      req = Request.new(
+        method: :get,
+        path: path,
+        query_params: query_params
+      )
+
+      connection.call(req, return_type: CustomerListResult)
+    end
+
+    # Retrieve a customer
+    # @param customer_id [String] The customer's reference ID in your system
+    # @param [Hash] opts the optional parameters
+    # @return [CustomerResult]
+    def retrieve(customer_id, _opts = {})
+      path = '/api/customers/{customer_id}'
+      path = path.sub('{customer_id}', CGI.escape(customer_id.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: CustomerResult)
+    end
+
+    # Update a customer
+    # @param customer_id [String] The customer's reference ID in your system
+    # @param customer_update_params [CustomerUpdateParams]
+    # @param [Hash] opts the optional parameters
+    # @return [CustomerResult]
+    def update(customer_id, customer_update_params, _opts = {})
+      path = '/api/customers/{customer_id}'
+      path = path.sub('{customer_id}', CGI.escape(customer_id.to_s))
+
+      req = Request.new(
+        method: :patch,
+        path: path,
+        body_params: customer_update_params
+      )
+
+      connection.call(req, return_type: CustomerResult)
+    end
+
+    private
+
+    attr_reader :connection
+  end
+end

data/lib/cryptopay/api/exchange_transfers.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class ExchangeTransfers
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # Commit an exchange transfer
+    # @param exchange_transfer_id [String] Exchange transfer ID
+    # @param [Hash] opts the optional parameters
+    # @return [ExchangeTransferResult]
+    def commit(exchange_transfer_id, _opts = {})
+      path = '/api/exchange_transfers/{exchange_transfer_id}/commit'
+      path = path.sub('{exchange_transfer_id}', CGI.escape(exchange_transfer_id.to_s))
+
+      req = Request.new(
+        method: :post,
+        path: path
+      )
+
+      connection.call(req, return_type: ExchangeTransferResult)
+    end
+
+    # Create an exchange transfer
+    # @param exchange_transfer_params [ExchangeTransferParams]
+    # @param [Hash] opts the optional parameters
+    # @return [ExchangeTransferResult]
+    def create(exchange_transfer_params, _opts = {})
+      path = '/api/exchange_transfers'
+
+      req = Request.new(
+        method: :post,
+        path: path,
+        body_params: exchange_transfer_params
+      )
+
+      connection.call(req, return_type: ExchangeTransferResult)
+    end
+
+    # Retrieve an exchange transfer
+    # @param exchange_transfer_id [String] Exchange transfer ID
+    # @param [Hash] opts the optional parameters
+    # @return [ExchangeTransferResult]
+    def retrieve(exchange_transfer_id, _opts = {})
+      path = '/api/exchange_transfers/{exchange_transfer_id}'
+      path = path.sub('{exchange_transfer_id}', CGI.escape(exchange_transfer_id.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: ExchangeTransferResult)
+    end
+
+    private
+
+    attr_reader :connection
+  end
+end

data/lib/cryptopay/api/invoices.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class Invoices
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # Commit invoice recalculation
+    # This endpoint allows you to commit invoice recalculation.
+    # @param invoice_id [String] Invoice ID
+    # @param recalculation_id [String] Recalculation ID
+    # @param [Hash] opts the optional parameters
+    # @return [InvoiceRecalculationResult]
+    def commit_recalculation(invoice_id, recalculation_id, _opts = {})
+      path = '/api/invoices/{invoice_id}/recalculations/{recalculation_id}/commit'
+      path = path.sub('{invoice_id}', CGI.escape(invoice_id.to_s))
+      path = path.sub('{recalculation_id}', CGI.escape(recalculation_id.to_s))
+
+      req = Request.new(
+        method: :post,
+        path: path
+      )
+
+      connection.call(req, return_type: InvoiceRecalculationResult)
+    end
+
+    # Create an invoice
+    # This endpoint allows you to create invoices.
+    # @param invoice_params [InvoiceParams]
+    # @param [Hash] opts the optional parameters
+    # @return [InvoiceResult]
+    def create(invoice_params, _opts = {})
+      path = '/api/invoices'
+
+      req = Request.new(
+        method: :post,
+        path: path,
+        body_params: invoice_params
+      )
+
+      connection.call(req, return_type: InvoiceResult)
+    end
+
+    # Create invoice recalculation
+    # This endpoint allows you to recalculate invoices.
+    # @param invoice_id [String] Invoice ID
+    # @param invoice_recalculation_params [InvoiceRecalculationParams]
+    # @param [Hash] opts the optional parameters
+    # @return [InvoiceRecalculationResult]
+    def create_recalculation(invoice_id, invoice_recalculation_params, _opts = {})
+      path = '/api/invoices/{invoice_id}/recalculations'
+      path = path.sub('{invoice_id}', CGI.escape(invoice_id.to_s))
+
+      req = Request.new(
+        method: :post,
+        path: path,
+        body_params: invoice_recalculation_params
+      )
+
+      connection.call(req, return_type: InvoiceRecalculationResult)
+    end
+
+    # Create invoice refund
+    # This endpoint allows you to create invoice refunds.
+    # @param invoice_id [String] Invoice ID
+    # @param invoice_refund_params [InvoiceRefundParams]
+    # @param [Hash] opts the optional parameters
+    # @return [InvoiceRefundResult]
+    def create_refund(invoice_id, invoice_refund_params, _opts = {})
+      path = '/api/invoices/{invoice_id}/refunds'
+      path = path.sub('{invoice_id}', CGI.escape(invoice_id.to_s))
+
+      req = Request.new(
+        method: :post,
+        path: path,
+        body_params: invoice_refund_params
+      )
+
+      connection.call(req, return_type: InvoiceRefundResult)
+    end
+
+    # List invoices
+    # This endpoint allows you to retrieve a list of all invoices.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :customer_id The internal ID of your customer that the transaction relates to
+    # @option opts [String] :starting_after Pagination parameter. ID to start after
+    # @return [InvoiceListResult]
+    def list(opts = {})
+      path = '/api/invoices'
+
+      query_params = {}
+      query_params[:customer_id] = opts[:customer_id] unless opts[:customer_id].nil?
+      query_params[:starting_after] = opts[:starting_after] unless opts[:starting_after].nil?
+
+      req = Request.new(
+        method: :get,
+        path: path,
+        query_params: query_params
+      )
+
+      connection.call(req, return_type: InvoiceListResult)
+    end
+
+    # List invoice refunds
+    # This endpoint allows you to retrieve a list of a particular invoice refunds.
+    # @param invoice_id [String] Invoice ID
+    # @param [Hash] opts the optional parameters
+    # @return [InvoiceRefundListResult]
+    def list_refunds(invoice_id, _opts = {})
+      path = '/api/invoices/{invoice_id}/refunds'
+      path = path.sub('{invoice_id}', CGI.escape(invoice_id.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: InvoiceRefundListResult)
+    end
+
+    # Retrieve an invoice
+    # This endpoint allows you to retrieve the invoice details.
+    # @param invoice_id [String] Invoice ID
+    # @param [Hash] opts the optional parameters
+    # @return [InvoiceResult]
+    def retrieve(invoice_id, _opts = {})
+      path = '/api/invoices/{invoice_id}'
+      path = path.sub('{invoice_id}', CGI.escape(invoice_id.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: InvoiceResult)
+    end
+
+    # Retrieve an invoice by custom_id
+    # This endpoint allows you to retrieve invoice details by its custom_id.
+    # @param custom_id [String]
+    # @param [Hash] opts the optional parameters
+    # @return [InvoiceResult]
+    def retrieve_by_custom_id(custom_id, _opts = {})
+      path = '/api/invoices/custom_id/{custom_id}'
+      path = path.sub('{custom_id}', CGI.escape(custom_id.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: InvoiceResult)
+    end
+
+    private
+
+    attr_reader :connection
+  end
+end

data/lib/cryptopay/api/rates.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class Rates
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # Retrieve all rates
+    # This endpoint allows you to retrieve all public rates.
+    # @param [Hash] opts the optional parameters
+    # @return [RatesResult]
+    def all(_opts = {})
+      path = '/api/rates'
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: RatesResult)
+    end
+
+    # Retrieve a pair rate
+    # This endpoint allows you to retrieve a public rate by currency pair.
+    # @param base_currency [String] Base currency of pair
+    # @param quote_currency [String] Quote currency of pair
+    # @param [Hash] opts the optional parameters
+    # @return [RateResult]
+    def retrieve(base_currency, quote_currency, _opts = {})
+      path = '/api/rates/{base_currency}/{quote_currency}'
+      path = path.sub('{base_currency}', CGI.escape(base_currency.to_s))
+      path = path.sub('{quote_currency}', CGI.escape(quote_currency.to_s))
+
+      req = Request.new(
+        method: :get,
+        path: path
+      )
+
+      connection.call(req, return_type: RateResult)
+    end
+
+    private
+
+    attr_reader :connection
+  end
+end

data/lib/cryptopay/api/risks.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class Risks
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # Score a coin address
+    # @param risk_params [RiskParams]
+    # @param [Hash] opts the optional parameters
+    # @return [RiskResult]
+    def score(risk_params, _opts = {})
+      path = '/api/risks/score'
+
+      req = Request.new(
+        method: :post,
+        path: path,
+        body_params: risk_params
+      )
+
+      connection.call(req, return_type: RiskResult)
+    end
+
+    private
+
+    attr_reader :connection
+  end
+end

data/lib/cryptopay/api/transactions.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class Transactions
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # List transactions
+    # @param [Hash] opts the optional parameters
+    # @option opts [Time] :created_at_from Date and time in iso8601 format
+    # @option opts [Time] :created_at_to Date and time in iso8601 format
+    # @option opts [TransactionReferenceType] :reference_type Transaction reference type
+    # @option opts [String] :currency Transaction currency
+    # @option opts [String] :status Transaction status
+    # @option opts [RiskLevel] :risk_level Transaction risk level
+    # @option opts [String] :starting_after Pagination parameter. ID to start after
+    # @return [TransactionListResult]
+    def list(opts = {})
+      path = '/api/transactions'
+
+      query_params = {}
+      query_params[:created_at_from] = opts[:created_at_from] unless opts[:created_at_from].nil?
+      query_params[:created_at_to] = opts[:created_at_to] unless opts[:created_at_to].nil?
+      query_params[:reference_type] = opts[:reference_type] unless opts[:reference_type].nil?
+      query_params[:currency] = opts[:currency] unless opts[:currency].nil?
+      query_params[:status] = opts[:status] unless opts[:status].nil?
+      query_params[:risk_level] = opts[:risk_level] unless opts[:risk_level].nil?
+      query_params[:starting_after] = opts[:starting_after] unless opts[:starting_after].nil?
+
+      req = Request.new(
+        method: :get,
+        path: path,
+        query_params: query_params
+      )
+
+      connection.call(req, return_type: TransactionListResult)
+    end
+
+    private
+
+    attr_reader :connection
+  end
+end