tangany 0.0.1

data/bin/test-live

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+
+puts "This suite will run tests against the \e[1mlive Tangany's API\e[0m."
+puts "\e[36mBe sure to set environment variables with \e[1mtesting values\e[0m\e[36m before running this suite.\e[0m"
+print "Do you want to continue? [y/N] "
+answer = gets.chomp
+
+exit 1 unless answer == "y"
+
+require "bundler/setup"
+require "byebug"
+require "factory_bot"
+
+require "tangany"
+
+load("Rakefile")
+Rake::Task["regenerate_fixtures"].invoke
+
+Tangany.client_id = ENV.fetch("TEST_TANGANY_CLIENT_ID", "test")
+Tangany.client_secret = ENV.fetch("TEST_TANGANY_CLIENT_SECRET", "test")
+Tangany.environment = "testnet"
+Tangany.subscription = ENV.fetch("TEST_TANGANY_SUBSCRIPTION", "test")
+Tangany.vault_url = ENV.fetch("TEST_TANGANY_VAULT_URL", "test")
+
+def safe_not_found(&block)
+  yield
+rescue Tangany::RequestError => e
+  raise e unless e.status_code == 404
+end
+
+begin
+  custody_client = Tangany::Custody::Client.new
+  customers_client = Tangany::Customers::Client.new
+
+  puts
+  puts "== Preparing data ".ljust(80, "=")
+  inputs = {
+    customer: {
+      create: JSON.parse(
+        File.read("spec/fixtures/generated/inputs/customers/customers/create/valid_input.json"),
+        symbolize_names: true
+      ),
+      update: JSON.parse(
+        File.read("spec/fixtures/generated/inputs/customers/customers/update/valid_input.json"),
+        symbolize_names: true
+      )
+    },
+    natural_person: {
+      create: JSON.parse(
+        File.read("spec/fixtures/generated/inputs/customers/natural_persons/create/valid_input.json"),
+        symbolize_names: true
+      ),
+      update: JSON.parse(
+        File.read("spec/fixtures/generated/inputs/customers/natural_persons/update/valid_input.json"),
+        symbolize_names: true
+      )
+    },
+    wallet: {
+      create: JSON.parse(
+        File.read("spec/fixtures/generated/inputs/custody/wallets/create/valid_input.json"),
+        symbolize_names: true
+      )
+    },
+    wallet_link: {
+      create: JSON.parse(
+        File.read("spec/fixtures/generated/inputs/customers/wallet_links/create/valid_input.json"),
+        symbolize_names: true
+      )
+    }
+  }
+  ids = {
+    customer: inputs[:customer][:create][:id],
+    natural_person: inputs[:natural_person][:create][:id],
+    wallet: inputs[:wallet][:create][:wallet],
+    wallet_link: inputs[:wallet_link][:create][:id]
+  }
+  inputs[:customer][:create][:owner][:entityId] = ids[:natural_person]
+  inputs[:customer][:create][:authorized][0][:entityId] = ids[:natural_person]
+  inputs[:customer][:update][:id] = ids[:customer]
+  inputs[:customer][:update][:owner][:entityId] = ids[:natural_person]
+  inputs[:customer][:update][:authorized][0][:entityId] = ids[:natural_person]
+  inputs[:natural_person][:update][:id] = ids[:natural_person]
+  inputs[:wallet_link][:create][:assignment][:customerId] = ids[:customer]
+  inputs[:wallet_link][:create][:assetId] = "ETH"
+  puts " -> \e[36mCustomer: \e[1m#{ids[:customer]}\e[0m"
+  puts " -> \e[36mNatural person: \e[1m#{ids[:natural_person]}\e[0m"
+  puts " -> \e[36mWallet: \e[1m#{ids[:wallet]}\e[0m"
+  puts " -> \e[36mWallet link: \e[1m#{ids[:wallet_link]}\e[0m"
+  puts "== Data prepared ".ljust(80, "=")
+
+  puts
+  puts "== Running tests... ".ljust(80, "=")
+
+  puts " -> Creating natural person..."
+  natural_person = customers_client.natural_persons.create(inputs[:natural_person][:create])
+  raise "Natural person creation failed" unless natural_person.is_a?(Tangany::Customers::NaturalPerson)
+
+  puts " -> Listing natural persons..."
+  natural_persons = customers_client.natural_persons.list
+  raise "Natural person not present in list" unless natural_persons.data.map(&:id).include?(ids[:natural_person])
+
+  puts " -> Retrieving natural person..."
+  natural_person = customers_client.natural_persons.retrieve(ids[:natural_person])
+  raise "Natural person retrieval failed" unless natural_person.is_a?(Tangany::Customers::NaturalPerson)
+
+  puts " -> Updating natural person..."
+  natural_person = customers_client.natural_persons.update(ids[:natural_person], inputs[:natural_person][:update])
+  raise "Natural person update failed" unless natural_person.is_a?(Tangany::Customers::NaturalPerson)
+
+  puts " -> Creating customer..."
+  customer = customers_client.customers.create(inputs[:customer][:create])
+  raise "Customer creation failed" unless customer.is_a?(Tangany::Customers::Customer)
+
+  puts " -> Listing customers..."
+  customers = customers_client.customers.list
+  raise "Customer not present in list" unless customers.data.map(&:id).include?(ids[:customer])
+
+  puts " -> Retrieving customer..."
+  customer = customers_client.customers.retrieve(ids[:customer])
+  raise "Customer retrieval failed" unless customer.is_a?(Tangany::Customers::Customer)
+
+  puts " -> Updating customer..."
+  customer = customers_client.customers.update(ids[:customer], inputs[:customer][:update])
+  raise "Customer update failed" unless customer.is_a?(Tangany::Customers::Customer)
+
+  puts " -> Creating wallet..."
+  wallet = custody_client.wallets.create(inputs[:wallet][:create])
+  raise "Wallet creation failed" unless wallet.is_a?(Tangany::Custody::Wallet)
+
+  puts " -> Creating wallet link with address value..."
+  wallet_link = customers_client.wallet_links.create(inputs[:wallet_link][:create])
+  raise "Wallet link creation failed" unless wallet_link.is_a?(Tangany::Customers::WalletLink)
+
+  puts " -> Creating wallet link with wallet value..."
+  customers_client.wallet_links.delete(ids[:wallet_link])
+  inputs[:wallet_link][:create].delete(:address)
+  inputs[:wallet_link][:create][:wallet] = ids[:wallet]
+  wallet_link = customers_client.wallet_links.create(inputs[:wallet_link][:create])
+  raise "Wallet link creation failed" unless wallet_link.is_a?(Tangany::Customers::WalletLink)
+
+  puts " -> Listing wallet links..."
+  wallet_links = customers_client.wallet_links.list
+  raise "Wallet link not present in list" unless wallet_links.data.map(&:id).include?(ids[:wallet_link])
+
+  puts " -> Retrieving wallet link..."
+  wallet_link = customers_client.wallet_links.retrieve(ids[:wallet_link])
+  raise "Wallet link retrieval failed" unless wallet_link.is_a?(Tangany::Customers::WalletLink)
+
+  puts "== Tests run... ".ljust(80, "=")
+rescue => e
+  puts e.message
+  exit 1
+ensure
+  puts
+  puts "== Cleaning up... ".ljust(80, "=")
+
+  puts " -> Deleting wallet link..."
+  safe_not_found { customers_client.wallet_links.delete(ids[:wallet_link]) }
+
+  puts " -> Deleting wallet..."
+  safe_not_found { custody_client.wallets.delete(ids[:wallet]) }
+
+  puts " -> Deleting customer..."
+  safe_not_found { customers_client.customers.delete(ids[:customer]) }
+
+  puts " -> Deleting natural person..."
+  safe_not_found { customers_client.natural_persons.delete(ids[:natural_person]) }
+
+  puts "== Cleaned ".ljust(80, "=")
+end

