weft-sdk 0.2.1

data/docs/Payment.md

@@ -0,0 +1,44 @@
+# Weft::Payment
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **Integer** |  |  |
+| **tx_hash** | **String** |  |  |
+| **payer_address** | **String** |  |  |
+| **recipient_address** | **String** |  |  |
+| **amount** | **Integer** | Amount in atomic units (1 USDC = 1,000,000) |  |
+| **amount_formatted** | **String** | Human-readable amount (e.g. \"1.00 USDC\") |  |
+| **currency** | **String** |  |  |
+| **network** | **String** | CAIP-2 chain identifier |  |
+| **resource_url** | **String** |  | [optional] |
+| **resource_host** | **String** |  | [optional] |
+| **fee_amount** | **Integer** |  | [optional] |
+| **settlement_latency_ms** | **Integer** |  | [optional] |
+| **settled_at** | **Time** |  |  |
+| **api_key_name** | **String** |  |  |
+
+## Example
+
+```ruby
+require 'weft-sdk'
+
+instance = Weft::Payment.new(
+  id: null,
+  tx_hash: null,
+  payer_address: null,
+  recipient_address: null,
+  amount: null,
+  amount_formatted: null,
+  currency: null,
+  network: null,
+  resource_url: null,
+  resource_host: null,
+  fee_amount: null,
+  settlement_latency_ms: null,
+  settled_at: null,
+  api_key_name: null
+)
+```
+

data/docs/PaymentListResponse.md

@@ -0,0 +1,20 @@
+# Weft::PaymentListResponse
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **data** | [**Array<Payment>**](Payment.md) |  |  |
+| **pagination** | [**Pagination**](Pagination.md) |  |  |
+
+## Example
+
+```ruby
+require 'weft-sdk'
+
+instance = Weft::PaymentListResponse.new(
+  data: null,
+  pagination: null
+)
+```
+

data/docs/PaymentResponse.md

@@ -0,0 +1,18 @@
+# Weft::PaymentResponse
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **data** | [**Payment**](Payment.md) |  |  |
+
+## Example
+
+```ruby
+require 'weft-sdk'
+
+instance = Weft::PaymentResponse.new(
+  data: null
+)
+```
+

data/docs/PaymentsApi.md

@@ -0,0 +1,147 @@
+# Weft::PaymentsApi
+
+All URIs are relative to *https://api.weftlabs.com*
+
+| Method | HTTP request | Description |
+| ------ | ------------ | ----------- |
+| [**get_payment**](PaymentsApi.md#get_payment) | **GET** /api/v1/payments/{id} | Get payment details |
+| [**list_payments**](PaymentsApi.md#list_payments) | **GET** /api/v1/payments | List payments |
+
+
+## get_payment
+
+> <PaymentResponse> get_payment(id)
+
+Get payment details
+
+### Examples
+
+```ruby
+require 'time'
+require 'weft-sdk'
+# setup authorization
+Weft.configure do |config|
+  # Configure Bearer authorization (APIKey): bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Weft::PaymentsApi.new
+id = 56 # Integer | Payment ID
+
+begin
+  # Get payment details
+  result = api_instance.get_payment(id)
+  p result
+rescue Weft::ApiError => e
+  puts "Error when calling PaymentsApi->get_payment: #{e}"
+end
+```
+
+#### Using the get_payment_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<PaymentResponse>, Integer, Hash)> get_payment_with_http_info(id)
+
+```ruby
+begin
+  # Get payment details
+  data, status_code, headers = api_instance.get_payment_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <PaymentResponse>
+rescue Weft::ApiError => e
+  puts "Error when calling PaymentsApi->get_payment_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **Integer** | Payment ID |  |
+
+### Return type
+
+[**PaymentResponse**](PaymentResponse.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## list_payments
+
+> <PaymentListResponse> list_payments(opts)
+
+List payments
+
+### Examples
+
+```ruby
+require 'time'
+require 'weft-sdk'
+# setup authorization
+Weft.configure do |config|
+  # Configure Bearer authorization (APIKey): bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Weft::PaymentsApi.new
+opts = {
+  page: 56, # Integer | Page number
+  per_page: 56 # Integer | Items per page
+}
+
+begin
+  # List payments
+  result = api_instance.list_payments(opts)
+  p result
+rescue Weft::ApiError => e
+  puts "Error when calling PaymentsApi->list_payments: #{e}"
+end
+```
+
+#### Using the list_payments_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<PaymentListResponse>, Integer, Hash)> list_payments_with_http_info(opts)
+
+```ruby
+begin
+  # List payments
+  data, status_code, headers = api_instance.list_payments_with_http_info(opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <PaymentListResponse>
+rescue Weft::ApiError => e
+  puts "Error when calling PaymentsApi->list_payments_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **page** | **Integer** | Page number | [optional][default to 1] |
+| **per_page** | **Integer** | Items per page | [optional][default to 25] |
+
+### Return type
+
+[**PaymentListResponse**](PaymentListResponse.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+

data/docs/ResendConfirmationRequest.md

@@ -0,0 +1,18 @@
+# Weft::ResendConfirmationRequest
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **email** | **String** |  |  |
+
+## Example
+
+```ruby
+require 'weft-sdk'
+
+instance = Weft::ResendConfirmationRequest.new(
+  email: null
+)
+```
+

data/docs/SignInRequest.md

@@ -0,0 +1,20 @@
+# Weft::SignInRequest
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **email** | **String** |  |  |
+| **password** | **String** |  |  |
+
+## Example
+
+```ruby
+require 'weft-sdk'
+
+instance = Weft::SignInRequest.new(
+  email: null,
+  password: null
+)
+```
+

data/docs/SignUpRequest.md

@@ -0,0 +1,22 @@
+# Weft::SignUpRequest
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **email** | **String** |  |  |
+| **password** | **String** |  |  |
+| **password_confirmation** | **String** |  |  |
+
+## Example
+
+```ruby
+require 'weft-sdk'
+
+instance = Weft::SignUpRequest.new(
+  email: null,
+  password: null,
+  password_confirmation: null
+)
+```
+

data/docs/User.md

@@ -0,0 +1,22 @@
+# Weft::User
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **Integer** |  |  |
+| **email** | **String** |  |  |
+| **status** | **String** |  | [optional] |
+
+## Example
+
+```ruby
+require 'weft-sdk'
+
+instance = Weft::User.new(
+  id: null,
+  email: null,
+  status: null
+)
+```
+

data/lib/weft/facilitator/client.rb

@@ -0,0 +1,89 @@
+require 'net/http'
+require 'json'
+
+module Weft
+  module Facilitator
+    DEFAULT_URL = 'https://x402.weft.network'.freeze
+    DEFAULT_ENV = 'X402_FACILITATOR_URL'.freeze
+
+    class Client
+      def initialize(url: nil, create_headers: nil)
+        @url = resolve_url(url)
+        validate_url(@url)
+        @create_headers = create_headers
+      end
+
+      def verify(payment_payload:, payment_requirements:)
+        post_json('/verify', {
+                    x402Version: 2,
+                    paymentPayload: payment_payload,
+                    paymentRequirements: payment_requirements
+                  })
+      end
+
+      def settle(payment_payload:, payment_requirements:)
+        post_json('/settle', {
+                    x402Version: 2,
+                    paymentPayload: payment_payload,
+                    paymentRequirements: payment_requirements
+                  })
+      end
+
+      def supported
+        get_json('/supported')
+      end
+
+      private
+
+      def resolve_url(url)
+        return url if url && !url.empty?
+
+        env = ENV.fetch(DEFAULT_ENV, nil)
+        return env if env && !env.empty?
+
+        DEFAULT_URL
+      end
+
+      def validate_url(url)
+        return unless url.empty? || (!url.start_with?('http://') && !url.start_with?('https://'))
+
+        raise ArgumentError, "Invalid URL: #{url}"
+      end
+
+      def build_headers(scope)
+        headers = { 'Content-Type' => 'application/json' }
+        return headers unless @create_headers
+
+        custom = @create_headers.call
+        scope_headers = custom && custom[scope]
+        headers.merge(scope_headers || {})
+      end
+
+      def get_json(path)
+        uri = URI.join(@url, path)
+        request = Net::HTTP::Get.new(uri, build_headers('supported'))
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(request)
+        end
+        parse_response(response)
+      end
+
+      def post_json(path, body)
+        uri = URI.join(@url, path)
+        scope = path.include?('verify') ? 'verify' : 'settle'
+        request = Net::HTTP::Post.new(uri, build_headers(scope))
+        request.body = JSON.generate(body)
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(request)
+        end
+        parse_response(response)
+      end
+
+      def parse_response(response)
+        raise "Facilitator request failed: #{response.code} #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/weft/facilitator/fee.rb

@@ -0,0 +1,47 @@
+module Weft
+  module Facilitator
+    module Fee
+      DEFAULT_TTL = 300
+
+      @cache = nil
+
+      class << self
+        def get_fee_info(client: Client.new, ttl: DEFAULT_TTL)
+          return @cache[:fee] if cache_valid?
+
+          supported = client.supported
+          fee = supported['fee']
+          raise 'Fee information not found in /supported response' unless fee
+
+          validate_fee!(fee)
+
+          @cache = {
+            fee: fee,
+            fetched_at: Time.now.to_i,
+            ttl: ttl
+          }
+
+          fee
+        end
+
+        def invalidate_fee_cache
+          @cache = nil
+        end
+
+        private
+
+        def cache_valid?
+          return false unless @cache
+
+          Time.now.to_i - @cache[:fetched_at] < @cache[:ttl]
+        end
+
+        def validate_fee!(fee)
+          raise 'Invalid fee structure: amount must be a string' unless fee['amount'].is_a?(String)
+          raise 'Invalid fee structure: asset must be a string' unless fee['asset'].is_a?(String)
+          raise 'Invalid fee structure: network must be a string' unless fee['network'].is_a?(String)
+        end
+      end
+    end
+  end
+end

data/lib/weft/facilitator/middleware.rb

@@ -0,0 +1,190 @@
+require 'json'
+require_relative 'client'
+
+module Weft
+  module Facilitator
+    # Configuration for a route that requires payment.
+    #
+    #   {
+    #     path: "/api/resource",          # string or Regexp
+    #     price: "0.01",                  # price in asset units
+    #     asset: "USDC",
+    #     network: "base-sepolia",
+    #     pay_to: "0x...",                # recipient address
+    #     description: "Access resource",
+    #     max_deadline_seconds: 60,
+    #   }
+    RouteConfig = Struct.new(
+      :path, :price, :asset, :network, :pay_to,
+      :description, :max_deadline_seconds,
+      keyword_init: true
+    ) do
+      def initialize(**kwargs)
+        super
+        self.network ||= 'base-sepolia'
+        self.max_deadline_seconds ||= 60
+        self.description ||= ''
+      end
+    end
+
+    class RackMiddleware
+      PAYMENT_HEADERS = %w[HTTP_X_PAYMENT HTTP_PAYMENT_SIGNATURE].freeze
+      X402_VERSION = 2
+
+      # @param app [#call] The downstream Rack app
+      # @param routes [Array<Hash>] Route payment configurations
+      # @param config [Hash] Options including :facilitator_url
+      def initialize(app, routes: [], config: {})
+        @app = app
+        @config = config
+        @routes = routes.map do |r|
+          r.is_a?(RouteConfig) ? r : RouteConfig.new(**r)
+        end
+        @client = Client.new(url: config[:facilitator_url])
+      end
+
+      def call(env)
+        return @app.call(env) if @routes.empty?
+
+        request_path = env['PATH_INFO'] || '/'
+        route = match_route(request_path)
+
+        return @app.call(env) unless route
+
+        payment_header = extract_payment_header(env)
+
+        return payment_required_response(route, env) unless payment_header
+
+        # Verify the payment via facilitator
+        payment_payload = parse_payment(payment_header)
+        requirements = build_requirements(route, env)
+
+        begin
+          verify_result = @client.verify(
+            payment_payload: payment_payload,
+            payment_requirements: requirements
+          )
+        rescue StandardError => e
+          return error_response(402, "Payment verification failed: #{e.message}")
+        end
+
+        unless verify_result['valid']
+          return error_response(402, verify_result['message'] || 'Payment verification failed')
+        end
+
+        # Call the downstream app
+        status, headers, body = @app.call(env)
+
+        # If the app returned an error, don't settle
+        return [status, headers, body] if status >= 400
+
+        # Settle the payment
+        begin
+          settle_result = @client.settle(
+            payment_payload: payment_payload,
+            payment_requirements: requirements
+          )
+
+          return error_response(402, "Settlement failed: #{settle_result['message']}") unless settle_result['success']
+
+          headers['X-Payment-TxHash'] = settle_result['txHash'] if settle_result['txHash']
+        rescue StandardError => e
+          return error_response(402, "Settlement failed: #{e.message}")
+        end
+
+        [status, headers, body]
+      end
+
+      private
+
+      def match_route(path)
+        @routes.find do |route|
+          case route.path
+          when Regexp
+            route.path.match?(path)
+          when '*'
+            true
+          else
+            route.path == path
+          end
+        end
+      end
+
+      def extract_payment_header(env)
+        PAYMENT_HEADERS.each do |header|
+          value = env[header]
+          return value if value && !value.empty?
+        end
+        nil
+      end
+
+      def parse_payment(header_value)
+        JSON.parse(header_value)
+      rescue JSON::ParserError
+        # If not JSON, treat as an opaque token
+        { 'token' => header_value }
+      end
+
+      def build_requirements(route, env)
+        {
+          'scheme' => 'exact',
+          'network' => route.network,
+          'asset' => route.asset,
+          'amount' => route.price,
+          'payTo' => route.pay_to,
+          'maxTimeoutSeconds' => route.max_deadline_seconds,
+          'resource' => {
+            'url' => request_url(env),
+            'method' => env['REQUEST_METHOD'],
+            'description' => route.description
+          }
+        }
+      end
+
+      def request_url(env)
+        scheme = env['rack.url_scheme'] || 'https'
+        host = env['HTTP_HOST'] || env['SERVER_NAME'] || 'localhost'
+        path = env['PATH_INFO'] || '/'
+        "#{scheme}://#{host}#{path}"
+      end
+
+      def payment_required_response(route, env)
+        body = {
+          'x402Version' => X402_VERSION,
+          'error' => 'Payment Required',
+          'accepts' => [{
+            'scheme' => 'exact',
+            'network' => route.network,
+            'asset' => route.asset,
+            'amount' => route.price,
+            'payTo' => route.pay_to,
+            'maxTimeoutSeconds' => route.max_deadline_seconds,
+            'resource' => {
+              'url' => request_url(env),
+              'method' => env['REQUEST_METHOD'],
+              'description' => route.description
+            }
+          }]
+        }
+
+        [
+          402,
+          {
+            'Content-Type' => 'application/json',
+            'X-Payment-Required' => 'true'
+          },
+          [JSON.generate(body)]
+        ]
+      end
+
+      def error_response(status, message)
+        body = { 'error' => message }
+        [
+          status,
+          { 'Content-Type' => 'application/json' },
+          [JSON.generate(body)]
+        ]
+      end
+    end
+  end
+end