gasfree_sdk 0.1.0 → 1.0.0

data/lib/gasfree_sdk/client.rb

@@ -3,6 +3,7 @@
 require "base64"
 require "openssl"
 require "time"
+require "uri"
 
 module GasfreeSdk
   # Client for interacting with the GasFree API
@@ -17,45 +18,50 @@ module GasfreeSdk
         f.request :retry, GasfreeSdk.config.retry_options
         f.response :json
         f.adapter Faraday.default_adapter
+        f.response :logger, ::Logger.new($stdout), bodies: true if ENV["DEBUG_GASFREE_SDK"]
       end
     end
 
     # Get all supported tokens
     # @return [Array<Token>] List of supported tokens
     def tokens
-      response = get("/api/v1/config/token/all")
-      response.dig("data", "tokens").map { |token| Models::Token.new(token) }
+      response = get("api/v1/config/token/all")
+      response.dig("data", "tokens").map do |token|
+        Models::Token.new(transform_token_data(token))
+      end
     end
 
     # Get all service providers
     # @return [Array<Provider>] List of service providers
     def providers
-      response = get("/api/v1/config/provider/all")
-      response.dig("data", "providers").map { |provider| Models::Provider.new(provider) }
+      response = get("api/v1/config/provider/all")
+      response.dig("data", "providers").map do |provider|
+        Models::Provider.new(transform_provider_data(provider))
+      end
     end
 
     # Get GasFree account info
     # @param account_address [String] The user's EOA address
     # @return [GasFreeAddress] The GasFree account info
     def address(account_address)
-      response = get("/api/v1/address/#{account_address}")
-      Models::GasFreeAddress.new(response["data"])
+      response = get("api/v1/address/#{account_address}")
+      Models::GasFreeAddress.new(transform_address_data(response["data"]))
     end
 
     # Submit a GasFree transfer
     # @param request [TransferRequest] The transfer request
     # @return [TransferResponse] The transfer response
     def submit_transfer(request)
-      response = post("/api/v1/gasfree/submit", request.to_h)
-      Models::TransferResponse.new(response["data"])
+      response = post("api/v1/gasfree/submit", transform_transfer_request_data(request.to_h))
+      Models::TransferResponse.new(transform_transfer_response_data(response["data"]))
     end
 
     # Get transfer status
     # @param trace_id [String] The transfer trace ID
     # @return [TransferResponse] The transfer status
     def transfer_status(trace_id)
-      response = get("/api/v1/gasfree/#{trace_id}")
-      Models::TransferResponse.new(response["data"])
+      response = get("api/v1/gasfree/#{trace_id}")
+      Models::TransferResponse.new(transform_transfer_response_data(response["data"]))
     end
 
     private
@@ -67,7 +73,7 @@ module GasfreeSdk
     def get(path, params = {})
       timestamp = Time.now.to_i
       response = connection.get(path, params) do |req|
-        sign_request(req, "GET", path, timestamp)
+        sign_request(req, "GET", normalize_path(path), timestamp)
       end
       handle_response(response)
     end
@@ -80,23 +86,40 @@ module GasfreeSdk
       timestamp = Time.now.to_i
       response = connection.post(path) do |req|
         req.body = body
-        sign_request(req, "POST", path, timestamp)
+        sign_request(req, "POST", normalize_path(path), timestamp)
       end
       handle_response(response)
     end
 
+    # Normalize path for signature calculation (needs leading slash)
+    # @param path [String] The API path
+    # @return [String] Normalized path
+    def normalize_path(path)
+      path.start_with?("/") ? path : "/#{path}"
+    end
+
     # Sign an API request
     # @param request [Faraday::Request] The request to sign
     # @param method [String] HTTP method
     # @param path [String] Request path
     # @param timestamp [Integer] Request timestamp
-    def sign_request(request, method, path, timestamp)
+    def sign_request(request, method, path, timestamp) # rubocop:disable Metrics/AbcSize
       api_key = GasfreeSdk.config.api_key
       api_secret = GasfreeSdk.config.api_secret
 
       raise AuthenticationError, "API key and secret are required" if api_key.nil? || api_secret.nil?
 