data/lib/config/chains.json

@@ -0,0 +1,22 @@
+[
+  {
+    "asset_id": "ETH",
+    "base_path": "eth",
+    "header": {
+      "name": "tangany-ethereum-network",
+      "mainnet": "mainnet",
+      "testnet": "goerli"
+    },
+    "name": "Ethereum"
+  },
+  {
+    "asset_id": "MATIC",
+    "base_path": "eth",
+    "header": {
+      "name": "tangany-ethereum-network",
+      "mainnet": "polygon",
+      "testnet": "https://rpc-mumbai.maticvigil.com"
+    },
+    "name": "Polygon"
+  }
+]

data/lib/tangany/application_contract.rb

@@ -0,0 +1,19 @@
+require "active_support/core_ext/object/to_param"
+require "dry-validation"
+
+module Tangany
+  class ApplicationContract < Dry::Validation::Contract
+    ALLOWED_SORTS = ["asc", "desc"].freeze
+    COUNTRY_CODE_REGEX = %r{[A-Z]{2}}
+    DATE_REGEX = %r{[0-9]{4}-[0-9]{2}-[0-9]{2}}
+    DATETIME_REGEX = %r{[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}Z}
+    ETHEREUM_ADDRESS_REGEX = %r{^0x[a-fA-F0-9]{40}$}
+
+    def to_safe_params!(params)
+      response = call(params)
+      raise InputError, response.errors.to_h if response.failure?
+
+      response.to_h
+    end
+  end
+end

