circle.rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a6e1e4f41b558e12b4015b4c7b83a4672933c31d12ef2a1ad87e3ddbb416e2f4
+  data.tar.gz: b347435f333a4f4b6717d6a09bc3243224fe42ea3b281a20f06b040218007297
+SHA512:
+  metadata.gz: 14063ad72ee93bc1ed8cf8fe6f900811d6f6b5fce19d2203b32cf0a2fb5006a1be6aa3f566890b50f52662824a4493a1857d8f1652df3401fc6a9ad0a82d331b
+  data.tar.gz: 751ea1419846e1093c54188f6b08c23827622dbd1b72e08ccf4bdb7d0a1b48a71c1ac521fc2e3ae2d061fd3fd588f9cd9bb91dba1c9441f2d59e2e585d6fdb67

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Filippo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/circle/client.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Circle
+  class Client
+    attr_reader :connection, :api_key, :entity_secret
+
+    def initialize(api_key: nil, entity_secret: nil, base_url: nil, **options)
+      config = Circle.configuration || Configuration.new
+      @api_key = api_key || config.api_key
+      @entity_secret = entity_secret || config.entity_secret
+
+      raise ArgumentError, "api_key is required" unless @api_key
+
+      @connection = Connection.new(
+        api_key: @api_key,
+        base_url: base_url || config.base_url,
+        open_timeout: options[:open_timeout] || config.open_timeout,
+        read_timeout: options[:read_timeout] || config.read_timeout,
+        user_agent: options[:user_agent] || config.user_agent
+      )
+
+      @public_key_cache = nil
+    end
+
+    def generate_entity_secret_ciphertext
+      raise ArgumentError, "entity_secret is required" unless entity_secret
+
+      @public_key_cache ||= developer_account.get_public_key.data["publicKey"]
+      EntitySecret.encrypt(entity_secret_hex: entity_secret, public_key_pem: @public_key_cache)
+    end
+
+    # Developer-controlled wallet resources
+    def developer_account
+      @developer_account ||= Resources::DeveloperAccount.new(self)
+    end
+
+    def wallet_sets
+      @wallet_sets ||= Resources::WalletSets.new(self)
+    end
+
+    def wallets
+      @wallets ||= Resources::Wallets.new(self)
+    end
+
+    def transactions
+      @transactions ||= Resources::Transactions.new(self)
+    end
+
+    def signing
+      @signing ||= Resources::Signing.new(self)
+    end
+
+    def tokens
+      @tokens ||= Resources::Tokens.new(self)
+    end
+
+    def monitored_tokens
+      @monitored_tokens ||= Resources::MonitoredTokens.new(self)
+    end
+
+    def subscriptions
+      @subscriptions ||= Resources::Subscriptions.new(self)
+    end
+
+    def faucet
+      @faucet ||= Resources::Faucet.new(self)
+    end
+
+    def address_validation
+      @address_validation ||= Resources::AddressValidation.new(self)
+    end
+
+    # User-controlled wallet resources
+    def users
+      @users ||= Resources::Users.new(self)
+    end
+
+    def user_pin
+      @user_pin ||= Resources::UserPin.new(self)
+    end
+
+    def user_wallets
+      @user_wallets ||= Resources::UserWallets.new(self)
+    end
+
+    def user_transactions
+      @user_transactions ||= Resources::UserTransactions.new(self)
+    end
+
+    def user_signing
+      @user_signing ||= Resources::UserSigning.new(self)
+    end
+
+    # Smart Contract Platform resources
+    def contracts
+      @contracts ||= Resources::Contracts.new(self)
+    end
+
+    def contract_templates
+      @contract_templates ||= Resources::ContractTemplates.new(self)
+    end
+
+    def event_monitors
+      @event_monitors ||= Resources::EventMonitors.new(self)
+    end
+
+    def event_logs
+      @event_logs ||= Resources::EventLogs.new(self)
+    end
+  end
+end