-      message = "#{method}#{path}#{timestamp}"
+      # Extract the base path from the endpoint URL
+      # For https://open-test.gasfree.io/nile/ the base path is /nile
+      endpoint_uri = URI(GasfreeSdk.config.api_endpoint)
+      base_path = endpoint_uri.path.chomp("/") # Remove trailing slash
+
+      # Combine base path with API path for signature
+      # e.g., /nile + /api/v1/config/token/all = /nile/api/v1/config/token/all
+      full_path = "#{base_path}#{path}"
+
+      # According to GasFree API documentation, the message format is: method + path + timestamp
+      message = "#{method}#{full_path}#{timestamp}"
       signature = Base64.strict_encode64(
         OpenSSL::HMAC.digest("SHA256", api_secret, message)
       )
@@ -120,5 +143,152 @@ module GasfreeSdk
         message: data["message"]
       )
     end
+
+    # Transform transfer request data from model format to API format
+    # @param request_data [Hash] Transfer request data from model
+    # @return [Hash] Transformed transfer request data for API
+    def transform_transfer_request_data(request_data)
+      {
+        "token" => request_data[:token],
+        "serviceProvider" => request_data[:service_provider], # snake_case to camelCase
+        "user" => request_data[:user],
+        "receiver" => request_data[:receiver],
+        "value" => request_data[:value],
+        "maxFee" => request_data[:max_fee], # snake_case to camelCase
+        "deadline" => request_data[:deadline],
+        "version" => request_data[:version],
+        "nonce" => request_data[:nonce],
+        "sig" => request_data[:sig]
+      }
+    end
+
+    # Transform token data from API format to model format
+    # @param token_data [Hash] Token data from API
+    # @return [Hash] Transformed token data
+    def transform_token_data(token_data)
+      {
+        token_address: token_data["tokenAddress"],
+        created_at: Types::JSON::Time.call(token_data["createdAt"]),
+        updated_at: Types::JSON::Time.call(token_data["updatedAt"]),
+        activate_fee: Types::JSON::Amount.call(token_data["activateFee"]),
+        transfer_fee: Types::JSON::Amount.call(token_data["transferFee"]),
+        supported: token_data["supported"],
+        symbol: token_data["symbol"],
+        decimal: token_data["decimal"]
+      }
+    end
+
+    # Transform provider data from API format to model format
+    # @param provider_data [Hash] Provider data from API
+    # @return [Hash] Transformed provider data
+    def transform_provider_data(provider_data)
+      {
+        address: provider_data["address"],
+        name: provider_data["name"],
+        icon: provider_data["icon"],
+        website: provider_data["website"],
+        config: transform_provider_config_data(provider_data["config"])
+      }
+    end
+
+    # Transform provider config data from API format to model format
+    # @param config_data [Hash] Provider config data from API
+    # @return [Hash] Transformed provider config data
+    def transform_provider_config_data(config_data)
+      {
+        max_pending_transfer: config_data["maxPendingTransfer"],
+        min_deadline_duration: config_data["minDeadlineDuration"],
+        max_deadline_duration: config_data["maxDeadlineDuration"],
+        default_deadline_duration: config_data["defaultDeadlineDuration"]
+      }
+    end
+
+    # Transform address data from API format to model format
+    # @param address_data [Hash] Address data from API
+    # @return [Hash] Transformed address data
+    def transform_address_data(address_data)
+      {
+        account_address: address_data["accountAddress"],
+        gas_free_address: address_data["gasFreeAddress"],
+        active: address_data["active"],
+        nonce: address_data["nonce"],
+        allow_submit: address_data["allowSubmit"],
+        assets: address_data["assets"]&.map { |asset| transform_asset_data(asset) } || []
+      }
+    end
+
+    # Transform asset data from API format to model format
+    # @param asset_data [Hash] Asset data from API
+    # @return [Hash] Transformed asset data
+    def transform_asset_data(asset_data)
+      {
+        token_address: asset_data["tokenAddress"],
+        token_symbol: asset_data["tokenSymbol"],
+        activate_fee: Types::JSON::Amount.call(asset_data["activateFee"]),
+        transfer_fee: Types::JSON::Amount.call(asset_data["transferFee"]),
+        decimal: asset_data["decimal"],
+        frozen: Types::JSON::Amount.call(asset_data["frozen"])
+      }
+    end
+
+    # Transform transfer response data from API format to model format
+    # @param response_data [Hash] Transfer response data from API
+    # @return [Hash] Transformed transfer response data
+    def transform_transfer_response_data(response_data)
+      basic_fields = extract_basic_transfer_fields(response_data)
+      transaction_fields = extract_transaction_fields(response_data)
+
+      basic_fields.merge(transaction_fields).compact
+    end
+
+    # Extract basic transfer fields from response data
+    # @param response_data [Hash] Transfer response data from API
+    # @return [Hash] Basic transfer fields
+    def extract_basic_transfer_fields(response_data)
+      {
+        id: response_data["id"],
+        created_at: get_field_value(response_data, "createdAt", "created_at"),
+        updated_at: get_field_value(response_data, "updatedAt", "updated_at"),
+        account_address: get_field_value(response_data, "accountAddress", "account_address"),
+        gas_free_address: get_field_value(response_data, "gasFreeAddress", "gas_free_address"),
+        provider_address: get_field_value(response_data, "providerAddress", "provider_address"),
+        target_address: get_field_value(response_data, "targetAddress", "target_address"),
+        token_address: get_field_value(response_data, "tokenAddress", "token_address"),
+        amount: response_data["amount"],
+        max_fee: get_field_value(response_data, "maxFee", "max_fee"),
+        signature: response_data["signature"],
+        nonce: response_data["nonce"],
+        expired_at: get_field_value(response_data, "expiredAt", "expired_at"),
+        state: response_data["state"]
+      }
+    end
+
+    # Extract transaction-related fields from response data
+    # @param response_data [Hash] Transfer response data from API
+    # @return [Hash] Transaction fields
+    def extract_transaction_fields(response_data)
+      {
+        estimated_activate_fee: get_field_value(response_data, "estimatedActivateFee", "estimated_activate_fee"),
+        estimated_transfer_fee: get_field_value(response_data, "estimatedTransferFee", "estimated_transfer_fee"),
+        txn_hash: get_field_value(response_data, "txnHash", "txn_hash"),
+        txn_block_num: get_field_value(response_data, "txnBlockNum", "txn_block_num"),
+        txn_block_timestamp: get_field_value(response_data, "txnBlockTimestamp", "txn_block_timestamp"),
+        txn_state: get_field_value(response_data, "txnState", "txn_state"),
+        txn_activate_fee: get_field_value(response_data, "txnActivateFee", "txn_activate_fee"),
+        txn_transfer_fee: get_field_value(response_data, "txnTransferFee", "txn_transfer_fee"),
+        txn_total_fee: get_field_value(response_data, "txnTotalFee", "txn_total_fee"),
+        txn_amount: get_field_value(response_data, "txnAmount", "txn_amount"),
+        txn_total_cost: get_field_value(response_data, "txnTotalCost", "txn_total_cost")
+      }
+    end
+
+    # Get field value with fallback to snake_case version
+    # @param data [Hash] The data hash
+    # @param camel_case_key [String] The camelCase key
+    # @param snake_case_key [String] The snake_case key
+    # @return [Object] The field value
+    def get_field_value(data, camel_case_key, snake_case_key)
+      data[camel_case_key] || data[snake_case_key]
+    end
   end
 end