data/lib/tangany/collection.rb

@@ -0,0 +1,13 @@
+module Tangany
+  class Collection
+    attr_reader :data, :next_page_token, :next_path, :previous_path, :total
+
+    def initialize(data:, total:, next_page_token: nil, next_path: nil, previous_path: nil)
+      @data = data
+      @next_page_token = next_page_token
+      @next_path = next_path
+      @previous_path = previous_path
+      @total = total
+    end
+  end
+end

data/lib/tangany/config.rb

@@ -0,0 +1,24 @@
+require "json"
+
+module Tangany
+  class Config
+    attr_accessor :client_id, :client_secret, :environment, :chain, :subscription, :vault_url
+
+    attr_reader :custody_base_url, :customers_base_url, :customers_version, :chains
+
+    def initialize
+      @custody_base_url = "https://api.tangany.com/v1"
+
+      @customers_base_url = "https://api.tangany.com/customers"
+      @customers_version = "1"
+
+      @chains = load_chains
+    end
+
+    private
+
+    def load_chains
+      JSON.parse(File.read(File.join(__dir__, "../config/chains.json")))
+    end
+  end
+end

data/lib/tangany/custody/client.rb

@@ -0,0 +1,37 @@
+require "faraday"
+
+module Tangany
+  module Custody
+    class Client
+      attr_reader :adapter, :client_id, :client_secret, :environment, :subscription, :vault_url
+
+      def initialize(adapter: Faraday.default_adapter, stubs: nil)
+        @adapter = adapter
+        @client_id = Tangany.client_id
+        @client_secret = Tangany.client_secret
+        @environment = Tangany.environment
+        @subscription = Tangany.subscription
+        @vault_url = Tangany.vault_url
+
+        @stubs = stubs
+      end
+
+      def connection
+        @connection ||= Faraday.new do |faraday|
+          faraday.adapter(adapter, @stubs)
+          faraday.request(:json)
+          faraday.response(:json, content_type: /\bjson$/, parser_options: {symbolize_names: true})
+          faraday.url_prefix = Tangany.custody_base_url
+        end
+      end
+
+      def wallets
+        WalletsResource.new(self)
+      end
+
+      def wallet_statuses(asset_id:)
+        WalletStatusesResource.new(self, asset_id: asset_id)
+      end
+    end
+  end
+end

data/lib/tangany/custody/collection.rb