data/lib/circle/configuration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Circle
+  class Configuration
+    attr_accessor :api_key, :entity_secret, :base_url, :open_timeout, :read_timeout, :user_agent
+
+    def initialize
+      @base_url = "https://api.circle.com"
+      @open_timeout = 30
+      @read_timeout = 60
+      @user_agent = "circle.rb/#{Circle::VERSION}"
+    end
+  end
+end

data/lib/circle/connection.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+module Circle
+  class Connection
+    def initialize(api_key:, base_url:, open_timeout:, read_timeout:, user_agent:)
+      @conn = Faraday.new(url: base_url) do |f|
+        f.request :json
+        f.response :json, content_type: /\bjson$/
+        f.request :authorization, "Bearer", api_key
+        f.headers["User-Agent"] = user_agent
+        f.options.open_timeout = open_timeout
+        f.options.timeout = read_timeout
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def get(path, params = {})
+      handle_response { @conn.get(path, params) }
+    end
+
+    def post(path, body = {})
+      handle_response { @conn.post(path, body) }
+    end
+
+    def put(path, body = {})
+      handle_response { @conn.put(path, body) }
+    end
+
+    def delete(path, params = {})
+      handle_response { @conn.delete(path) { |req| req.params = params } }
+    end
+
+    private
+
+    def handle_response
+      response = yield
+      return Response.new(response) if response.success?
+
+      raise Error.from_response(response)
+    rescue Faraday::Error => e
+      raise ConnectionError.new(e.message)
+    end
+  end
+end

data/lib/circle/entity_secret.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+
+module Circle
+  class EntitySecret
+    def self.encrypt(entity_secret_hex:, public_key_pem:)
+      entity_secret_bytes = [entity_secret_hex].pack("H*")
+      rsa_key = OpenSSL::PKey::RSA.new(public_key_pem)
+      encrypted = rsa_key.encrypt(
+        entity_secret_bytes,
+        {
+          "rsa_padding_mode" => "oaep",
+          "rsa_oaep_md" => "sha256",
+          "rsa_mgf1_md" => "sha256"
+        }
+      )
+      Base64.strict_encode64(encrypted)
+    end
+
+    def self.generate
+      SecureRandom.hex(32)
+    end
+  end
+end

data/lib/circle/errors.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Circle
+  class Error < StandardError
+    attr_reader :http_status, :error_code, :raw_response
+
+    def initialize(message = nil, http_status: nil, error_code: nil, raw_response: nil)
+      @http_status = http_status
+      @error_code = error_code
+      @raw_response = raw_response
+      super(message)
+    end
+
+    def self.from_response(response)
+      body = response.body
+      message = body.is_a?(Hash) ? body["message"] : body.to_s
+      error_code = body.is_a?(Hash) ? body["code"] : nil
+
+      klass = case response.status
+              when 400 then ValidationError
+              when 401 then AuthenticationError
+              when 403 then ForbiddenError
+              when 404 then NotFoundError
+              when 409 then ConflictError
+              when 429 then RateLimitError
+              when 500..599 then ServerError
+              else Error
+              end
+
+      klass.new(message, http_status: response.status, error_code: error_code, raw_response: body)
+    end
+  end
+
+  class AuthenticationError < Error; end
+  class ForbiddenError < Error; end
+  class NotFoundError < Error; end
+  class ValidationError < Error; end
+  class ConflictError < Error; end
+  class RateLimitError < Error; end
+  class ServerError < Error; end
+  class ConnectionError < Error; end
+  class WebhookSignatureError < Error; end
+end

data/lib/circle/pagination.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Circle
+  class Pagination
+    include Enumerable
+
+    DEFAULT_PAGE_SIZE = 10
+
+    def initialize(resource:, path:, params: {}, key: nil)
+      @resource = resource
+      @path = path
+      @params = params
+      @key = key
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      params = @params.dup
+      loop do
+        response = @resource.send(:get_request, @path, params)
+        items = @key ? response.data[@key] : response.data
+        break if items.nil? || !items.is_a?(Array) || items.empty?
+
+        items.each(&block)
+
+        page_size = params[:page_size] || params[:pageSize] || DEFAULT_PAGE_SIZE
+        break if items.size < page_size
+
+        params = params.merge(page_after: items.last["id"])
+      end
+    end
+  end
+end

