amazon-pay-api-sdk-ruby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: be95e6a94ffd92f2b63c434fae57106167e710b78e37ec2ee769055400498153
+  data.tar.gz: b37aec741850a99fb89cc241f396da9fe49e0de47f910232101ba32c8c8bafb0
+SHA512:
+  metadata.gz: 82928d3a73a42da02eb620166c86056402773fd700ff6d0e717d0610ff25ef02f1c84ef9bf4cd4288b70df489d0333b30297cee3b40bfbcdb34e3a3a057816b9
+  data.tar.gz: 575aa9e43e074704128e085ac94d2dc3063d2dc4add84eebb5ea9d860c051fea17c1fe139b2339ceca0f2028a2ecd1e0cc8fb7fd48bf47d547a12d1f8a8b457e

data/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+   
+   Licensed under the Apache License, Version 2.0 (the "License").
+   You may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+   
+         http://www.apache.org/licenses/LICENSE-2.0
+   
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,218 @@
+## Amazon Pay Ruby SDK Usage
+
+This guide provides step-by-step instructions on how to use the Amazon Pay Client for creating and updating merchant accounts, as well as claiming merchant accounts.
+
+
+### Prerequisites
+
+- Ruby installed on your system.
+- `amazon-pay-api-sdk-ruby` gem installed or this source code has been imported in your project.
+- Your `publicKeyId` & `privateKey.pem` file available.
+
+### Install
+```
+gem install amazon-pay-api-sdk-ruby
+```
+or add the following in your Gemfile:
+
+```ruby
+gem 'amazon-pay-api-sdk-ruby'
+```
+```
+bundle install
+```
+
+### Configuration
+
+Create a configuration with your Amazon Pay credentials and region:
+
+```ruby
+config = {
+  region: 'jp', # Supported Values: na, eu, jp
+  public_key_id: 'PUBLIC_KEY_ID',
+  private_key: File.read('privateKey.pem'),
+  sandbox: true # Optional. Set this paramter true/false if your public_key_id does not have an environment prefix (does not begin with 'SANDBOX' or 'LIVE')
+}
+```
+
+### Initialize the Amazon Pay Client:
+
+```ruby
+client = AmazonPayClient.new(config)
+```
+
+
+### Create Merchant Account
+
+Define the payload and headers for the `create_merchant_account` API call:
+
+```ruby
+require './lib/amazon_pay'
+
+client = AmazonPayClient.new(config)
+
+createMerchantAccountPayload = {
+    "uniqueReferenceId": "XXXXX",
+    "ledgerCurrency": "JPY",
+    "businessInfo": {
+        "email": "abc@abc.com",
+        "businessType": "CORPORATE",
+        "businessLegalName": "Legal Name",
+        "businessCategory": "Beauty",
+        "businessAddress": {
+            "addressLine1": "122, ABC XYZ",
+            "addressLine2": "XYZ",
+            "city": "XYZ",
+            "stateOrRegion": "XYZ",
+            "postalCode": "123456",
+            "countryCode": "JP",
+            "phoneNumber": {
+                "countryCode": "123",
+                "number": "1234567890"
+            }
+        },
+        "businessDisplayName": "Business Name",
+        "annualSalesVolume": {
+            "amount": "100000",
+            "currencyCode": "JPY"
+        },
+        "countryOfEstablishment": "JP",
+        "customerSupportInformation": {
+            "customerSupportEmail": "merchant@abc.com",
+            "customerSupportPhoneNumber": {
+                "countryCode": "1",
+                "number": "1234567",
+                "extension": "123"
+            }
+        }
+    },
+    "beneficiaryOwners": [
+        {
+            "personId": "BO1",
+            "personFullName": "ABC ABC",
+            "residentialAddress": {
+                "addressLine1": "122, ABC XYZ",
+                "addressLine2": "XYZ",
+                "city": "XYZ",
+                "stateOrRegion": "XYZ",
+                "postalCode": "123456",
+                "countryCode": "JP",
+                "phoneNumber": {
+                    "countryCode": "123",
+                    "number": "2062062061"
+                }
+            }
+        },
+        {
+            "personId": "BO2",
+            "personFullName": "ABC ABC",
+            "residentialAddress": {
+                "addressLine1": "122, ABC XYZ",
+                "addressLine2": "XYZ",
+                "city": "XYZ",
+                "stateOrRegion": "XYZ",
+                "postalCode": "123456",
+                "countryCode": "JP",
+                "phoneNumber": {
+                    "countryCode": "123",
+                    "number": "2062062061"
+                }
+            }
+        }
+    ],
+    "primaryContactPerson": {
+        "personFullName": "ABC ABC"
+    },
+    "integrationInfo": {
+        "ipnEndpointUrls": [
+            "https://website.com/ipnendpoint", "https://website.com/ipnendpoint"
+        ]
+    },
+    "defaultStore": {
+        "domainUrls": [
+            "http://www.abc.com"
+        ],
+        "storeName": "ABC ABC",
+        "privacyPolicyUrl": "http://www.abc.com/privacy",
+        "storeStatus": {
+            "state": "Active",
+            "reasonCode": nil
+        }
+    },
+    "merchantStatus": {
+        "statusProvider": "ABC",
+        "state": "ACTIVE",
+        "reasonCode": nil
+    }
+}
+
+createMerchantAccountHeader = {
+    "x-amz-pay-Idempotency-Key": "idempotency-key"
+}
+
+response = client.create_merchant_account(createMerchantAccountPayload, headers: createMerchantAccountHeader)
+if response.code.to_i == 201 || response.code.to_i == 200
+    puts "Create Merchant Account API Response:"
+    puts response.body
+else
+    puts "Error: Create Merchant Account API"
+    puts "Status: #{response.code}"
+    puts response.body
+end
+```
+
+### Update Merchant Account
+
+Define the payload and headers for the `update_merchant_account` API call:
+
+```ruby
+updateMerchantAccountPayload = {
+    "businessInfo": {
+      "businessAddress": {
+        "addressLine1": "122, ABC XYZ",
+        "addressLine2": "XYZ",
+        "city": "XYZ",
+        "stateOrRegion": "XYZ",
+        "postalCode": "123456",
+        "countryCode": "JP",
+        "phoneNumber": {
+            "countryCode": "123",
+            "number": "2062062061"
+        }
+      }
+    }
+}
+
+updateMerchantAccountHeader = {}
+
+response = client.update_merchant_account('XXXXXXXXX', updateMerchantAccountPayload, headers: updateMerchantAccountHeader)
+if response.code.to_i == 200
+    puts "Update Merchant Account API Response:"
+    puts response.body
+else
+    puts "Error: Update Merchant Account API"
+    puts "Status: #{response.code}"
+    puts response.body
+end
+```
+
+### Merchant Account Claim
+
+Define the payload and headers for the `merchant_account_claim` API call:
+
+```ruby
+
+merchantAccountClaimPayload = {
+    "uniqueReferenceId": "XXXXXX"
+}
+
+response = client.merchant_account_claim('XXXXXXXXX', merchantAccountClaimPayload, headers: {})
+if response.code.to_i == 303
+    puts "Merchant Account Claim API Response:"
+    puts response.body
+else
+    puts "Error: Merchant Account Claim API"
+    puts "Status: #{response.code}"
+    puts response.body
+end
+```