data/lib/gasfree_sdk/crypto.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module GasfreeSdk
+  module Crypto
+    # Keccak256 implementation for TRON EIP-712 signatures
+    class Keccak256 < Digest::Class
+      PILN = [10, 7, 11, 17, 18, 3, 5, 16,
+              8, 21, 24,  4, 15, 23, 19, 13,
+              12, 2, 20, 14, 22, 9, 6, 1].freeze
+
+      ROTC = [1, 3,  6, 10, 15, 21, 28, 36,
+              45, 55,  2, 14, 27, 41, 56, 8,
+              25, 43, 62, 18, 39, 61, 20, 44].freeze
+
+      RNDC = [0x0000000000000001, 0x0000000000008082, 0x800000000000808a,
+              0x8000000080008000, 0x000000000000808b, 0x0000000080000001,
+              0x8000000080008081, 0x8000000000008009, 0x000000000000008a,
+              0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
+              0x000000008000808b, 0x800000000000008b, 0x8000000000008089,
+              0x8000000000008003, 0x8000000000008002, 0x8000000000000080,
+              0x000000000000800a, 0x800000008000000a, 0x8000000080008081,
+              0x8000000000008080, 0x0000000080000001, 0x8000000080008008].freeze
+
+      def initialize
+        @size = 256 / 8
+        @buffer = "".dup  # Use dup to ensure it's not frozen
+
+        super
+      end
+
+      def <<(string)
+        @buffer << string.to_s
+        self
+      end
+      alias update <<
+
+      def reset
+        @buffer = "".dup  # Create a new unfrozen string instead of clearing
+        self
+      end
+
+      def finish # rubocop:disable Metrics/AbcSize
+        string = Array.new 25, 0
+        width = 200 - (@size * 2)
+        padding = "\x01".dup
+
+        buffer = @buffer.dup # Create a copy to avoid modifying the original
+        buffer << padding << ("\0" * (width - (buffer.size % width)))
+        buffer[-1] = (buffer[-1].ord | 0x80).chr
+
+        0.step buffer.size - 1, width do |j|
+          quads = buffer[j, width].unpack "Q*"
+          (width / 8).times do |i|
+            string[i] ^= quads[i]
+          end
+
+          keccak string
+        end
+
+        string.pack("Q*")[0, @size]
+      end
+
+      private
+
+      def keccak(string) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        24.times.each_with_object [] do |round, a|
+          # Theta
+          5.times do |i|
+            a[i] = string[i] ^ string[i + 5] ^ string[i + 10] ^ string[i + 15] ^ string[i + 20]
+          end
+
+          5.times do |i|
+            t = a[(i + 4) % 5] ^ rotate(a[(i + 1) % 5], 1)
+            0.step 24, 5 do |j|
+              string[j + i] ^= t
+            end
+          end
+
+          # Rho Pi
+          t = string[1]
+          24.times do |i|
+            j = PILN[i]
+            a[0] = string[j]
+            string[j] = rotate t, ROTC[i]
+            t = a[0]
+          end
+
+          # Chi
+          0.step 24, 5 do |j|
+            5.times do |i|
+              a[i] = string[j + i]
+            end
+
+            5.times do |i|
+              string[j + i] ^= ~a[(i + 1) % 5] & a[(i + 2) % 5]
+            end
+          end
+
+          # Iota
+          string[0] ^= RNDC[round]
+        end
+      end
+
+      def rotate(x, y) # rubocop:disable Naming/MethodParameterName
+        ((x << y) | (x >> (64 - y))) & ((1 << 64) - 1)
+      end
+    end
+  end
+end

