synapseruby 1.0.8 → 1.0.9

data/lib/synapse_api/http_request.rb

@@ -10,20 +10,20 @@ module Synapse
 		#   @return [String] the base url of the API (production or sandbox)
 		# @!attribute [rw] config
 		#   @return [Hash] various settings related to request headers
-    # @!attribute [rw] raise_for_202
-    #   @return [Boolean] relating to how to handle 202 exception
+        # @!attribute [rw] raise_for_202
+        #   @return [Boolean] relating to how to handle 202 exception
 		attr_accessor :base_url, :config, :raise_for_202
 
 		# @param base_url [String] the base url of the API (production or sandbox)
-  	# @param client_id [String]
-  	# @param client_secret [String]
-  	# @param fingerprint [String]
-  	# @param ip_address [String]
-    # @param raise_for_202 [String]
-  	# @param logging [Boolean] (optional) logs to stdout when true
-  	# @param log_to [String] (optional) file path to log to file (logging must be true)
+      	# @param client_id [String]
+      	# @param client_secret [String]
+      	# @param fingerprint [String]
+      	# @param ip_address [String]
+        # @param raise_for_202 [String]
+      	# @param logging [Boolean] (optional) logs to stdout when true
+      	# @param log_to [String] (optional) file path to log to file (logging must be true)
 		def initialize(base_url:, client_id:, client_secret:, fingerprint:, ip_address:, raise_for_202:false, **options)
-      @raise_for_202 = raise_for_202
+            @raise_for_202 = raise_for_202
 			log_to         = options[:log_to] || 'stdout'
 			RestClient.log = log_to if options[:logging]
 			@logging       = options[:logging]
@@ -39,7 +39,7 @@ module Synapse
 		end
 
 		# Returns headers for HTTP requests.
-	  # @return [Hash]
+	    # @return [Hash]
 		def headers
 			user    = "#{config[:oauth_key]}|#{config[:fingerprint]}"
 			gateway = "#{config[:client_id]}|#{config[:client_secret]}"
@@ -50,30 +50,30 @@ module Synapse
 			    'X-SP-USER'    => user,
 			    'X-SP-USER-IP' => config[:ip_address],
 			}
-      if config[:idemopotency_key]
-        headers['X-SP-IDEMPOTENCY-KEY'] = config[:idemopotency_key]
-      end
-      headers
+            if config[:idemopotency_key]
+                headers['X-SP-IDEMPOTENCY-KEY'] = config[:idemopotency_key]
+            end
+            headers
 		end
 
 		# Alias for headers (copy of current headers)
 		alias_method :get_headers, :headers
 
 		# Updates current HTPP headers
-    # @param fingerprint [String]
-    # @param oauth_key [String]
-    # @param fingerprint [String]
-    # @param client_id [String]
-    # @param client_secret [String]
-    # @param ip_address [String]
-    # @param idemopotency_key [String]
+        # @param fingerprint [String]
+        # @param oauth_key [String]
+        # @param fingerprint [String]
+        # @param client_id [String]
+        # @param client_secret [String]
+        # @param ip_address [String]
+        # @param idemopotency_key [String]
 		def update_headers(oauth_key: nil, fingerprint: nil, client_id: nil, client_secret: nil, ip_address: nil, idemopotency_key: nil)
 			config[:fingerprint]   = fingerprint if fingerprint
 			config[:oauth_key]     = oauth_key if oauth_key
 			config[:client_id]     = client_id if client_id
 			config[:client_secret] = client_secret if client_secret
 			config[:ip_address]    = ip_address if ip_address
-      config[:idemopotency_key] = idemopotency_key if idemopotency_key
+            config[:idemopotency_key] = idemopotency_key if idemopotency_key
 			nil
 		end
 
@@ -81,36 +81,36 @@ module Synapse
 		# @param path [String]
 		# @param payload [HASH]
 		# @param **options payload = idempotency_key [String] (optional) avoid accidentally performing the same operation twice