data/lib/amazon_pay/client.rb

@@ -0,0 +1,102 @@
+require 'net/http'
+require_relative 'client_helper'
+require_relative 'constants'
+
+# AmazonPayClient class provides methods to interact with Amazon Pay API
+class AmazonPayClient
+
+  # Initialize the client with configuration settings
+  def initialize(config)
+    @helper = ClientHelper.new(config)
+  end
+
+  # Perform an API call to Amazon Pay
+  # @param url_fragment [String] The URL fragment for the API endpoint
+  # @param method [String] The HTTP method for the API call (e.g., 'POST', 'PATCH')
+  # @param payload [Hash] The payload for the API call, default is an empty string
+  # @param headers [Hash] Optional headers for the API call, default is an empty hash
+  # @param query_params [Hash] Optional query parameters for the API call, default is an empty hash
+  # @return [HTTPResponse] The response from the API call
+  def api_call(url_fragment, method, payload: '', headers: {}, query_params: {})
+    # Convert query parameters into a URL-encoded query string
+    query = @helper.to_query(query_params)
+
+    # Build the full URI by combining the URL fragment and query string
+    uri = @helper.build_uri(url_fragment, query)
+
+    # Initialize the retry counter
+    retries = 0
+  
+    begin
+      # Create a new HTTP request with the specified method, URI, and payload
+      request = @helper.create_request(method, uri, payload)
+
+      # Generate signed headers for the request
+      signed_headers = @helper.signed_headers(method, uri, request.body, headers, query)
+
+      # Set the signed headers on the request
+      @helper.set_request_headers(request, signed_headers)
+
+      # Send the HTTP request and get the response
+      response = @helper.send_request(uri, request)
+  
+      # Check if the response code indicates a retryable error and if we haven't exceeded the maximum retries
+      if Constants::RETRYABLE_ERROR_CODES.include?(response.code.to_i) && retries < Constants::MAX_RETRIES
+        # Wait for a specified backoff period before retrying
+        sleep Constants::BACKOFF_TIMES[retries]
+
+        # Increment the retry counter
+        retries += 1
+        print "Retrying\n"
+        # Raise an exception to force a retry
+        raise "Transient error: #{response.code}" # Force retry
+      end
+  
+      # Return the response if no retry is needed
+      response 
+  
+      rescue => e
+        # Catches any exceptions that occur during the request
+        if retries < Constants::MAX_RETRIES
+
+          # Increment the retry counter
+          retries += 1
+
+          # Wait for a specified backoff period before retrying
+          sleep Constants::BACKOFF_TIMES[retries - 1] # Backoff before retry
+
+          # Retry the request
+          retry
+        else
+          # After maximum retries are exhausted, return the response from the last attempt
+          response
+        end
+    end
+  end 
+
+  # Creates a merchant account
+  # @param payload [Hash] The payload for the API call
+  # @param headers [Hash] - Optional headers for the API call, default is an empty hash
+  # @return [HTTPResponse] The response from the API call
+  def create_merchant_account(payload, headers: {})
+    api_call(Constants::MERCHANT_ACCOUNTS_BASE_URL, Constants::POST, payload: payload, headers: headers)
+  end
+
+  # Updates a merchant account
+  # @param merchant_account_id [String] The ID of the merchant account to update
+  # @param payload [Hash] The payload for the API call
+  # @param headers [Hash] - Optional headers for the API call but requires x-amz-pay-authToken header for this API, default is an empty hash
+  # @return [HTTPResponse] The response from the API call
+  def update_merchant_account(merchant_account_id, payload, headers: {})
+    api_call("#{Constants::MERCHANT_ACCOUNTS_BASE_URL}/#{merchant_account_id}", Constants::PATCH, payload: payload, headers: headers)
+  end
+
+  # Claims a merchant account
+  # @param merchant_account_id [String] The ID of the merchant account to claim
+  # @param payload [Hash] The payload for the API call
+  # @param headers [Hash] Optional headers for the API call, default is an empty hash
+  # @return [HTTPResponse] The response from the API call
+  def merchant_account_claim(merchant_account_id, payload, headers: {})
+    api_call("#{Constants::MERCHANT_ACCOUNTS_BASE_URL}/#{merchant_account_id}/claim", Constants::POST, payload: payload, headers: headers)
+  end
+end