data/lib/gasfree_sdk/models/token.rb

@@ -12,19 +12,19 @@ module GasfreeSdk
 
       # @!attribute [r] created_at
       #   @return [Time] When the token was added to GasFree
-      attribute :created_at, Types::JSON::Time
+      attribute :created_at, Types::Time
 
       # @!attribute [r] updated_at
       #   @return [Time] When the token was last updated
-      attribute :updated_at, Types::JSON::Time
+      attribute :updated_at, Types::Time
 
       # @!attribute [r] activate_fee
       #   @return [String] The activation fee in the smallest unit of the token
-      attribute :activate_fee, Types::Amount
+      attribute :activate_fee, Types::String
 
       # @!attribute [r] transfer_fee
       #   @return [String] The transfer fee in the smallest unit of the token
-      attribute :transfer_fee, Types::Amount
+      attribute :transfer_fee, Types::String
 
       # @!attribute [r] supported
       #   @return [Boolean] Whether the token is currently supported

data/lib/gasfree_sdk/models/transfer_response.rb

@@ -12,51 +12,51 @@ module GasfreeSdk
 
       # @!attribute [r] created_at
       #   @return [Time] When the transfer was created
-      attribute :created_at, Types::JSON::Time
+      attribute? :created_at, Types::JSON::Time
 
       # @!attribute [r] updated_at
       #   @return [Time] When the transfer was last updated