@@ -0,0 +1,17 @@
+module Tangany
+  module Custody
+    class Collection
+      class << self
+        def from_response(response, type:)
+          body = response.body
+          Tangany::Collection.new(
+            data: body[:list].map { |attributes| type.new(attributes) },
+            total: body.dig(:hits, :total),
+            next_path: body.dig(:links, :next),
+            previous_path: body.dig(:links, :previous)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tangany/custody/contracts/wallets/create.rb

@@ -0,0 +1,23 @@
+module Tangany
+  module Custody
+    module Contracts
+      module Wallets
+        class Create < ApplicationContract
+          TagSchema = Dry::Schema.Params do
+            10.times do |i|
+              optional("tag#{i}".to_sym).maybe(:string, max_size?: 256)
+            end
+          end
+
+          schema do
+            config.validate_keys = true
+
+            optional(:wallet).filled(:string, max_size?: 127, min_size?: 1)
+            optional(:useHsm).filled(:bool)
+            optional(:tags).array(TagSchema)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tangany/custody/contracts/wallets/list.rb

@@ -0,0 +1,37 @@
+module Tangany
+  module Custody
+    module Contracts
+      module Wallets
+        class List < ApplicationContract
+          ALLOWED_ORDERS = ["created", "security", "updated", "wallet"].freeze
+
+          schema do
+            config.validate_keys = true
+
+            optional(:start).filled(:integer, lt?: 10_000)
+            optional(:limit).filled(:integer, gt?: 0, lteq?: 100)
+            optional(:order).filled(:string, included_in?: ALLOWED_ORDERS)
+            optional(:sort).filled(:string, included_in?: ALLOWED_SORTS)
+            optional(:tags).filled(:array, min_size?: 1)
+            optional(:xtags).filled(:array, min_size?: 1)
+          end
+
+          rule(:sort) do
+            key.failure("should not be specified without `order`") if values[:sort] && values[:order].nil?
+          end
+
+          def to_safe_params!(params)
+            safe_params = super(params)
+            order = safe_params.delete(:order)
+
+            safe_params[:sort] = order + ((safe_params[:sort] == "desc") ? "desc" : "") if order
+            safe_params[:index] = safe_params.delete(:start) if safe_params[:start]
+            safe_params[:tags] = safe_params[:tags].join(",") if safe_params[:tags]
+            safe_params[:xtags] = safe_params[:xtags].join(",") if safe_params[:xtags]
+            safe_params
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tangany/custody/contracts/wallets/update.rb

@@ -0,0 +1,21 @@
+module Tangany
+  module Custody
+    module Contracts
+      module Wallets
+        class Update < ApplicationContract
+          TagSchema = Dry::Schema.Params do
+            10.times do |i|
+              optional("tag#{i}".to_sym).maybe(:string, max_size?: 256)
+            end
+          end
+
+          schema do
+            config.validate_keys = true
+
+            optional(:tags).array(TagSchema)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tangany/custody/contracts/wallets.rb

@@ -0,0 +1,3 @@
+require_relative "wallets/create"
+require_relative "wallets/list"
+require_relative "wallets/update"

data/lib/tangany/custody/contracts.rb

@@ -0,0 +1 @@
+require_relative "contracts/wallets"

data/lib/tangany/custody/objects/wallet.rb

@@ -0,0 +1,17 @@
+module Tangany
+  module Custody
+    class Wallet < Object
+      attribute :wallet, Types::String
+      attribute? :version, Types::String
+      attribute? :created, Types::DateTime
+      attribute? :updated, Types::DateTime
+      attribute? :security, Types::String
+      attribute? :public do
+        attribute :secp256k1, Types::String
+      end
+      attribute? :tags, Types::Array
+
+      to_datetime :created, :updated
+    end
+  end
+end

data/lib/tangany/custody/objects/wallet_recovery.rb

@@ -0,0 +1,10 @@
+module Tangany
+  module Custody
+    class WalletRecovery < Object
+      attribute :recoveryId, Types::String
+      attribute :scheduledPurgeDate, Types::DateTime
+
+      to_datetime :scheduledPurgeDate
+    end
+  end
+end

data/lib/tangany/custody/objects/wallet_status.rb

@@ -0,0 +1,10 @@
+module Tangany
+  module Custody
+    class WalletStatus < Object
+      attribute :address, Types::String
+      attribute :balance, Types::String
+      attribute :currency, Types::String
+      attribute :nonce, Types::Integer
+    end
+  end
+end

data/lib/tangany/custody/objects.rb

@@ -0,0 +1,3 @@
+require_relative "objects/wallet"
+require_relative "objects/wallet_status"
+require_relative "objects/wallet_recovery"

data/lib/tangany/custody/resource.rb

@@ -0,0 +1,29 @@
+module Tangany
+  module Custody
+    class Resource < Tangany::Resource
+      def initialize(client, options = {})
+        @chain = Tangany.chains.find { |chain| chain["asset_id"] == options[:asset_id] } if options[:asset_id]
+
+        super(client)
+      end
+
+      private
+
+      def default_headers
+        headers = {
+          "tangany-client-id" => client.client_id,
+          "tangany-client-secret" => client.client_secret,
+          "tangany-subscription" => client.subscription,
+          "tangany-vault-url" => client.vault_url
+        }
+        merge_chain_header(headers) if @chain
+        headers
+      end
+
+      def merge_chain_header(headers)
+        header = @chain["header"]
+        headers.merge(header["name"] => header[Tangany.environment])
+      end
+    end
+  end
+end

data/lib/tangany/custody/resources/wallet_statuses_resource.rb

@@ -0,0 +1,9 @@
+module Tangany
+  module Custody
+    class WalletStatusesResource < Resource
+      def retrieve(wallet_id)
+        WalletStatus.new(get_request("#{@chain["base_path"]}/wallet/#{wallet_id}").body)
+      end
+    end
+  end
+end

data/lib/tangany/custody/resources/wallets_resource.rb

@@ -0,0 +1,34 @@
+module Tangany
+  module Custody
+    class WalletsResource < Resource
+      def create(**params)
+        Wallet.new(post_request("wallets", body: sanitize_params!(params).to_json).body)
+      end
+
+      def delete(wallet_id)
+        WalletRecovery.new(delete_request("wallet/#{wallet_id}").body)
+      end
+
+      def list(**params)
+        Collection.from_response(get_request("wallets", params: sanitize_params!(params)), type: Wallet)
+      end
+
+      def retrieve(wallet_id)
+        Wallet.new(get_request("wallet/#{wallet_id}").body)
+      end
+
+      def update(wallet_id, **params)
+        safe_params = sanitize_params!(params)
+
+        retrieve_response = get_request("wallet/#{wallet_id}")
+        wallet = Wallet.new(retrieve_response.body)
+
+        Wallet.new(patch_request(
+          "wallet/#{wallet_id}",
+          body: build_update_body_json(wallet.to_h, safe_params),
+          headers: {"If-Match" => retrieve_response.headers["If-Match"]}
+        ).body)
+      end
+    end
+  end
+end

data/lib/tangany/custody/resources.rb

@@ -0,0 +1,2 @@
+require_relative "resources/wallet_statuses_resource"
+require_relative "resources/wallets_resource"

data/lib/tangany/custody.rb

@@ -0,0 +1,7 @@
+require_relative "custody/client"
+require_relative "custody/collection"
+require_relative "custody/resource"
+
+require_relative "custody/contracts"
+require_relative "custody/objects"
+require_relative "custody/resources"

data/lib/tangany/customers/application_contract.rb

@@ -0,0 +1,6 @@
+module Tangany
+  module Customers
+    class ApplicationContract < Tangany::ApplicationContract
+    end
+  end
+end

data/lib/tangany/customers/client.rb

@@ -0,0 +1,37 @@
+require "faraday"
+
+module Tangany
+  module Customers
+    class Client
+      attr_reader :adapter, :subscription
+
+      def initialize(adapter: Faraday.default_adapter, stubs: nil)
+        @adapter = adapter
+        @subscription = Tangany.subscription
+
+        @stubs = stubs
+      end
+
+      def connection
+        @connection ||= Faraday.new do |faraday|
+          faraday.adapter(adapter, @stubs)
+          faraday.request(:json)
+          faraday.response(:json, content_type: /\bjson$/, parser_options: {symbolize_names: true})
+          faraday.url_prefix = Tangany.customers_base_url
+        end
+      end
+
+      def customers
+        CustomersResource.new(self)
+      end
+
+      def natural_persons
+        NaturalPersonsResource.new(self)
+      end
+
+      def wallet_links
+        WalletLinksResource.new(self)
+      end
+    end
+  end
+end

data/lib/tangany/customers/collection.rb

@@ -0,0 +1,16 @@
+module Tangany
+  module Customers
+    class Collection
+      class << self
+        def from_response(response, type:)
+          body = response.body
+          Tangany::Collection.new(
+            data: body[:items].map { |attributes| type.new(attributes) },
+            total: body.dig(:pageInfo, :totalResults),
+            next_page_token: body[:nextPageToken]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tangany/customers/contracts/customers/create.rb

@@ -0,0 +1,17 @@
+require_relative "create_schemas/customer"
+
+module Tangany
+  module Customers
+    module Contracts
+      module Customers
+        class Create < ApplicationContract
+          schema(CreateSchemas::Customer.schema) { config.validate_keys = true }
+
+          rule(:contracts) do
+            key.failure("must contain at least one contract") if value.size == 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tangany/customers/contracts/customers/create_schemas/contract.rb

@@ -0,0 +1,21 @@
+module Tangany
+  module Customers
+    module Contracts
+      module Customers
+        module CreateSchemas
+          module Contract
+            class << self
+              def schema
+                Dry::Schema.Params do
+                  required(:type).filled(:string, included_in?: Tangany::Customers::Contract::ALLOWED_TYPES)
+                  required(:signedDate).filled(:string, format?: ApplicationContract::DATE_REGEX)
+                  optional(:cancelledDate).maybe(:string, format?: ApplicationContract::DATE_REGEX)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tangany/customers/contracts/customers/create_schemas/customer.rb

@@ -0,0 +1,34 @@
+require_relative "contract"
+
+module Tangany
+  module Customers
+    module Contracts
+      module Customers
+        module CreateSchemas
+          module Customer
+            module ClassMethods
+              def schema
+                Dry::Schema.Params do
+                  required(:id).filled(:string, max_size?: 40)
+                  required(:owner).hash do
+                    required(:entityId).filled(:string)
+                  end
+                  required(:authorized).array(:hash) do
+                    required(:entityId).filled(:string)
+                  end
+                  required(:contracts).array(CreateSchemas::Contract.schema)
+                end
+              end
+            end
+
+            extend ClassMethods
+
+            def self.included(base)
+              base.extend(ClassMethods)
+            end
+          end
+        end
+      end
+    end
+  end
+end