data/lib/amazon_pay/client_helper.rb

@@ -0,0 +1,176 @@
+require 'openssl'
+require 'time'
+require 'json'
+require 'base64'
+require_relative 'constants'
+require 'uri'
+
+# ClientHelper class provides utility functions for API interactions
+class ClientHelper
+  attr_reader :base_url
+
+  # Initialize with configuration settings
+  def initialize(config)
+    validate_config(config)
+    @region = fetch(:region, config)
+    @public_key_id = fetch(:public_key_id, config) 
+    @private_key = fetch(:private_key, config)
+    @amazon_signature_algorithm = Constants::AMAZON_SIGNATURE_ALGORITHM 
+    @salt_length = 32 
+    environment = determine_environment(config)
+    @base_url = "https://#{endpoint}/#{environment}/#{Constants::API_VERSION}/"
+  end
+
+  # Determine the environment based on the public key or the config setting
+  def determine_environment(config)
+    @live = Constants::LIVE[0...-1].downcase
+    @sandbox = Constants::SANDBOX[0...-1].downcase
+    if @public_key_id.start_with?(Constants::LIVE)
+      :live
+    elsif @public_key_id.start_with?(Constants::SANDBOX)
+      :sandbox
+    else
+      fetch(:sandbox, config) ? :sandbox : :live
+    end
+  end
+
+  # Fetch value from config hash
+  def fetch(key, config)
+    config[key] || config[key.to_s]
+  end
+
+  # Get endpoint URL based on region
+  def endpoint
+    Constants::API_ENDPOINTS[@region] || raise(ArgumentError, "Unknown region: '#{@region}'. Valid regions are: #{Constants::API_ENDPOINTS.keys.join(', ')}.")
+  end
+
+  # Get HTTP method object based on method string
+  def http_method(method)
+    Constants::METHOD_TYPES[method] || raise(ArgumentError, "Unknown HTTP method: '#{method}'. Valid methods are: #{Constants::METHOD_TYPES.keys.join(', ')}.")
+  end
+
+  # Generate signed headers for the API request
+  def signed_headers(method, uri, payload, user_headers, query)
+    headers = prepare_headers(user_headers, uri, payload) 
+    canonical_headers = canonicalize_headers(headers) 
+    canonical_request = build_canonical_request(method, uri, query, canonical_headers, payload) 
+    signed_headers = sign_headers(canonical_request, canonical_headers)
+    
+    # Add authorization header
+    headers[Constants::AUTHORIZATION] = authorization_header(signed_headers) 
+    headers
+  end
+
+  # Sign the given string using the private key
+  def sign(string_to_sign)
+    hashed_request = "#{@amazon_signature_algorithm}\n#{hex_and_hash(string_to_sign)}"
+    rsa = OpenSSL::PKey::RSA.new(@private_key)
+    Base64.strict_encode64(rsa.sign_pss(Constants::HASH_ALGORITHM, hashed_request, salt_length: @salt_length, mgf1_hash: Constants::HASH_ALGORITHM))
+  end
+
+  # Convert query parameters to URL query string
+  def to_query(query_params)
+    URI.encode_www_form(query_params.sort.to_h)
+  end
+
+  # Prepare headers for the API request
+  def prepare_headers(user_headers, uri, payload)
+    headers = normalize_headers(user_headers)
+    headers[Constants::ACCEPT] = headers[Constants::CONTENT_TYPE] = Constants::APPLICATION_JSON
+    headers[Constants::X_AMZ_PAY_REGION] = @region
+    headers[Constants::X_AMZ_PAY_DATE] = formatted_timestamp
+    headers[Constants::X_AMZ_PAY_HOST] = uri.host
+    headers[Constants::CONTENT_LENGTH] = payload.bytesize.to_s unless payload.empty?
+    headers[Constants::X_AMZ_PAY_SDK_TYPE] = Constants::SDK_TYPE
+    headers[Constants::X_AMZ_PAY_SDK_VERSION] = Constants::SDK_VERSION
+    headers
+  end
+
+  # Normalize headers by converting keys to strings and stripping values
+  def normalize_headers(headers)
+    headers.transform_keys(&:to_s).transform_values(&:strip)
+  end
+
+  # Canonicalize headers by converting keys to lowercase and sorting them
+  def canonicalize_headers(headers)
+    headers.transform_keys(&:downcase).sort.to_h
+  end
+
+  # Build the canonical request string
+  def build_canonical_request(method, uri, query, canonical_headers, payload)
+    headers_string = canonical_headers.map { |k, v| "#{k}:#{v}" }.join("\n")
+    signed_headers = canonical_headers.keys.join(';')
+    hashed_payload = hex_and_hash(payload)
+
+    "#{method}\n#{uri.path}\n#{query}\n#{headers_string}\n\n#{signed_headers}\n#{hashed_payload}"
+  end
+
+  # Sign the canonical request headers
+  def sign_headers(canonical_request, canonical_headers)
+    hashed_request = "#{@amazon_signature_algorithm}\n#{hex_and_hash(canonical_request)}"
+    rsa = OpenSSL::PKey::RSA.new(@private_key)
+    signature = Base64.strict_encode64(rsa.sign_pss(Constants::HASH_ALGORITHM, hashed_request, salt_length: @salt_length, mgf1_hash: Constants::HASH_ALGORITHM))
+    "SignedHeaders=#{canonical_headers.keys.join(';')}, Signature=#{signature}"
+  end
+
+  # Build authorization header from signed headers
+  def authorization_header(signed_headers)
+    "#{@amazon_signature_algorithm} PublicKeyId=#{@public_key_id}, #{signed_headers}"
+  end
+
+  # Compute SHA256 hash of the given data
+  def hex_and_hash(data)
+    Digest::SHA256.hexdigest(data)
+  end
+
+  # Format the current timestamp
+  def formatted_timestamp
+    Time.now.utc.iso8601.delete(':-')
+  end
+
+  # URL encode the given value
+  def url_encode(value)
+    URI.encode_www_form_component(value).gsub('%7E', '~')
+  end
+
+  # AmazonPayClient dependency methods
+  # Create a new HTTP request
+  def create_request(method, uri, payload)
+    request = http_method(method).new(uri)
+    request.body = payload.is_a?(String) ? payload : JSON.generate(payload)
+    request
+  end
+
+  # Set headers for the HTTP request
+  def set_request_headers(request, signed_headers)
+    signed_headers.each { |k, v| request[k] = v }
+  end
+
+  # Send the HTTP request
+  def send_request(uri, request)
+    Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == Constants::HTTPS) do |http|
+      http.request(request)
+    end
+  end
+
+  # Build the full URI for the API request
+  def build_uri(url_fragment, query)
+    URI.parse("#{@base_url}#{url_fragment}#{query.empty? ? '' : "?#{query}"}")
+  end
+
+  # This method checks if all required configuration keys are present in the given config. 
+  # If any required key is missing, it raises a StandardError with a message listing the missing keys.
+  def validate_config(config)
+    # Define the list of required keys.
+    required_keys = %i[region public_key_id private_key]
+
+    # Identify which required keys are missing from the config hash.
+    missing_keys = required_keys.select { |key| config[key].nil? }
+
+    # If there are missing keys, raise an error with a descriptive message.
+    unless missing_keys.empty?
+      raise StandardError, "Missing required config keys: #{missing_keys.join(', ')}"
+    end
+  end
+
+end

data/lib/amazon_pay/constants.rb

@@ -0,0 +1,42 @@
+require 'net/http'
+
+module Constants
+    SDK_TYPE = "MerchantOnboarding-Ruby".freeze
+    SDK_VERSION = "1.0.0".freeze
+    API_VERSION = "v2".freeze
+    API_ENDPOINTS = {
+      'na' => 'pay-api.amazon.com',
+      'eu' => 'pay-api.amazon.eu',
+      'jp' => 'pay-api.amazon.jp'
+    }.freeze
+    METHOD_TYPES = {
+      'GET' => Net::HTTP::Get,
+      'POST' => Net::HTTP::Post,
+      'PUT' => Net::HTTP::Put,
+      'PATCH' => Net::HTTP::Patch,
+      'DELETE' => Net::HTTP::Delete
+    }.freeze
+    HASH_ALGORITHM = "SHA256".freeze
+    HTTPS = 'https'.freeze
+    AMAZON_SIGNATURE_ALGORITHM = "AMZN-PAY-RSASSA-PSS-V2".freeze
+    AUTHORIZATION = 'authorization'.freeze
+    ACCEPT = 'accept'.freeze
+    CONTENT_TYPE = 'content-type'.freeze
+    APPLICATION_JSON = 'application/json'.freeze
+    X_AMZ_PAY_REGION = 'x-amz-pay-region'.freeze
+    X_AMZ_PAY_DATE = 'x-amz-pay-date'.freeze
+    X_AMZ_PAY_HOST = 'x-amz-pay-host'.freeze
+    CONTENT_LENGTH = 'content-length'.freeze
+    X_AMZ_PAY_SDK_TYPE = 'x-amz-pay-sdk-type'.freeze
+    X_AMZ_PAY_SDK_VERSION = 'x-amz-pay-sdk-version'.freeze
+    LIVE = 'LIVE-'
+    SANDBOX = 'SANDBOX-'
+    MERCHANT_ACCOUNTS_BASE_URL = 'merchantAccounts'.freeze
+    POST = 'POST'.freeze
+    PATCH = 'PATCH'.freeze
+    MAX_RETRIES = 3.freeze
+    BACKOFF_TIMES = [1, 2, 4].freeze # Define backoff times for retries
+    RETRYABLE_ERROR_CODES = [408, 429, 500, 502, 503, 504].freeze
+    HTTP_OK = '200'
+    HTTP_SERVER_ERROR = '500'
+end

data/lib/amazon_pay.rb

@@ -0,0 +1,3 @@
+require_relative './amazon_pay/client'
+require_relative './amazon_pay/client_helper'
+require_relative "./amazon_pay/constants"

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: amazon-pay-api-sdk-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- AmazonPay
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: AmazonPay Ruby SDK
+email: amazon-pay-sdk@amazon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/amazon_pay.rb
+- lib/amazon_pay/client.rb
+- lib/amazon_pay/client_helper.rb
+- lib/amazon_pay/constants.rb
+homepage: https://rubygems.org/gems/amazon-pay-api-sdk-ruby
+licenses:
+- Apache-2.0
+metadata:
+  source_code_uri: https://github.com/amzn/amazon-pay-api-sdk-ruby
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: This is an AmazonPay Ruby SDK
+test_files: []