data/lib/circle/resource.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Circle
+  class Resource
+    API_PATH = "/v1/w3s"
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    private
+
+    def get_request(path, params = {})
+      client.connection.get("#{API_PATH}#{path}", Util.deep_snake_to_camel(params))
+    end
+
+    def post_request(path, body = {}, inject_entity_secret: false)
+      body = Util.deep_snake_to_camel(body)
+      body["idempotencyKey"] ||= SecureRandom.uuid
+      if inject_entity_secret && client.entity_secret
+        body["entitySecretCiphertext"] = client.generate_entity_secret_ciphertext
+      end
+      client.connection.post("#{API_PATH}#{path}", body)
+    end
+
+    def put_request(path, body = {})
+      client.connection.put("#{API_PATH}#{path}", Util.deep_snake_to_camel(body))
+    end
+
+    def delete_request(path, body = {})
+      client.connection.delete("#{API_PATH}#{path}", Util.deep_snake_to_camel(body))
+    end
+  end
+end

data/lib/circle/resources/address_validation.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class AddressValidation < Resource
+      def validate(**params)
+        post_request("/transactions/validateAddress", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/contract_templates.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class ContractTemplates < Resource
+      def deploy(template_id, **params)
+        post_request("/contracts/templates/#{template_id}/deploy", params, inject_entity_secret: true)
+      end
+
+      def estimate_deployment_fee(template_id, **params)
+        post_request("/contracts/templates/#{template_id}/deploy/estimateFee", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/contracts.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class Contracts < Resource
+      def deploy(**params)
+        post_request("/contracts/deploy", params, inject_entity_secret: true)
+      end
+
+      def estimate_deployment_fee(**params)
+        post_request("/contracts/deploy/estimateFee", params)
+      end
+
+      def import(**params)
+        post_request("/contracts/import", params)
+      end
+
+      def list(**params)
+        get_request("/contracts", params)
+      end
+
+      def get(id)
+        get_request("/contracts/#{id}")
+      end
+
+      def update(id, **params)
+        put_request("/contracts/#{id}", params)
+      end
+
+      def query(**params)
+        post_request("/contracts/query", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/developer_account.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class DeveloperAccount < Resource
+      def get_public_key
+        get_request("/config/entity/publicKey")
+      end
+
+      def register_entity_secret(**params)
+        post_request("/config/entity/entitySecret", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/event_logs.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class EventLogs < Resource
+      def list(**params)
+        get_request("/contracts/events", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/event_monitors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class EventMonitors < Resource
+      def create(**params)
+        post_request("/contracts/monitors", params)
+      end
+
+      def list(**params)
+        get_request("/contracts/monitors", params)
+      end
+
+      def get(id)
+        get_request("/contracts/monitors/#{id}")
+      end
+
+      def update(id, **params)
+        put_request("/contracts/monitors/#{id}", params)
+      end
+
+      def delete(id)
+        delete_request("/contracts/monitors/#{id}")
+      end
+    end
+  end
+end

data/lib/circle/resources/faucet.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class Faucet < Resource
+      FAUCET_PATH = "/v1/faucet"
+
+      def request_tokens(**params)
+        body = Util.deep_snake_to_camel(params)
+        body["idempotencyKey"] ||= SecureRandom.uuid
+        client.connection.post("#{FAUCET_PATH}/drips", body)
+      end
+    end
+  end
+end

data/lib/circle/resources/monitored_tokens.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class MonitoredTokens < Resource
+      def create(**params)
+        post_request("/config/entity/monitoredTokens", params)
+      end
+
+      def list(**params)
+        get_request("/config/entity/monitoredTokens", params)
+      end
+
+      def update(**params)
+        put_request("/config/entity/monitoredTokens", params)
+      end
+
+      def delete(**params)
+        delete_request("/config/entity/monitoredTokens", params)
+      end
+
+      def update_scope(**params)
+        put_request("/config/entity/monitoredTokens/scope", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/signing.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class Signing < Resource
+      def sign_message(**params)
+        post_request("/developer/sign/message", params, inject_entity_secret: true)
+      end
+
+      def sign_typed_data(**params)
+        post_request("/developer/sign/typedData", params, inject_entity_secret: true)
+      end
+
+      def sign_transaction(**params)
+        post_request("/developer/sign/transaction", params, inject_entity_secret: true)
+      end
+
+      def sign_delegate_action(**params)
+        post_request("/developer/sign/delegateAction", params, inject_entity_secret: true)
+      end
+    end
+  end
+end

data/lib/circle/resources/subscriptions.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class Subscriptions < Resource
+      NOTIFICATIONS_PATH = "/v2/notifications"
+
+      def create(**params)
+        body = Util.deep_snake_to_camel(params)
+        body["idempotencyKey"] ||= SecureRandom.uuid
+        client.connection.post("#{NOTIFICATIONS_PATH}/subscriptions", body)
+      end
+
+      def list
+        client.connection.get("#{NOTIFICATIONS_PATH}/subscriptions")
+      end
+
+      def get(id)
+        client.connection.get("#{NOTIFICATIONS_PATH}/subscriptions/#{id}")
+      end
+
+      def update(id, **params)
+        client.connection.put("#{NOTIFICATIONS_PATH}/subscriptions/#{id}", Util.deep_snake_to_camel(params))
+      end
+
+      def delete(id)
+        client.connection.delete("#{NOTIFICATIONS_PATH}/subscriptions/#{id}")
+      end
+
+      def get_notification_signature(id)
+        client.connection.get("#{NOTIFICATIONS_PATH}/subscriptions/#{id}/notificationSignature")
+      end
+    end
+  end
+end

data/lib/circle/resources/tokens.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class Tokens < Resource
+      def get(id)
+        get_request("/tokens/#{id}")
+      end
+    end
+  end
+end

data/lib/circle/resources/transactions.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class Transactions < Resource
+      def create_transfer(**params)
+        post_request("/developer/transactions/transfer", params, inject_entity_secret: true)
+      end
+
+      def create_contract_execution(**params)
+        post_request("/developer/transactions/contractExecution", params, inject_entity_secret: true)
+      end
+
+      def list(**params)
+        get_request("/transactions", params)
+      end
+
+      def get(id, **params)
+        get_request("/transactions/#{id}", params)
+      end
+
+      def accelerate(id, **params)
+        post_request("/developer/transactions/#{id}/accelerate", params, inject_entity_secret: true)
+      end
+
+      def cancel(id, **params)
+        post_request("/developer/transactions/#{id}/cancel", params, inject_entity_secret: true)
+      end
+
+      def estimate_transfer_fee(**params)
+        post_request("/transactions/transfer/estimateFee", params)
+      end
+
+      def estimate_contract_execution_fee(**params)
+        post_request("/transactions/contractExecution/estimateFee", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/user_pin.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class UserPin < Resource
+      def create(**params)
+        post_request("/user/pin", params)
+      end
+
+      def create_with_wallets(**params)
+        post_request("/user/pin/wallets", params)
+      end
+
+      def update(**params)
+        put_request("/user/pin", params)
+      end
+
+      def restore(**params)
+        post_request("/user/pin/restore", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/user_signing.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class UserSigning < Resource
+      def sign_message(**params)
+        post_request("/user/sign/message", params)
+      end
+
+      def sign_typed_data(**params)
+        post_request("/user/sign/typedData", params)
+      end
+
+      def sign_transaction(**params)
+        post_request("/user/sign/transaction", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/user_transactions.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class UserTransactions < Resource
+      def create_transfer(**params)
+        post_request("/user/transactions/transfer", params)
+      end
+
+      def create_contract_execution(**params)
+        post_request("/user/transactions/contractExecution", params)
+      end
+
+      def list(**params)
+        get_request("/transactions", params)
+      end
+
+      def get(id, **params)
+        get_request("/transactions/#{id}", params)
+      end
+
+      def accelerate(id, **params)
+        post_request("/user/transactions/#{id}/accelerate", params)
+      end
+
+      def cancel(id, **params)
+        post_request("/user/transactions/#{id}/cancel", params)
+      end
+
+      def estimate_transfer_fee(**params)
+        post_request("/transactions/transfer/estimateFee", params)
+      end
+
+      def estimate_contract_execution_fee(**params)
+        post_request("/transactions/contractExecution/estimateFee", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/user_wallets.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class UserWallets < Resource
+      def create(**params)
+        post_request("/user/wallets", params)
+      end
+
+      def list(**params)
+        get_request("/wallets", params)
+      end
+
+      def get(id, **params)
+        get_request("/wallets/#{id}", params)
+      end
+
+      def update(id, **params)
+        put_request("/wallets/#{id}", params)
+      end
+
+      def get_token_balance(id, **params)
+        get_request("/wallets/#{id}/balances", params)
+      end
+
+      def get_nft_balance(id, **params)
+        get_request("/wallets/#{id}/nfts", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/users.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class Users < Resource
+      def create(**params)
+        post_request("/users", params)
+      end
+
+      def list(**params)
+        get_request("/users", params)
+      end
+
+      def get(id)
+        get_request("/users/#{id}")
+      end
+
+      def get_status(user_token:)
+        get_request("/user", { user_token: user_token })
+      end
+
+      def create_token(**params)
+        post_request("/users/token", params)
+      end
+
+      def refresh_token(**params)
+        post_request("/user/token/refresh", params)
+      end
+
+      def create_device_token_social(**params)
+        post_request("/users/social/token", params)
+      end
+
+      def create_device_token_email(**params)
+        post_request("/users/email/token", params)
+      end
+
+      def resend_otp(**params)
+        post_request("/users/resendOTP", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/wallet_sets.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class WalletSets < Resource
+      def create(**params)
+        post_request("/developer/walletSets", params, inject_entity_secret: true)
+      end
+
+      def list(**params)
+        get_request("/walletSets", params)
+      end
+
+      def get(id)
+        get_request("/walletSets/#{id}")
+      end
+
+      def update(id, **params)
+        put_request("/walletSets/#{id}", params)
+      end
+    end
+  end
+end

data/lib/circle/resources/wallets.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Circle
+  module Resources
+    class Wallets < Resource
+      def create(**params)
+        post_request("/developer/wallets", params, inject_entity_secret: true)
+      end
+
+      def list(**params)
+        get_request("/wallets", params)
+      end
+
+      def get(id)
+        get_request("/wallets/#{id}")
+      end
+
+      def update(id, **params)
+        put_request("/wallets/#{id}", params)
+      end
+
+      def derive(id, **params)
+        post_request("/developer/wallets/#{id}/derive", params, inject_entity_secret: true)
+      end
+
+      def get_token_balance(id, **params)
+        get_request("/wallets/#{id}/balances", params)
+      end
+
+      def get_nft_balance(id, **params)
+        get_request("/wallets/#{id}/nfts", params)
+      end
+
+      def list_with_balances(**params)
+        get_request("/wallets/balances", params)
+      end
+    end
+  end
+end

data/lib/circle/response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Circle
+  class Response
+    attr_reader :data, :status, :raw_body
+
+    def initialize(faraday_response)
+      @status = faraday_response.status
+      @raw_body = faraday_response.body
+      @data = extract_data(@raw_body)
+    end
+
+    private
+
+    def extract_data(body)
+      return body unless body.is_a?(Hash)
+
+      body.key?("data") ? body["data"] : body
+    end
+  end
+end

data/lib/circle/util.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Circle
+  module Util
+    module_function
+
+    def deep_snake_to_camel(params)
+      case params
+      when Hash
+        params.each_with_object({}) do |(key, value), result|
+          camel_key = snake_to_camel(key.to_s)
+          result[camel_key] = deep_snake_to_camel(value)
+        end
+      when Array
+        params.map { |item| deep_snake_to_camel(item) }
+      else
+        params
+      end
+    end
+
+    def snake_to_camel(str)
+      return str unless str.include?("_")
+
+      parts = str.split("_")
+      parts[0] + parts[1..].map(&:capitalize).join
+    end
+  end
+end

data/lib/circle/version.rb

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

data/lib/circle/webhook.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+require "json"
+
+module Circle
+  class Webhook
+    def self.verify!(payload:, signature_b64:, public_key_b64:)
+      public_key_der = Base64.decode64(public_key_b64)
+      key = OpenSSL::PKey.read(public_key_der)
+      signature_bytes = Base64.decode64(signature_b64)
+      key.verify("SHA256", signature_bytes, payload)
+    rescue OpenSSL::PKey::PKeyError
+      false
+    end
+
+    def self.construct_event(payload:, signature:, public_key:)
+      verified = verify!(payload: payload, signature_b64: signature, public_key_b64: public_key)
+      raise WebhookSignatureError, "Invalid webhook signature" unless verified
+
+      JSON.parse(payload)
+    end
+  end
+end

data/lib/circle.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "circle/version"
+require_relative "circle/configuration"
+require_relative "circle/errors"
+require_relative "circle/util"
+require_relative "circle/response"
+require_relative "circle/connection"
+require_relative "circle/resource"
+require_relative "circle/entity_secret"
+require_relative "circle/webhook"
+require_relative "circle/pagination"
+require_relative "circle/client"
+
+# Resources
+require_relative "circle/resources/developer_account"
+require_relative "circle/resources/wallet_sets"
+require_relative "circle/resources/wallets"
+require_relative "circle/resources/transactions"
+require_relative "circle/resources/signing"
+require_relative "circle/resources/tokens"
+require_relative "circle/resources/monitored_tokens"
+require_relative "circle/resources/subscriptions"
+require_relative "circle/resources/faucet"
+require_relative "circle/resources/address_validation"
+require_relative "circle/resources/users"
+require_relative "circle/resources/user_pin"
+require_relative "circle/resources/user_wallets"
+require_relative "circle/resources/user_transactions"
+require_relative "circle/resources/user_signing"
+require_relative "circle/resources/contracts"
+require_relative "circle/resources/contract_templates"
+require_relative "circle/resources/event_monitors"
+require_relative "circle/resources/event_logs"
+
+module Circle
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      self.configuration = Configuration.new
+    end
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: circle.rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Filippo
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  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'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A Ruby SDK for Circle's Web3 Services platform, providing access to developer-controlled
+  wallets, user-controlled wallets, smart contract platform, and more.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- lib/circle.rb
+- lib/circle/client.rb
+- lib/circle/configuration.rb
+- lib/circle/connection.rb
+- lib/circle/entity_secret.rb
+- lib/circle/errors.rb
+- lib/circle/pagination.rb
+- lib/circle/resource.rb
+- lib/circle/resources/address_validation.rb
+- lib/circle/resources/contract_templates.rb
+- lib/circle/resources/contracts.rb
+- lib/circle/resources/developer_account.rb
+- lib/circle/resources/event_logs.rb
+- lib/circle/resources/event_monitors.rb
+- lib/circle/resources/faucet.rb
+- lib/circle/resources/monitored_tokens.rb
+- lib/circle/resources/signing.rb
+- lib/circle/resources/subscriptions.rb
+- lib/circle/resources/tokens.rb
+- lib/circle/resources/transactions.rb
+- lib/circle/resources/user_pin.rb
+- lib/circle/resources/user_signing.rb
+- lib/circle/resources/user_transactions.rb
+- lib/circle/resources/user_wallets.rb
+- lib/circle/resources/users.rb
+- lib/circle/resources/wallet_sets.rb
+- lib/circle/resources/wallets.rb
+- lib/circle/response.rb
+- lib/circle/util.rb
+- lib/circle/version.rb
+- lib/circle/webhook.rb
+homepage: https://github.com/fconforti/circle.rb
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: Ruby client for Circle Web3 Services API
+test_files: []