-      attribute :updated_at, Types::JSON::Time
+      attribute? :updated_at, Types::JSON::Time
 
       # @!attribute [r] account_address
       #   @return [String] The user's EOA address
-      attribute :account_address, Types::Address
+      attribute? :account_address, Types::Address
 
       # @!attribute [r] gas_free_address
       #   @return [String] The GasFree account address
-      attribute :gas_free_address, Types::Address
+      attribute? :gas_free_address, Types::Address
 
       # @!attribute [r] provider_address
       #   @return [String] The service provider's address
-      attribute :provider_address, Types::Address
+      attribute? :provider_address, Types::Address
 
       # @!attribute [r] target_address
       #   @return [String] The recipient's address
-      attribute :target_address, Types::Address
+      attribute? :target_address, Types::Address
 
       # @!attribute [r] token_address
       #   @return [String] The token contract address
-      attribute :token_address, Types::Address
+      attribute? :token_address, Types::Address
 
       # @!attribute [r] amount
       #   @return [String] The transfer amount
-      attribute :amount, Types::Amount
+      attribute? :amount, Types::JSON::Amount
 
       # @!attribute [r] max_fee
       #   @return [String] Maximum fee limit
-      attribute :max_fee, Types::Amount
+      attribute? :max_fee, Types::JSON::Amount
 
       # @!attribute [r] signature
       #   @return [String] User's signature
-      attribute :signature, Types::String
+      attribute? :signature, Types::String
 
       # @!attribute [r] nonce
       #   @return [Integer] Transfer nonce
-      attribute :nonce, Types::Nonce
+      attribute? :nonce, Types::Nonce
 
       # @!attribute [r] expired_at
       #   @return [Time] When the transfer expires
-      attribute :expired_at, Types::JSON::Time
+      attribute? :expired_at, Types::JSON::Time
 
       # @!attribute [r] state
       #   @return [String] Current transfer state
@@ -64,11 +64,11 @@ module GasfreeSdk
 
       # @!attribute [r] estimated_activate_fee
       #   @return [String] Estimated activation fee
-      attribute? :estimated_activate_fee, Types::Amount
+      attribute? :estimated_activate_fee, Types::JSON::Amount
 
       # @!attribute [r] estimated_transfer_fee
       #   @return [String] Estimated transfer fee
-      attribute? :estimated_transfer_fee, Types::Amount
+      attribute? :estimated_transfer_fee, Types::JSON::Amount
 
       # @!attribute [r] txn_hash
       #   @return [String] On-chain transaction hash
@@ -90,23 +90,23 @@ module GasfreeSdk
 
       # @!attribute [r] txn_activate_fee
       #   @return [String] Actual activation fee
-      attribute? :txn_activate_fee, Types::Amount
+      attribute? :txn_activate_fee, Types::JSON::Amount
 
       # @!attribute [r] txn_transfer_fee
       #   @return [String] Actual transfer fee
-      attribute? :txn_transfer_fee, Types::Amount
+      attribute? :txn_transfer_fee, Types::JSON::Amount
 
       # @!attribute [r] txn_total_fee
       #   @return [String] Total actual fee
-      attribute? :txn_total_fee, Types::Amount
+      attribute? :txn_total_fee, Types::JSON::Amount
 
       # @!attribute [r] txn_amount
       #   @return [String] Actual transferred amount
-      attribute? :txn_amount, Types::Amount
+      attribute? :txn_amount, Types::JSON::Amount
 
       # @!attribute [r] txn_total_cost
       #   @return [String] Total cost including fees
-      attribute? :txn_total_cost, Types::Amount
+      attribute? :txn_total_cost, Types::JSON::Amount
     end
   end
 end