-	  # @return [Hash] API response
-    # @raise [Synapse::Error] subclass depends on HTTP response
-    def post(path, payload, **options)
-    	#copy of current headers
-    	headers = get_headers
-
-    	# update the headers with idempotency_key
-    	if options[:idempotency_key]
-    		headers = headers.merge({'X-SP-IDEMPOTENCY-KEY' => options[:idempotency_key]})
-    	end
-
-    	response = with_error_handling { RestClient::Request.execute(:method =>  :post,
+	    # @return [Hash] API response
+        # @raise [Synapse::Error] subclass depends on HTTP response
+        def post(path, payload, **options)
+            #copy of current headers
+            headers = get_headers
+
+            # update the headers with idempotency_key
+            if options[:idempotency_key]
+                headers = headers.merge({'X-SP-IDEMPOTENCY-KEY' => options[:idempotency_key]})
+            end
+
+    	    response = with_error_handling { RestClient::Request.execute(:method =>  :post,
                                                                    :url =>     full_url(path),
                                                                    :payload => payload.to_json,
                                                                    :headers => headers,
                                                                    :timeout => 300
                                                                    ) }
-    	puts 'RESPONSE:', JSON.parse(response) if @logging
-    	response = JSON.parse(response)
-
-      if raise_for_202 && response["http_code"] == "202"
-        raise Error.from_response(response)
-      elsif response["error"]
-        raise Error.from_response(response)
-      else
-        response
-      end
-    end
-
-    # Sends a GET request to the given path with the given payload.
+    	    puts 'RESPONSE:', JSON.parse(response) if @logging
+    	    response = JSON.parse(response)
+
+            if raise_for_202 && response["http_code"] == "202"
+                raise Error.from_response(response)
+            elsif response["error"]
+                raise Error.from_response(response)
+            else
+                response
+            end
+         end
+
+        # Sends a GET request to the given path with the given payload.
 		# @param path [String]
 		# @return [Hash] API response
 		# @raise [Synapse::Error] subclass depends on HTTP response
@@ -119,38 +119,38 @@ module Synapse
 			puts 'RESPONSE:', JSON.parse(response) if @logging
 			response = JSON.parse(response)
 
-      if raise_for_202 && response["http_code"] == "202"
-        raise Error.from_response(response)
-      elsif response["error"]
-        raise Error.from_response(response)
-      else
-        response
-      end
+            if raise_for_202 && response["http_code"] == "202"
+                raise Error.from_response(response)
+            elsif response["error"]
+                raise Error.from_response(response)
+            else
+                response
+            end
 		end
 
-    # Sends a DELETE request to the given path
-    # @param path [String]
-    # @return [Hash] API response
-    # @raise [Synapse::Error] subclass depends on HTTP response
-    def delete(path)
-      response = with_error_handling {RestClient.delete(full_url(path), headers)}
-      puts 'RESPONSE:', JSON.parse(response) if @logging
-      response = JSON.parse(response)
-
-      if raise_for_202 && response["http_code"] == "202"
-        raise Error.from_response(response)
-      elsif response["error"]
-        raise Error.from_response(response)
-      else
-        response
-      end
-    end
+        # Sends a DELETE request to the given path
+        # @param path [String]
+        # @return [Hash] API response
+        # @raise [Synapse::Error] subclass depends on HTTP response
+        def delete(path)
+            response = with_error_handling {RestClient.delete(full_url(path), headers)}
+            puts 'RESPONSE:', JSON.parse(response) if @logging
+            response = JSON.parse(response)
+
+            if raise_for_202 && response["http_code"] == "202"
+                raise Error.from_response(response)
+            elsif response["error"]
+                raise Error.from_response(response)
+            else
+                response
+            end
+        end
 
 		# Sends a PATCH request to the given path with the given payload.
-    # @param path [String]
-    # @param payload [Hash]
-    # @return [Hash] API response
-    # @raise [Synapse::Error] subclass depends on HTTP response
+        # @param path [String]
+        # @param payload [Hash]
+        # @return [Hash] API response
+        # @raise [Synapse::Error] subclass depends on HTTP response
 		def patch(path, payload)
 			response = with_error_handling {RestClient::Request.execute(:method =>  :patch,
                                                                   :url =>     full_url(path),
@@ -161,75 +161,75 @@ module Synapse
 			p 'RESPONSE:', JSON.parse(response) if @logging
 			response = JSON.parse(response)
 
-      if raise_for_202 && response["http_code"] == "202"
-        raise Error.from_response(response)
-      elsif response["error"]
-        raise Error.from_response(response)
-      else
-        response
-      end
+            if raise_for_202 && response["http_code"] == "202"
+                raise Error.from_response(response)
+            elsif response["error"]
+                raise Error.from_response(response)
+            else
+                response
+            end
 		end
 
-    def oauthenticate(user_id:)
-      refresh_token = refresh_token(user_id: user_id)
-    end
+        def oauthenticate(user_id:)
+            refresh_token = refresh_token(user_id: user_id)
+        end
 
 		private
 
-    # get user
-    # get refresh_token
-    # send refresh_token to oauth path
-    # grabs the refresh token and formats a refresh token payload
-    def refresh_token(user_id:)
-      path = "/users/#{user_id}"
-      response = get(path)
-      refresh_token = response["refresh_token"]
-
-      refresh_token = {"refresh_token" => refresh_token}
-      oauth_path = oauth_path(user_id)
-      authenticate(refresh_token, oauth_path)
-    end
-
-    # options payload to change scope of oauth
-    def authenticate(refresh_token, oauth_path)
-      oauth_key = post(oauth_path, refresh_token)
-      oauth_key = oauth_key['oauth_key']
-      update_headers(oauth_key: oauth_key)
-      nil
-    end
-
-    def oauth_path(user_id)
-      "/oauth/#{user_id}"
-    end
+        # get user
+        # get refresh_token
+        # send refresh_token to oauth path
+        # grabs the refresh token and formats a refresh token payload
+        def refresh_token(user_id:)
+            path = "/users/#{user_id}"
+            response = get(path)
+            refresh_token = response["refresh_token"]
+
+            refresh_token = {"refresh_token" => refresh_token}
+            oauth_path = oauth_path(user_id)
+            authenticate(refresh_token, oauth_path)
+        end
+
+        # options payload to change scope of oauth
+        def authenticate(refresh_token, oauth_path)
+            oauth_key = post(oauth_path, refresh_token)
+            oauth_key = oauth_key['oauth_key']
+            update_headers(oauth_key: oauth_key)
+            nil
+        end
+
+        def oauth_path(user_id)
+            "/oauth/#{user_id}"
+        end
 
 		def full_url(path)
-		  "#{base_url}#{path}"
+            "#{base_url}#{path}"
 		end
 
-    # raising an exception based on http_request
-    # yeilds if http_request raises an exception
+        # raising an exception based on http_request
+        # yeilds if http_request raises an exception
 		def with_error_handling
 			yield
-		rescue RestClient::Exceptions::Timeout
-			body = {
-				error: {
-					en: "Request Timeout"
-				},
-				http_code: 504
-			}
-			raise Error.from_response(body)
-		rescue RestClient::Exception => e
-			if e.response.headers[:content_type] == 'application/json'
-				body = JSON.parse(e.response.body)
-			else
-				body = {
-					error: {
-						en: e.response.body
-					},
-					http_code: e.response.code
-				}
-			end
-			raise Error.from_response(body)
+		    rescue RestClient::Exceptions::Timeout
+    			body = {
+    				error: {
+    					en: "Request Timeout"
+    				},
+    				http_code: 504
+    			}
+			    raise Error.from_response(body)
+		    rescue RestClient::Exception => e
+                if e.response.headers[:content_type] == 'application/json'
+                    body = JSON.parse(e.response.body)
+                else
+    				body = {
+    					error: {
+    						en: e.response.body
+    					},
+    					http_code: e.response.code
+    				}
+			    end
+			   raise Error.from_response(body)
 		end
 	end
 end

data/lib/synapse_api/user.rb

@@ -1,20 +1,20 @@
 module Synapse
-  # Wrapper class for /users endpoints
+    # Wrapper class for /users endpoints
 	class User
 
 		# Valid optional args for #get
-    VALID_QUERY_PARAMS = [:query, :page, :per_page, :type, :full_dehydrate, :ship, :force_refresh, :is_credit,
-                          :subnetid, :foreign_transaction,].freeze
+        VALID_QUERY_PARAMS = [:query, :page, :per_page, :type, :full_dehydrate, :ship, :force_refresh, :is_credit,
+                          :subnetid, :foreign_transaction,:amount].freeze
 
 		attr_accessor :client, :user_id,:refresh_token, :oauth_key, :expires_in, :payload, :full_dehydrate
 
-    # @param user_id [String]
-    # @param refresh_token [String]
-    # @param client [Synapse::HTTPClient]
-    # @param payload [Hash]
-    # @param full_dehydrate [Boolean]
+        # @param user_id [String]
+        # @param refresh_token [String]
+        # @param client [Synapse::HTTPClient]
+        # @param payload [Hash]
+        # @param full_dehydrate [Boolean]
 		def initialize(user_id:,refresh_token:, client:,payload:, full_dehydrate:)
-      @user_id = user_id
+            @user_id = user_id
 			@client = client
 			@refresh_token = refresh_token
 			@payload =payload
@@ -23,63 +23,62 @@ module Synapse
 
 		# Updates users documents
 		# @see https://docs.synapsefi.com/docs/updating-existing-document
-    # @param payload [Hash]
-    # @return [Synapse::User]
+        # @param payload [Hash]
+        # @return [Synapse::User]
 		def user_update(payload:)
-      path = get_user_path(user_id: self.user_id)
-     begin
-       response = client.patch(path, payload)
-     rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       response =client.patch(path, payload)
-     end
-		 User.new(user_id:        response['_id'],
-              refresh_token:  response['refresh_token'],
-              client:         client,
-              full_dehydrate: false,
-              payload:        response
-              )
+            path = get_user_path(user_id: self.user_id)
+            begin
+                response = client.patch(path, payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response =client.patch(path, payload)
+            end
+    		User.new(user_id:        response['_id'],
+                  refresh_token:  response['refresh_token'],
+                  client:         client,
+                  full_dehydrate: false,
+                  payload:        response
+                  )
 		end
 
-    # Queries the API for a node belonging to user
-    # @param node_id [String]
-    # @param full_dehydrate [String] (optional)
-    #   if true, returns all trans data on node
-    # @param force_refresh [String] (optional) if true, force refresh
-    #  will attempt updating the account balance and transactions on node
-    # @return [Synapse::Node]
-    def get_user_node(node_id:, **options)
-      options[:full_dehydrate] = "yes" if options[:full_dehydrate] == true
-      options[:full_dehydrate] = "no" if options[:full_dehydrate] == false
-      options[:force_refresh] = "yes" if options[:force_refresh] == true
-      options[:force_refresh] = "no" if options[:force_refresh] == false
-
-      path = node(node_id:        node_id,
+        # Queries the API for a node belonging to user
+        # @param node_id [String]
+        # @param full_dehydrate [String] (optional)
+        #   if true, returns all trans data on node
+        # @param force_refresh [String] (optional) if true, force refresh
+        #  will attempt updating the account balance and transactions on node
+        # @return [Synapse::Node]
+        def get_user_node(node_id:, **options)
+            options[:full_dehydrate] = "yes" if options[:full_dehydrate] == true
+            options[:full_dehydrate] = "no" if options[:full_dehydrate] == false
+            options[:force_refresh] = "yes" if options[:force_refresh] == true
+            options[:force_refresh] = "no" if options[:force_refresh] == false
+
+            path = node(node_id:        node_id,
                   full_dehydrate: options[:full_dehydrate],
                   force_refresh:  options[:force_refresh] )
 
-      begin
-        node = client.get(path)
-      rescue Synapse::Error::Unauthorized
+            begin
+                node = client.get(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                node = client.get(path)
+            end
 
-        self.authenticate()
-        node = client.get(path)
-      end
-
-      node = Node.new(node_id: node['_id'],
+            node = Node.new(node_id: node['_id'],
                       user_id: self.user_id,
                       payload: node,
                       full_dehydrate: options[:full_dehydrate] == "yes" ? true : false,
                       type: node["type"]
                       )
-    end
-
-    # Queries Synapse API for all nodes belonging to user
-    # @param page [String,Integer] (optional) response will default to 1
-    # @param per_page [String,Integer] (optional) response will default to 20
-    # @param type [String] (optional)
-    # @see https://docs.synapsepay.com/docs/node-resources node types
-    # @return [Array<Synapse::Nodes>]
+        end
+
+        # Queries Synapse API for all nodes belonging to user
+        # @param page [String,Integer] (optional) response will default to 1
+        # @param per_page [String,Integer] (optional) response will default to 20
+        # @param type [String] (optional)
+        # @see https://docs.synapsepay.com/docs/node-resources node types
+        # @return [Array<Synapse::Nodes>]
 		def get_all_user_nodes(**options)
 			[options[:page], options[:per_page]].each do |arg|
 				if arg && (!arg.is_a?(Integer) || arg < 1)
@@ -88,19 +87,19 @@ module Synapse
 			end
 			path = get_user_path(user_id: self.user_id) + nodes_path(options)
 
-      begin
-       nodes = client.get(path)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       nodes = client.get(path)
-      end
+            begin
+                nodes = client.get(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                nodes = client.get(path)
+            end
 
 			return [] if nodes["nodes"].empty?
 			response = nodes["nodes"].map { |node_data| Node.new(node_id: node_data['_id'],
                                                            user_id: node_data['user_id'],
                                                            payload: node_data, full_dehydrate: "no",
                                                            type: node_data["type"])}
-      nodes = Nodes.new(limit: nodes["limit"],
+            nodes = Nodes.new(limit: nodes["limit"],
                         page: nodes["page"],
                         page_count: nodes["page_count"],
                         nodes_count: nodes["node_count"],
@@ -109,636 +108,641 @@ module Synapse
 
 		# Quaries Synapse oauth API for uto authenitcate user
 		# @params scope [Array<Strings>] (optional)
-    # @param idempotency_key [String] (optional)
-    # @see https://docs.synapsefi.com/docs/get-oauth_key-refresh-token
+        # @param idempotency_key [String] (optional)
+        # @see https://docs.synapsefi.com/docs/get-oauth_key-refresh-token
 		def authenticate(**options)
-      payload = {
-        "refresh_token" => self.refresh_token
-      }
-      payload["scope"] = options[:scope] if options[:scope]
+            payload = {
+                "refresh_token" => self.refresh_token
+              }
+            payload["scope"] = options[:scope] if options[:scope]
 
-      path = oauth_path()
+            path = oauth_path()
 
 			oauth_response = client.post(path, payload,options)
-      oauth_key = oauth_response['oauth_key']
-      oauth_expires = oauth_response['expires_in']
-      self.oauth_key = oauth_key
-      self.expires_in = oauth_expires
-      client.update_headers(oauth_key: oauth_key)
+            oauth_key = oauth_response['oauth_key']
+            oauth_expires = oauth_response['expires_in']
+            self.oauth_key = oauth_key
+            self.expires_in = oauth_expires
+            client.update_headers(oauth_key: oauth_key)
 
-      oauth_response
+            oauth_response
 		end
 
-    # For registering new fingerprint
-    # Supply 2FA device which pin should be sent to
-    # @param device [String]
-    # @param idempotency_key [String] (optional)
-    # @see https://docs.synapsefi.com/docs/get-oauth_key-refresh-token
-    # @return API response [Hash]
-    def select_2fa_device(device:, **options)
-      payload = {
+        # For registering new fingerprint
+        # Supply 2FA device which pin should be sent to
+        # @param device [String]
+        # @param idempotency_key [String] (optional)
+        # @see https://docs.synapsefi.com/docs/get-oauth_key-refresh-token
+        # @return API response [Hash]
+        def select_2fa_device(device:, **options)
+            payload = {
                  "refresh_token": self.refresh_token,
                  "phone_number": device
                 }
-      path = oauth_path()
-      device_response = client.post(path, payload, options)
-      device_response
-    end
-
-    # Supply pin for 2FA confirmation
-    # @param pin [String]
-    # @param idempotency_key [String] (optional)
-    # @param scope [Array] (optional)
-    # @see https://docs.synapsefi.com/docs/get-oauth_key-refresh-token
-    # @return API response [Hash]
-    def confirm_2fa_pin(pin:, **options)
-      payload = {
-                "refresh_token": self.refresh_token,
-                "validation_pin": pin
-                }
+            path = oauth_path()
+            device_response = client.post(path, payload, options)
+            device_response
+        end
 
-      payload["scope"] = options[:scope] if options[:scope]
-
-      path = oauth_path()
-
-      pin_response = client.post(path, payload, options)
-      oauth_key = pin_response['oauth_key']
-      oauth_expires = pin_response['expires_in']
-      self.oauth_key = oauth_key
-      self.expires_in = oauth_expires
-      client.update_headers(oauth_key: oauth_key)
-
-      pin_response
-    end
-
-	  # Queries the Synapse API to get all transactions belonging to a user
-    # @return [Array<Synapse::Transactions>]
-    # @param page [Integer] (optional) response will default to 1
-    # @param per_page [Integer] (optional) response will default to 20
-    def get_user_transactions(**options)
-  		[options[:page], options[:per_page]].each do |arg|
-  			if arg && (!arg.is_a?(Integer) || arg < 1)
-  				raise ArgumentError, "#{arg} must be nil or an Integer >= 1"
-  			end
-  		end
-
-      path = transactions_path(user_id: self.user_id, options: options)
-
-      begin
-        trans = client.get(path)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        trans = client.get(path)
-      end
-
-
-      response = trans["trans"].map { |trans_data| Transaction.new(trans_id: trans_data['_id'],
-                                                                   payload:  trans_data
-                                                                   )}
-      trans = Transactions.new(limit:       trans["limit"],
-                               page:        trans["page"],
-                               page_count:  trans["page_count"],
-                               trans_count: trans["trans_count"],
-                               payload:     response
-                               )
-
-    	trans
-    end
-
-    # Creates Synapse node
-    # @note Types of nodes [Card, IB/Deposit-US, Check/Wire Instructions]
-    # @param payload [Hash]
-    # @param idempotency_key [String] (optional)
-    # @see https://docs.synapsefi.com/docs/node-resources
-    # @return [Synapse::Node] or [Hash]
+        # Supply pin for 2FA confirmation
+        # @param pin [String]
+        # @param idempotency_key [String] (optional)
+        # @param scope [Array] (optional)
+        # @see https://docs.synapsefi.com/docs/get-oauth_key-refresh-token
+        # @return API response [Hash]
+        def confirm_2fa_pin(pin:, **options)
+            payload = {
+                        "refresh_token": self.refresh_token,
+                        "validation_pin": pin
+                        }
+
+            payload["scope"] = options[:scope] if options[:scope]
+
+            path = oauth_path()
+
+            pin_response = client.post(path, payload, options)
+            oauth_key = pin_response['oauth_key']
+            oauth_expires = pin_response['expires_in']
+            self.oauth_key = oauth_key
+            self.expires_in = oauth_expires
+            client.update_headers(oauth_key: oauth_key)
+
+            pin_response
+        end
+
+	    # Queries the Synapse API to get all transactions belonging to a user
+        # @return [Array<Synapse::Transactions>]
+        # @param page [Integer] (optional) response will default to 1
+        # @param per_page [Integer] (optional) response will default to 20
+        def get_user_transactions(**options)
+      		[options[:page], options[:per_page]].each do |arg|
+      			if arg && (!arg.is_a?(Integer) || arg < 1)
+      				raise ArgumentError, "#{arg} must be nil or an Integer >= 1"
+      			end
+      		end
+
+            path = transactions_path(user_id: self.user_id, options: options)
+
+            begin
+                trans = client.get(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                trans = client.get(path)
+            end
+
+
+            response = trans["trans"].map { |trans_data| Transaction.new(trans_id: trans_data['_id'],
+                                                                       payload:  trans_data
+                                                                       )}
+            trans = Transactions.new(limit:       trans["limit"],
+                                   page:        trans["page"],
+                                   page_count:  trans["page_count"],
+                                   trans_count: trans["trans_count"],
+                                   payload:     response
+                                   )
+
+        	trans
+        end
+
+        # Creates Synapse node
+        # @note Types of nodes [Card, IB/Deposit-US, Check/Wire Instructions]
+        # @param payload [Hash]
+        # @param idempotency_key [String] (optional)
+        # @see https://docs.synapsefi.com/docs/node-resources
+        # @return [Synapse::Node] or [Hash]
 		def create_node(payload:, **options)
 			path = get_user_path(user_id: self.user_id)
 			path = path + nodes_path
 
-      begin
-        response = client.post(path,payload, options)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        response = client.post(path,payload, options)
-      end
+            begin
+                response = client.post(path,payload, options)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.post(path,payload, options)
+            end
 
-      if response["nodes"]
-        nodes = response["nodes"].map { |nodes_data| Node.new(user_id:        self.user_id,
+            if response["nodes"]
+                nodes = response["nodes"].map { |nodes_data| Node.new(user_id:        self.user_id,
                                                               node_id:        nodes_data["_id"],
                                                               full_dehydrate: false,
                                                               payload:        response,
                                                               type:           nodes_data["type"]
                                                               )}
-        nodes = Nodes.new(page:        response["page"],
+                nodes = Nodes.new(page:        response["page"],
                           limit:       response["limit"],
                           page_count:  response["page_count"],
                           nodes_count: response["node_count"],
                           payload:     nodes
                           )
-      else
-        access_token = response
-      end
-      access_token ? access_token : nodes
+            else
+                access_token = response
+            end
+            access_token ? access_token : nodes
 		end
 
-    # Submit answer to a MFA question using access token from bank login attempt
-    # @return [Synapse::Node] or [Hash]
-    # @param payload [Hash]
-    # @param idempotency_key [String] (optional)
-    # @see https://docs.synapsefi.com/docs/add-ach-us-node-via-bank-logins-mfa
-    # Please be sure to call ach_mfa again if you have more security questions
-    def ach_mfa(payload:, **options)
-      path = get_user_path(user_id: self.user_id)
-      path = path + nodes_path
-
-      begin
-        response = client.post(path,payload, options)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        response = client.post(path,payload, options)
-      end
-
-      if response["nodes"]
-        nodes = response["nodes"].map { |nodes_data| Node.new(user_id:        self.user_id,
-                                                              node_id:        nodes_data["_id"],
-                                                              full_dehydrate: false,
-                                                              payload:        response,
-                                                              type:           nodes_data["type"]
-                                                              )}
-        nodes = Nodes.new(page:        response["page"],
-                          limit:       response["limit"],
-                          page_count:  response["page_count"],
-                          nodes_count: response["node_count"],
-                          payload:     nodes
-                          )
-      else
-        access_token = response
-      end
-      access_token ? access_token : nodes
-    end
-
-    # Allows you to upload an Ultimate Beneficial Ownership document
-    # @param payload [Hash]
-    # @see https://docs.synapsefi.com/docs/generate-ubo-form
-    # @return API response
-    def create_ubo(payload:)
-      path = get_user_path(user_id: self.user_id)
-      path = path + nodes_path + "/ubo"
-
-      begin
-       response = client.patch(path,payload)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       response = client.patch(path,payload)
-      end
-      response
-    end
-
-    # Gets user statement
-    # @param page [Integer]
-    # @param per_page [Integer]
-    # @see https://docs.synapsefi.com/docs/statements-by-user
-    # @return API response
-    def get_user_statement(**options)
-      path = get_user_path(user_id: self.user_id) + "/statements"
-      params = VALID_QUERY_PARAMS.map do |p|
-        options[p] ? "#{p}=#{options[p]}" : nil
-      end.compact
-      path += '?' + params.join('&') if params.any?
-
-      begin
-       statements = client.get(path)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       statements = client.get(path)
-      end
-      statements
-    end
-
-    # Request to ship CARD-US
-    # @note Deprecated
-    # @param node_id [String]
-    # @param payload [Hash]
-    # @return [Synapse::Node] or [Hash]
-    def ship_card_node(node_id:, payload:)
-
-      path = node(user_id: self.user_id, node_id: node_id) + "?ship=YES"
-
-      begin
-       response = client.patch(path,payload)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       response = client.patch(path,payload)
-      end
-      Node.new(user_id:        self.user_id,
+        # Submit answer to a MFA question using access token from bank login attempt
+        # @return [Synapse::Node] or [Hash]
+        # @param payload [Hash]
+        # @param idempotency_key [String] (optional)
+        # @see https://docs.synapsefi.com/docs/add-ach-us-node-via-bank-logins-mfa
+        # Please be sure to call ach_mfa again if you have more security questions
+        def ach_mfa(payload:, **options)
+            path = get_user_path(user_id: self.user_id)
+            path = path + nodes_path
+
+            begin
+                response = client.post(path,payload, options)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.post(path,payload, options)
+            end
+
+            if response["nodes"]
+                nodes = response["nodes"].map { |nodes_data| Node.new(user_id:        self.user_id,
+                                                                      node_id:        nodes_data["_id"],
+                                                                      full_dehydrate: false,
+                                                                      payload:        response,
+                                                                      type:           nodes_data["type"]
+                                                                      )}
+                nodes = Nodes.new(page:        response["page"],
+                                  limit:       response["limit"],
+                                  page_count:  response["page_count"],
+                                  nodes_count: response["node_count"],
+                                  payload:     nodes
+                                  )
+            else
+                access_token = response
+            end
+            access_token ? access_token : nodes
+        end
+
+        # Allows you to upload an Ultimate Beneficial Ownership document
+        # @param payload [Hash]
+        # @see https://docs.synapsefi.com/docs/generate-ubo-form
+        # @return API response
+        def create_ubo(payload:)
+            path = get_user_path(user_id: self.user_id)
+            path = path + nodes_path + "/ubo"
+
+            begin
+                response = client.patch(path,payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.patch(path,payload)
+            end
+            response
+        end
+
+        # Gets user statement
+        # @param page [Integer]
+        # @param per_page [Integer]
+        # @see https://docs.synapsefi.com/docs/statements-by-user
+        # @return API response
+        def get_user_statement(**options)
+            path = get_user_path(user_id: self.user_id) + "/statements"
+            params = VALID_QUERY_PARAMS.map do |p|
+                options[p] ? "#{p}=#{options[p]}" : nil
+            end.compact
+
+            path += '?' + params.join('&') if params.any?
+
+            begin
+                statements = client.get(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                statements = client.get(path)
+            end
+          statements
+        end
+
+        # Request to ship CARD-US
+        # @note Deprecated
+        # @param node_id [String]
+        # @param payload [Hash]
+        # @return [Synapse::Node] or [Hash]
+        def ship_card_node(node_id:, payload:)
+            path = node(user_id: self.user_id, node_id: node_id) + "?ship=YES"
+            begin
+                response = client.patch(path,payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.patch(path,payload)
+            end
+            Node.new(user_id:        self.user_id,
                node_id:        response["_id"],
                full_dehydrate: false,
                payload:        response,
                type:           response["type"])
-    end
-
-    # Request to ship user debit card [Subnet]
-    # @param node_id [String]
-    # @param payload [Hash]
-    # @param subnet_id [String]
-    # @return [Synapse::Node] or [Hash]
-    def ship_card(node_id:, payload:, subnet_id:)
-
-      path = node(user_id: self.user_id, node_id: node_id) + "/subnets/#{subnet_id}/ship"
-
-      begin
-       response = client.patch(path,payload)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       response = client.patch(path,payload)
-      end
-      Subnet.new(subnet_id: response["subnet_id"], payload: response, node_id: response["node_id"])
-
-    end
-
-    # Resets debit card number, cvv, and expiration date
-    # @note Deprecated
-    # @see https://docs.synapsefi.com/docs/reset-debit-card
-    # @param node_id [String]
-    # @return [Synapse::Node] or [Hash]
-    def reset_card_node(node_id:)
-      path = node(user_id: self.user_id, node_id: node_id)  + "?reset=YES"
-      payload = {}
-      begin
-       response = client.patch(path,payload)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       response = client.patch(path,payload)
-      end
-      Node.new(user_id: self.user_id,
-               node_id:response["_id"],
-               full_dehydrate: false,
-               payload: response,
-               type: response["type"]
-               )
-    end
-
-    # Creates a new transaction in the API belonging to the provided node
-    # @param node_id [String]
-    # @param payload [Hash]
-    # @param idempotency_key [String] (optional)
-    # @return [Synapse::Transaction]
-    def create_transaction(node_id: ,payload:, **options)
-      path = trans_path(user_id: self.user_id, node_id: node_id)
-
-      begin
-       transaction = client.post(path,payload, options)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       transaction = client.post(path,payload, options)
-      end
-      transaction = Transaction.new(trans_id: transaction['_id'],
-                                    payload:  transaction,
-                                    node_id:  node_id
-                                    )
-    end
-
-    # Queries the API for a transaction belonging to the supplied node by transaction id
-    # @param node_id [String]
-    # @param trans_id [String] id of the transaction to find
-    # @return [Synapse::Transaction]
-    def get_node_transaction(node_id:, trans_id:)
-      path = node(user_id: self.user_id, node_id: node_id) + "/trans/#{trans_id}"
-
-      begin
-        trans = client.get(path)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        trans = client.get(path)
-      end
-      Transaction.new(trans_id: trans['_id'],
-                      payload:  trans,
-                      node_id:  node_id
-                     )
-    end
-
-
-    # Queries the API for all transactions belonging to the supplied node
-    # @param node_id [String] node to which the transaction belongs
-    # @param page [Integer] (optional) response will default to 1
-    # @param per_page [Integer] (optional) response will default to 20
-    # @return [Array<Synapse::Transaction>]
-    def get_all_node_transaction(node_id:, **options)
-      [options[:page], options[:per_page]].each do |arg|
-        if arg && (!arg.is_a?(Integer) || arg < 1)
-          raise ArgumentError, "#{arg} must be nil or an Integer >= 1"
         end
-      end
 
-      path = node(user_id: self.user_id, node_id: node_id) + "/trans"
+        # Request to ship user debit card [Subnet]
+        # @param node_id [String]
+        # @param payload [Hash]
+        # @param subnet_id [String]
+        # @return [Synapse::Node] or [Hash]
+        def ship_card(node_id:, payload:, subnet_id:)
+            path = node(user_id: self.user_id, node_id: node_id) + "/subnets/#{subnet_id}/ship"
+
+            begin
+                response = client.patch(path,payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.patch(path,payload)
+            end
+            Subnet.new(subnet_id: response["subnet_id"], payload: response, node_id: response["node_id"])
+        end
 
-      params = VALID_QUERY_PARAMS.map do |p|
-        options[p] ? "#{p}=#{options[p]}" : nil
-      end.compact
+        # Resets debit card number, cvv, and expiration date
+        # @note Deprecated
+        # @see https://docs.synapsefi.com/docs/reset-debit-card
+        # @param node_id [String]
+        # @return [Synapse::Node] or [Hash]
+        def reset_card_node(node_id:)
+            path = node(user_id: self.user_id, node_id: node_id)  + "?reset=YES"
+            payload = {}
+            begin
+                response = client.patch(path,payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.patch(path,payload)
+            end
+            Node.new(user_id: self.user_id,
+                       node_id:response["_id"],
+                       full_dehydrate: false,
+                       payload: response,
+                       type: response["type"]
+                       )
+        end
 
-      path += '?' + params.join('&') if params.any?
+        # Creates a new transaction in the API belonging to the provided node
+        # @param node_id [String]
+        # @param payload [Hash]
+        # @param idempotency_key [String] (optional)
+        # @return [Synapse::Transaction]
+        def create_transaction(node_id: ,payload:, **options)
+            path = trans_path(user_id: self.user_id, node_id: node_id)
+            begin
+                transaction = client.post(path,payload, options)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                transaction = client.post(path,payload, options)
+            end
+            transaction = Transaction.new(trans_id: transaction['_id'],
+                                        payload:  transaction,
+                                        node_id:  node_id
+                                        )
+        end
 
-      begin
-        trans = client.get(path)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        trans = client.get(path)
-      end
+        # Queries the API for a transaction belonging to the supplied node by transaction id
+        # @param node_id [String]
+        # @param trans_id [String] id of the transaction to find
+        # @return [Synapse::Transaction]
+        def get_node_transaction(node_id:, trans_id:)
+            path = node(user_id: self.user_id, node_id: node_id) + "/trans/#{trans_id}"
+
+            begin
+                trans = client.get(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                trans = client.get(path)
+            end
+            Transaction.new(trans_id: trans['_id'],
+                          payload:  trans,
+                          node_id:  node_id
+                         )
+        end
 
 
-      response = trans["trans"].map { |trans_data| Transaction.new(trans_id: trans_data['_id'],
-                                                                   payload:  trans_data,
-                                                                   node_id:  node_id
-                                                                   )}
-      Transactions.new(limit:       trans["limit"],
-                       page:        trans["page"],
-                       page_count:  trans["page_count"],
-                       trans_count: trans["trans_count"],
-                       payload:     response
-                       )
-    end
-
-    # Verifies microdeposits for a node
-    # @param node_id [String]
-    # @param payload [Hash]
-    def verify_micro_deposit(node_id:,payload:)
-      path = node(user_id: self.user_id, node_id: node_id)
-      begin
-        response = client.patch(path, payload)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        response = client.patch(path, payload)
-      end
-      Node.new(user_id:        self.user_id,
-               node_id:        response["_id"],
-               full_dehydrate: false,
-               payload:        response,
-               type:           response["type"]
-               )
-    end
-
-    # Reinitiate microdeposits on a node
-    # @param node_id [String]
-    def reinitiate_micro_deposit(node_id:)
-      payload = {}
-      path = node(user_id: self.user_id, node_id: node_id) + "?resend_micro=YES"
-      begin
-        response = client.patch(path, payload)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        response = client.patch(path, payload)
-      end
-      Node.new(user_id:        self.user_id,
-               node_id:        response["_id"],
-               full_dehydrate: false,
-               payload:        response,
-               type:           response["type"])
-    end
-
-    # Generate tokenized info for Apple Wallet
-    # @param node_id [String]
-    # @param payload [Hash]
-    # @see https://docs.synapsefi.com/docs/generate-applepay-token
-    def generate_apple_pay_token(node_id:,payload:)
-      path = node(user_id: self.user_id, node_id: node_id) + "/applepay"
-      begin
-        response = client.patch(path, payload)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        response = client.patch(path, payload)
-      end
-      response
-    end
-
-    # Update supp_id, nickname, etc. for a node
-    # @param node_id [String]
-    # @param payload [Hash]
-    # @see https://docs.synapsefi.com/docs/update-info
-    # @return [Synapse::Node]
-    def update_node(node_id:, payload:)
-      path = node(user_id: self.user_id, node_id: node_id)
-
-      begin
-        update = client.patch(path, payload)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        update = client.patch(path, payload)
-      end
-      Node.new(node_id:        node_id,
-               user_id:        self.user_id,
-               payload:        update,
-               full_dehydrate: false,
-               type:           update["type"]
-              )
-    end
-
-    def delete_node(node_id:)
-      path = node(user_id: self.user_id, node_id: node_id)
-
-      begin
-        delete = client.delete(path)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        delete = client.delete(path)
-      end
-      delete
-    end
-
-    # Initiates dummy transactions to a node
-    # @param node_id [String]
-    # @param is_credit [String]
-    # @param foreign_transaction [String]
-    # @param subnetid [String]
-    # @param type [String]
-    # @see https://docs.synapsefi.com/docs/trigger-dummy-transactions
-    def dummy_transactions(node_id:, **options)
-
-      path = node(user_id: self.user_id, node_id: node_id) + "/dummy-tran"
-
-
-      params = VALID_QUERY_PARAMS.map do |p|
-        options[p] ? "#{p}=#{options[p]}" : nil
-      end.compact
-      path += '?' + params.join('&') if params.any?
-      print(path)
-      begin
-       response = client.get(path)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       response = client.get(path)
-      end
-      response
-    end
-
-    # Adds comment to the transactions
-    # @param node_id [String]
-    # @param trans_id [String]
-    # @param payload [Hash]
-    # @return [Synapse::Transaction]
-    def comment_transaction(node_id:,trans_id:,payload:)
-      path = trans_path(user_id: self.user_id, node_id: node_id) + "/#{trans_id}"
-
-      begin
-        trans = client.patch(path, payload)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        trans = client.patch(path, payload)
-      end
-      Transaction.new(trans_id: trans['_id'], payload: trans)
-    end
-
-    # Cancels transaction if it has not already settled
-    # @param node_id
-    # @param trans_id
-    # @return API response [Hash]
-    def cancel_transaction(node_id:, trans_id:)
-      path = trans_path(user_id: self.user_id, node_id: node_id) + "/#{trans_id}"
-      begin
-        response = client.delete(path)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        response = client.delete(path)
-      end
-      response
-    end
-
-    # Dispute a transaction for a user
-    # @param node_id
-    # @param trans_id
-    # @see https://docs.synapsefi.com/docs/dispute-card-transaction
-    # @return API response [Hash]
-    def dispute_card_transactions(node_id:, trans_id:, payload:)
-
-      path = trans_path(user_id: user_id, node_id: node_id) + "/#{trans_id}"
-      path += "/dispute"
-      begin
-        dispute = client.patch(path, payload)
-      rescue Synapse::Error::Unauthorized
-        self.authenticate()
-        dispute = client.patch(path, payload)
-      end
-      dispute
-    end
-
-    # Creates subnet for a node debit card or act/rt number
-    # @param node_id [String]
-    # @param payload [Hash]
-    # @param idempotency_key [String] (optional)
-    # @return [Synapse::Subnet]
-    def create_subnet(node_id:,payload:, **options)
-      path = subnet_path(user_id: self.user_id, node_id: node_id)
-
-      begin
-       subnet = client.post(path,payload, options)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       subnet = client.post(path,payload, options)
-      end
-
-      Subnet.new(subnet_id: subnet['_id'], payload: subnet, node_id: node_id)
-    end
-
-    # Updates subnet debit card and act/rt number
-    # @param node_id [String]
-    # @param payload [Hash]
-    # @param subnet_id [String]
-    # @return [Synapse::Subnet]
-    def update_subnet(node_id:, payload:, subnet_id:, **options)
-      path = subnet_path(user_id: self.user_id, node_id: node_id, subnet_id: subnet_id)
-
-      begin
-       subnet = client.patch(path,payload)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       subnet = client.patch(path,payload)
-      end
-      Subnet.new(subnet_id: subnet['_id'], payload: subnet, node_id: node_id)
-    end
-
-
-    # Gets all node subnets
-    # @param node_id [String]
-    # @param page [Integer]
-    # @param per_page [Integer]
-    # @see https://docs.synapsefi.com/docs/all-node-subnets
-    def get_all_subnets(node_id:,**options)
-      [options[:page], options[:per_page]].each do |arg|
-        if arg && (!arg.is_a?(Integer) || arg < 1)
-          raise ArgumentError, "#{arg} must be nil or an Integer >= 1"
+        # Queries the API for all transactions belonging to the supplied node
+        # @param node_id [String] node to which the transaction belongs
+        # @param page [Integer] (optional) response will default to 1
+        # @param per_page [Integer] (optional) response will default to 20
+        # @return [Array<Synapse::Transaction>]
+        def get_all_node_transaction(node_id:, **options)
+            [options[:page], options[:per_page]].each do |arg|
+                if arg && (!arg.is_a?(Integer) || arg < 1)
+                    raise ArgumentError, "#{arg} must be nil or an Integer >= 1"
+                end
+            end
+
+            path = node(user_id: self.user_id, node_id: node_id) + "/trans"
+
+            params = VALID_QUERY_PARAMS.map do |p|
+                options[p] ? "#{p}=#{options[p]}" : nil
+            end.compact
+
+            path += '?' + params.join('&') if params.any?
+
+            begin
+                trans = client.get(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                trans = client.get(path)
+            end
+            response = trans["trans"].map { |trans_data| Transaction.new(trans_id: trans_data['_id'],
+                                                                       payload:  trans_data,
+                                                                       node_id:  node_id
+                                                                       )}
+            Transactions.new(limit:       trans["limit"],
+                           page:        trans["page"],
+                           page_count:  trans["page_count"],
+                           trans_count: trans["trans_count"],
+                           payload:     response
+                           )
+        end
+
+        # Verifies microdeposits for a node
+        # @param node_id [String]
+        # @param payload [Hash]
+        def verify_micro_deposit(node_id:,payload:)
+            path = node(user_id: self.user_id, node_id: node_id)
+            begin
+                response = client.patch(path, payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.patch(path, payload)
+            end
+            Node.new(user_id:        self.user_id,
+                   node_id:        response["_id"],
+                   full_dehydrate: false,
+                   payload:        response,
+                   type:           response["type"]
+                   )
+        end
+
+        # Reinitiate microdeposits on a node
+        # @param node_id [String]
+        def reinitiate_micro_deposit(node_id:)
+            payload = {}
+            path = node(user_id: self.user_id, node_id: node_id) + "?resend_micro=YES"
+            begin
+                response = client.patch(path, payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.patch(path, payload)
+            end
+            Node.new(user_id:        self.user_id,
+                   node_id:        response["_id"],
+                   full_dehydrate: false,
+                   payload:        response,
+                   type:           response["type"])
+        end
+
+        # Generate tokenized info for Apple Wallet
+        # @param node_id [String]
+        # @param payload [Hash]
+        # @see https://docs.synapsefi.com/docs/generate-applepay-token
+        def generate_apple_pay_token(node_id:,payload:)
+            path = node(user_id: self.user_id, node_id: node_id) + "/applepay"
+            begin
+                response = client.patch(path, payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.patch(path, payload)
+            end
+            response
+        end
+
+        # Update supp_id, nickname, etc. for a node
+        # @param node_id [String]
+        # @param payload [Hash]
+        # @see https://docs.synapsefi.com/docs/update-info
+        # @return [Synapse::Node]
+        def update_node(node_id:, payload:)
+            path = node(user_id: self.user_id, node_id: node_id)
+
+            begin
+                update = client.patch(path, payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                update = client.patch(path, payload)
+            end
+            Node.new(node_id:        node_id,
+                   user_id:        self.user_id,
+                   payload:        update,
+                   full_dehydrate: false,
+                   type:           update["type"]
+                  )
+        end
+
+        # @param node_id [String]
+        def delete_node(node_id:)
+            path = node(user_id: self.user_id, node_id: node_id)
+
+            begin
+                delete = client.delete(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                delete = client.delete(path)
+            end
+            delete
+        end
+
+        # Initiates dummy transactions to a node
+        # @param node_id [String]
+        # @param is_credit [String]
+        # @param foreign_transaction [String]
+        # @param subnetid [String]
+        # @param type [String]
+        # @see https://docs.synapsefi.com/docs/trigger-dummy-transactions
+        def dummy_transactions(node_id:, **options)
+            path = node(user_id: self.user_id, node_id: node_id) + "/dummy-tran"
+            params = VALID_QUERY_PARAMS.map do |p|
+                options[p] ? "#{p}=#{options[p]}" : nil
+            end.compact
+            path += '?' + params.join('&') if params.any?
+
+            begin
+                response = client.get(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.get(path)
+            end
+            response
+        end
+
+        # Adds comment to the transactions
+        # @param node_id [String]
+        # @param trans_id [String]
+        # @param payload [Hash]
+        # @return [Synapse::Transaction]
+        def comment_transaction(node_id:,trans_id:,payload:)
+            path = trans_path(user_id: self.user_id, node_id: node_id) + "/#{trans_id}"
+
+            begin
+                trans = client.patch(path, payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                trans = client.patch(path, payload)
+            end
+            Transaction.new(trans_id: trans['_id'], payload: trans)
+        end
+
+        # Cancels transaction if it has not already settled
+        # @param node_id
+        # @param trans_id
+        # @return API response [Hash]
+        def cancel_transaction(node_id:, trans_id:)
+            path = trans_path(user_id: self.user_id, node_id: node_id) + "/#{trans_id}"
+            begin
+                response = client.delete(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                response = client.delete(path)
+            end
+            response
+        end
+
+        # Dispute a transaction for a user
+        # @param node_id
+        # @param trans_id
+        # @see https://docs.synapsefi.com/docs/dispute-card-transaction
+        # @return API response [Hash]
+        def dispute_card_transactions(node_id:, trans_id:, payload:)
+            path = trans_path(user_id: user_id, node_id: node_id) + "/#{trans_id}"
+            path += "/dispute"
+            begin
+                dispute = client.patch(path, payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                dispute = client.patch(path, payload)
+            end
+            dispute
+        end
+
+        # Creates subnet for a node debit card or act/rt number
+        # @param node_id [String]
+        # @param payload [Hash]
+        # @param idempotency_key [String] (optional)
+        # @return [Synapse::Subnet]
+        def create_subnet(node_id:,payload:, **options)
+            path = subnet_path(user_id: self.user_id, node_id: node_id)
+            begin
+                subnet = client.post(path,payload, options)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                subnet = client.post(path,payload, options)
+            end
+            Subnet.new(subnet_id: subnet['_id'], payload: subnet, node_id: node_id)
+        end
+
+        # Updates subnet debit card and act/rt number
+        # @param node_id [String]
+        # @param payload [Hash]
+        # @param subnet_id [String]
+        # @return [Synapse::Subnet]
+        def update_subnet(node_id:, payload:, subnet_id:, **options)
+            path = subnet_path(user_id: self.user_id, node_id: node_id, subnet_id: subnet_id)
+            begin
+                subnet = client.patch(path,payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                subnet = client.patch(path,payload)
+            end
+            Subnet.new(subnet_id: subnet['_id'], payload: subnet, node_id: node_id)
+        end
+
+
+        # Gets all node subnets
+        # @param node_id [String]
+        # @param page [Integer]
+        # @param per_page [Integer]
+        # @see https://docs.synapsefi.com/docs/all-node-subnets
+        def get_all_subnets(node_id:,**options)
+            [options[:page], options[:per_page]].each do |arg|
+                if arg && (!arg.is_a?(Integer) || arg < 1)
+                    raise ArgumentError, "#{arg} must be nil or an Integer >= 1"
+                end
+            end
+
+            path = node(user_id: self.user_id, node_id: node_id) + "/subnets"
+            params = VALID_QUERY_PARAMS.map do |p|
+                options[p] ? "#{p}=#{options[p]}" : nil
+            end.compact
+            path += '?' + params.join('&') if params.any?
+
+            begin
+                subnets = client.get(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                subnets = client.get(path)
+            end
+
+            response = subnets["subnets"].map { |subnets_data| Subnet.new(subnet_id: subnets_data['_id'],
+                                                                        payload:   subnets,
+                                                                        node_id:   node_id
+                                                                        )}
+            Subnets.new(limit:         subnets["limit"],
+                      page:          subnets["page"],
+                      page_count:    subnets["page_count"],
+                      subnets_count: subnets["subnets_count"],
+                      payload:       response,
+                      node_id:       node_id
+                     )
         end
-      end
-
-      path = node(user_id: self.user_id, node_id: node_id) + "/subnets"
-      params = VALID_QUERY_PARAMS.map do |p|
-        options[p] ? "#{p}=#{options[p]}" : nil
-      end.compact
-      path += '?' + params.join('&') if params.any?
-
-      begin
-       subnets = client.get(path)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       subnets = client.get(path)
-      end
-
-      response = subnets["subnets"].map { |subnets_data| Subnet.new(subnet_id: subnets_data['_id'],
-                                                                    payload:   subnets,
-                                                                    node_id:   node_id
-                                                                    )}
-      Subnets.new(limit:         subnets["limit"],
-                  page:          subnets["page"],
-                  page_count:    subnets["page_count"],
-                  subnets_count: subnets["subnets_count"],
-                  payload:       response,
-                  node_id:       node_id
-                 )
-    end
-
-    # Queries a node for a specific subnet by subnet_id
-    # @param node_id [String] id of node
-    # @param subnet_id [String,void] (optional) id of a subnet to look up
-    # @return [Synapse::Subnet]
-    def get_subnet(node_id:,subnet_id:)
-
-      path = node(user_id: self.user_id, node_id: node_id) + "/subnets/#{subnet_id}"
-
-      begin
-       subnet = client.get(path)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       subnet = client.get(path)
-      end
-      subnet = Subnet.new(subnet_id: subnet['_id'], payload: subnet, node_id: node_id)
-      subnet
-    end
-
-    # Gets statement by node
-    # @param page [Integer]
-    # @param per_page [Integer]
-    # @see https://docs.synapsefi.com/docs/statements-by-user
-    # @return API response [Hash]
-    def get_node_statements(node_id:,**options)
-      [options[:page], options[:per_page]].each do |arg|
-        if arg && (!arg.is_a?(Integer) || arg < 1)
-          raise ArgumentError, "#{arg} must be nil or an Integer >= 1"
+
+        # Queries a node for a specific subnet by subnet_id
+        # @param node_id [String] id of node
+        # @param subnet_id [String,void] (optional) id of a subnet to look up
+        # @return [Synapse::Subnet]
+        def get_subnet(node_id:,subnet_id:)
+            path = node(user_id: self.user_id, node_id: node_id) + "/subnets/#{subnet_id}"
+            begin
+                subnet = client.get(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                subnet = client.get(path)
+            end
+            subnet = Subnet.new(subnet_id: subnet['_id'], payload: subnet, node_id: node_id)
+            subnet
+        end
+
+        # Gets statement by node
+        # @param page [Integer]
+        # @param per_page [Integer]
+        # @see https://docs.synapsefi.com/docs/statements-by-user
+        # @return API response [Hash]
+        def get_node_statements(node_id:,**options)
+            [options[:page], options[:per_page]].each do |arg|
+                if arg && (!arg.is_a?(Integer) || arg < 1)
+                    raise ArgumentError, "#{arg} must be nil or an Integer >= 1"
+                end
+            end
+
+            path = node(user_id: self.user_id, node_id: node_id) + "/statements"
+            params = VALID_QUERY_PARAMS.map do |p|
+                options[p] ? "#{p}=#{options[p]}" : nil
+            end.compact
+            path += '?' + params.join('&') if params.any?
+
+            begin
+                statements = client.get(path)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                statements = client.get(path)
+            end
+
+            statements
         end
-      end
 
-      path = node(user_id: self.user_id, node_id: node_id) + "/statements"
-      params = VALID_QUERY_PARAMS.map do |p|
-        options[p] ? "#{p}=#{options[p]}" : nil
-      end.compact
-      path += '?' + params.join('&') if params.any?
+        # Gets statement by node on demand
+        # @param payload [Hash]
+        # @see https://docs.synapsefi.com/reference#generate-node-statements
+        # @return API response [Hash]
+        def get_node_statements(node_id:,payload:)
 
-      begin
-       statements = client.get(path)
-      rescue Synapse::Error::Unauthorized
-       self.authenticate()
-       statements = client.get(path)
-      end
+            path = node(user_id: self.user_id, node_id: node_id) + "/statements"
 
-      statements
-    end
+
+            begin
+                statements = client.post(path,payload)
+            rescue Synapse::Error::Unauthorized
+                self.authenticate()
+                statements = client.post(path,payload)
+            end
+
+            statements
+        end
 
 		private
 
@@ -777,30 +781,30 @@ module Synapse
 			path
 		end
 
-    def node(node_id:, **options)
-      path = "/users/#{self.user_id}/nodes/#{node_id}"
-      params = VALID_QUERY_PARAMS.map do |p|
-        options[p] ? "#{p}=#{options[p]}" : nil
-      end.compact
-
-      path += '?' + params.join('&') if params.any?
-
-      path
-    end
-
-    def trans_path(user_id:, node_id:)
-      path = "/users/#{user_id}/nodes/#{node_id}/trans"
-      path
-    end
-
-    def subnet_path(user_id:, node_id:, subnet_id: nil)
-      if subnet_id
-        path = "/users/#{user_id}/nodes/#{node_id}/subnets/#{subnet_id}"
-      else
-        path = "/users/#{user_id}/nodes/#{node_id}/subnets"
-      end
-      path
-    end
+        def node(node_id:, **options)
+            path = "/users/#{self.user_id}/nodes/#{node_id}"
+            params = VALID_QUERY_PARAMS.map do |p|
+            options[p] ? "#{p}=#{options[p]}" : nil
+            end.compact
+
+            path += '?' + params.join('&') if params.any?
+
+            path
+        end
+
+        def trans_path(user_id:, node_id:)
+            path = "/users/#{user_id}/nodes/#{node_id}/trans"
+            path
+        end
+
+        def subnet_path(user_id:, node_id:, subnet_id: nil)
+            if subnet_id
+                path = "/users/#{user_id}/nodes/#{node_id}/subnets/#{subnet_id}"
+            else
+                path = "/users/#{user_id}/nodes/#{node_id}/subnets"
+            end
+            path
+        end
 	end
 end