lithic 0.19.0 → 0.21.0

data/rbi/lithic/models/payment.rbi

@@ -82,6 +82,10 @@ module Lithic
       sig { returns(Time) }
       attr_accessor :updated
 
+      # Token of the blockchain recipient the payout is sent to
+      sig { returns(T.nilable(String)) }
+      attr_accessor :blockchain_recipient_token
+
       # Currency of the transaction in ISO 4217 format
       sig { returns(T.nilable(String)) }
       attr_reader :currency
@@ -129,7 +133,8 @@ module Lithic
           method_attributes:
             T.any(
               Lithic::Payment::MethodAttributes::ACHMethodAttributes::OrHash,
-              Lithic::Payment::MethodAttributes::WireMethodAttributes::OrHash
+              Lithic::Payment::MethodAttributes::WireMethodAttributes::OrHash,
+              Lithic::Payment::MethodAttributes::StablecoinMethodAttributes::OrHash
             ),
           pending_amount: Integer,
           related_account_tokens:
@@ -139,6 +144,7 @@ module Lithic
           source: Lithic::Payment::Source::OrSymbol,
           status: Lithic::Payment::Status::OrSymbol,
           updated: Time,
+          blockchain_recipient_token: T.nilable(String),
           currency: String,
           expected_release_date: T.nilable(Date),
           external_bank_account_token: T.nilable(String),
@@ -181,6 +187,8 @@ module Lithic
         status:,
         # ISO 8601 timestamp of when the transaction was last updated
         updated:,
+        # Token of the blockchain recipient the payout is sent to
+        blockchain_recipient_token: nil,
         # Currency of the transaction in ISO 4217 format
         currency: nil,
         # Expected release date for the transaction
@@ -219,6 +227,7 @@ module Lithic
             source: Lithic::Payment::Source::TaggedSymbol,
             status: Lithic::Payment::Status::TaggedSymbol,
             updated: Time,
+            blockchain_recipient_token: T.nilable(String),
             currency: String,
             expected_release_date: T.nilable(Date),
             external_bank_account_token: T.nilable(String),
@@ -258,6 +267,8 @@ module Lithic
           T.let(:EXTERNAL_FEDNOW, Lithic::Payment::Category::TaggedSymbol)
         EXTERNAL_RTP =
           T.let(:EXTERNAL_RTP, Lithic::Payment::Category::TaggedSymbol)
+        EXTERNAL_STABLECOIN =
+          T.let(:EXTERNAL_STABLECOIN, Lithic::Payment::Category::TaggedSymbol)
         EXTERNAL_TRANSFER =
           T.let(:EXTERNAL_TRANSFER, Lithic::Payment::Category::TaggedSymbol)
         EXTERNAL_WIRE =
@@ -387,8 +398,16 @@ module Lithic
         #
         # - `STABLECOIN_RECEIVED` - Stablecoin pay-in received on-chain and pending
         #   release to available balance.
-        # - `STABLECOIN_REVIEWED` - Stablecoin pay-in has completed the review process.
-        # - `STABLECOIN_SETTLED` - Stablecoin pay-in funds released to available balance.
+        # - `STABLECOIN_INITIATED` - Stablecoin withdrawal initiated, with the funds
+        #   placed on hold.
+        # - `STABLECOIN_REVIEWED` - Stablecoin pay-in or withdrawal has completed the
+        #   review process.
+        # - `STABLECOIN_SENT` - Stablecoin withdrawal accepted for on-chain submission to
+        #   the destination address, and pending confirmation.
+        # - `STABLECOIN_SETTLED` - Stablecoin pay-in funds released to available balance,
+        #   or stablecoin withdrawal confirmed on-chain.
+        # - `STABLECOIN_REJECTED` - Stablecoin withdrawal failed and the hold placed at
+        #   initiation has been reversed.
         sig { returns(Lithic::Payment::Event::Type::TaggedSymbol) }
         attr_accessor :type
 
@@ -412,7 +431,9 @@ module Lithic
 
         # Payment event external ID. For ACH transactions, this is the ACH trace number.
         # For inbound wire transfers, this is the IMAD (Input Message Accountability
-        # Data).
+        # Data). For stablecoin payments, this is the on-chain transaction hash of the
+        # transfer; it is present on events that reflect on-chain activity and null on
+        # internal lifecycle events.
         sig { returns(T.nilable(String)) }
         attr_accessor :external_id
 
@@ -501,14 +522,24 @@ module Lithic
           #
           # - `STABLECOIN_RECEIVED` - Stablecoin pay-in received on-chain and pending
           #   release to available balance.
-          # - `STABLECOIN_REVIEWED` - Stablecoin pay-in has completed the review process.
-          # - `STABLECOIN_SETTLED` - Stablecoin pay-in funds released to available balance.
+          # - `STABLECOIN_INITIATED` - Stablecoin withdrawal initiated, with the funds
+          #   placed on hold.
+          # - `STABLECOIN_REVIEWED` - Stablecoin pay-in or withdrawal has completed the
+          #   review process.
+          # - `STABLECOIN_SENT` - Stablecoin withdrawal accepted for on-chain submission to
+          #   the destination address, and pending confirmation.
+          # - `STABLECOIN_SETTLED` - Stablecoin pay-in funds released to available balance,
+          #   or stablecoin withdrawal confirmed on-chain.
+          # - `STABLECOIN_REJECTED` - Stablecoin withdrawal failed and the hold placed at
+          #   initiation has been reversed.
           type:,
           # More detailed reasons for the event
           detailed_results: nil,
           # Payment event external ID. For ACH transactions, this is the ACH trace number.
           # For inbound wire transfers, this is the IMAD (Input Message Accountability
-          # Data).
+          # Data). For stablecoin payments, this is the on-chain transaction hash of the
+          # transfer; it is present on events that reflect on-chain activity and null on
+          # internal lifecycle events.
           external_id: nil
         )
         end
@@ -610,8 +641,16 @@ module Lithic
         #
         # - `STABLECOIN_RECEIVED` - Stablecoin pay-in received on-chain and pending
         #   release to available balance.
-        # - `STABLECOIN_REVIEWED` - Stablecoin pay-in has completed the review process.
-        # - `STABLECOIN_SETTLED` - Stablecoin pay-in funds released to available balance.
+        # - `STABLECOIN_INITIATED` - Stablecoin withdrawal initiated, with the funds
+        #   placed on hold.
+        # - `STABLECOIN_REVIEWED` - Stablecoin pay-in or withdrawal has completed the
+        #   review process.
+        # - `STABLECOIN_SENT` - Stablecoin withdrawal accepted for on-chain submission to
+        #   the destination address, and pending confirmation.
+        # - `STABLECOIN_SETTLED` - Stablecoin pay-in funds released to available balance,
+        #   or stablecoin withdrawal confirmed on-chain.
+        # - `STABLECOIN_REJECTED` - Stablecoin withdrawal failed and the hold placed at
+        #   initiation has been reversed.
         module Type
           extend Lithic::Internal::Type::Enum
 
@@ -734,16 +773,28 @@ module Lithic
               :STABLECOIN_RECEIVED,
               Lithic::Payment::Event::Type::TaggedSymbol
             )
+          STABLECOIN_INITIATED =
+            T.let(
+              :STABLECOIN_INITIATED,
+              Lithic::Payment::Event::Type::TaggedSymbol
+            )
           STABLECOIN_REVIEWED =
             T.let(
               :STABLECOIN_REVIEWED,
               Lithic::Payment::Event::Type::TaggedSymbol
             )
+          STABLECOIN_SENT =
+            T.let(:STABLECOIN_SENT, Lithic::Payment::Event::Type::TaggedSymbol)
           STABLECOIN_SETTLED =
             T.let(
               :STABLECOIN_SETTLED,
               Lithic::Payment::Event::Type::TaggedSymbol
             )
+          STABLECOIN_REJECTED =
+            T.let(
+              :STABLECOIN_REJECTED,
+              Lithic::Payment::Event::Type::TaggedSymbol
+            )
 
           sig do
             override.returns(
@@ -821,6 +872,7 @@ module Lithic
         ACH_SAME_DAY =
           T.let(:ACH_SAME_DAY, Lithic::Payment::Method::TaggedSymbol)
         WIRE = T.let(:WIRE, Lithic::Payment::Method::TaggedSymbol)
+        STABLECOIN = T.let(:STABLECOIN, Lithic::Payment::Method::TaggedSymbol)
 
         sig do
           override.returns(T::Array[Lithic::Payment::Method::TaggedSymbol])
@@ -837,7 +889,8 @@ module Lithic
           T.type_alias do
             T.any(
               Lithic::Payment::MethodAttributes::ACHMethodAttributes,
-              Lithic::Payment::MethodAttributes::WireMethodAttributes
+              Lithic::Payment::MethodAttributes::WireMethodAttributes,
+              Lithic::Payment::MethodAttributes::StablecoinMethodAttributes
             )
           end
 
@@ -1134,6 +1187,47 @@ module Lithic
           end
         end
 
+        class StablecoinMethodAttributes < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::Payment::MethodAttributes::StablecoinMethodAttributes,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # Blockchain the stablecoin transfer settled on
+          sig { returns(String) }
+          attr_accessor :chain
+
+          # On-chain transaction hash of the transfer. Null until the transfer has settled
+          # on chain
+          sig { returns(T.nilable(String)) }
+          attr_accessor :transaction_hash
+
+          sig do
+            params(chain: String, transaction_hash: T.nilable(String)).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # Blockchain the stablecoin transfer settled on
+            chain:,
+            # On-chain transaction hash of the transfer. Null until the transfer has settled
+            # on chain
+            transaction_hash: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              { chain: String, transaction_hash: T.nilable(String) }
+            )
+          end
+          def to_hash
+          end
+        end
+
         sig do
           override.returns(
             T::Array[Lithic::Payment::MethodAttributes::Variants]
@@ -1270,6 +1364,10 @@ module Lithic
             :WIRE_INBOUND_DRAWDOWN_REQUEST,
             Lithic::Payment::Type::TaggedSymbol
           )
+        STABLECOIN_INBOUND =
+          T.let(:STABLECOIN_INBOUND, Lithic::Payment::Type::TaggedSymbol)
+        STABLECOIN_OUTBOUND =
+          T.let(:STABLECOIN_OUTBOUND, Lithic::Payment::Type::TaggedSymbol)
 
         sig { override.returns(T::Array[Lithic::Payment::Type::TaggedSymbol]) }
         def self.values

data/rbi/lithic/models/payment_create_stablecoin_params.rbi

@@ -0,0 +1,162 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class PaymentCreateStablecoinParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::PaymentCreateStablecoinParams,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Payout amount in cents
+      sig { returns(Integer) }
+      attr_accessor :amount
+
+      # Token of the blockchain recipient to send the payout to. The recipient must be
+      # in the `ENABLED` verification state
+      sig { returns(String) }
+      attr_accessor :blockchain_recipient_token
+
+      # Token of the financial account the payout is funded from
+      sig { returns(String) }
+      attr_accessor :financial_account_token
+
+      # Direction of the payment. Stablecoin supports payouts only
+      sig { returns(Lithic::PaymentCreateStablecoinParams::Type::OrSymbol) }
+      attr_accessor :type
+
+      # Customer-provided token that will serve as an idempotency token. This token will
+      # become the transaction token
+      sig { returns(T.nilable(String)) }
+      attr_reader :token
+
+      sig { params(token: String).void }
+      attr_writer :token
+
+      # Optional hold to settle when this payout is initiated
+      sig { returns(T.nilable(Lithic::PaymentCreateStablecoinParams::Hold)) }
+      attr_reader :hold
+
+      sig do
+        params(hold: Lithic::PaymentCreateStablecoinParams::Hold::OrHash).void
+      end
+      attr_writer :hold
+
+      # Memo recorded on the payout. Defaults to `Stablecoin payout on <chain>` when
+      # omitted
+      sig { returns(T.nilable(String)) }
+      attr_reader :memo
+
+      sig { params(memo: String).void }
+      attr_writer :memo
+
+      sig do
+        params(
+          amount: Integer,
+          blockchain_recipient_token: String,
+          financial_account_token: String,
+          type: Lithic::PaymentCreateStablecoinParams::Type::OrSymbol,
+          token: String,
+          hold: Lithic::PaymentCreateStablecoinParams::Hold::OrHash,
+          memo: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Payout amount in cents
+        amount:,
+        # Token of the blockchain recipient to send the payout to. The recipient must be
+        # in the `ENABLED` verification state
+        blockchain_recipient_token:,
+        # Token of the financial account the payout is funded from
+        financial_account_token:,
+        # Direction of the payment. Stablecoin supports payouts only
+        type:,
+        # Customer-provided token that will serve as an idempotency token. This token will
+        # become the transaction token
+        token: nil,
+        # Optional hold to settle when this payout is initiated
+        hold: nil,
+        # Memo recorded on the payout. Defaults to `Stablecoin payout on <chain>` when
+        # omitted
+        memo: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            amount: Integer,
+            blockchain_recipient_token: String,
+            financial_account_token: String,
+            type: Lithic::PaymentCreateStablecoinParams::Type::OrSymbol,
+            token: String,
+            hold: Lithic::PaymentCreateStablecoinParams::Hold,
+            memo: String,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Direction of the payment. Stablecoin supports payouts only
+      module Type
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::PaymentCreateStablecoinParams::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PAYMENT =
+          T.let(
+            :PAYMENT,
+            Lithic::PaymentCreateStablecoinParams::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Lithic::PaymentCreateStablecoinParams::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class Hold < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::PaymentCreateStablecoinParams::Hold,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Token of the hold to settle when this payout is initiated
+        sig { returns(String) }
+        attr_accessor :token
+
+        # Optional hold to settle when this payout is initiated
+        sig { params(token: String).returns(T.attached_class) }
+        def self.new(
+          # Token of the hold to settle when this payout is initiated
+          token:
+        )
+        end
+
+        sig { override.returns({ token: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/payment_create_stablecoin_response.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class PaymentCreateStablecoinResponse < Lithic::Models::Payment
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::Models::PaymentCreateStablecoinResponse,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Balance
+      sig { returns(T.nilable(Lithic::Balance)) }
+      attr_reader :balance
+
+      sig { params(balance: Lithic::Balance::OrHash).void }
+      attr_writer :balance
+
+      # Payment transaction
+      sig { params(balance: Lithic::Balance::OrHash).returns(T.attached_class) }
+      def self.new(
+        # Balance
+        balance: nil
+      )
+      end
+
+      sig { override.returns({ balance: Lithic::Balance }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/payment_list_params.rbi

@@ -158,6 +158,8 @@ module Lithic
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         ACH = T.let(:ACH, Lithic::PaymentListParams::Category::TaggedSymbol)
+        STABLECOIN =
+          T.let(:STABLECOIN, Lithic::PaymentListParams::Category::TaggedSymbol)
 
         sig do
           override.returns(

data/rbi/lithic/models/payment_retry_params.rbi

@@ -14,22 +14,67 @@ module Lithic
       sig { returns(String) }
       attr_accessor :payment_token
 
+      # Settlement speed to retry the payment at. Defaults to the original payment's
+      # method. An `ACH_SAME_DAY` retry is rejected if the payment is for $1,000,000.00
+      # or more, or if it is submitted after the same day ACH cutoff
+      sig { returns(T.nilable(Lithic::PaymentRetryParams::Method::OrSymbol)) }
+      attr_reader :method_
+
+      sig { params(method_: Lithic::PaymentRetryParams::Method::OrSymbol).void }
+      attr_writer :method_
+
       sig do
         params(
           payment_token: String,
+          method_: Lithic::PaymentRetryParams::Method::OrSymbol,
           request_options: Lithic::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
-      def self.new(payment_token:, request_options: {})
+      def self.new(
+        payment_token:,
+        # Settlement speed to retry the payment at. Defaults to the original payment's
+        # method. An `ACH_SAME_DAY` retry is rejected if the payment is for $1,000,000.00
+        # or more, or if it is submitted after the same day ACH cutoff
+        method_: nil,
+        request_options: {}
+      )
       end
 
       sig do
         override.returns(
-          { payment_token: String, request_options: Lithic::RequestOptions }
+          {
+            payment_token: String,
+            method_: Lithic::PaymentRetryParams::Method::OrSymbol,
+            request_options: Lithic::RequestOptions
+          }
         )
       end
       def to_hash
       end
+
+      # Settlement speed to retry the payment at. Defaults to the original payment's
+      # method. An `ACH_SAME_DAY` retry is rejected if the payment is for $1,000,000.00
+      # or more, or if it is submitted after the same day ACH cutoff
+      module Method
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::PaymentRetryParams::Method) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACH_NEXT_DAY =
+          T.let(:ACH_NEXT_DAY, Lithic::PaymentRetryParams::Method::TaggedSymbol)
+        ACH_SAME_DAY =
+          T.let(:ACH_SAME_DAY, Lithic::PaymentRetryParams::Method::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Lithic::PaymentRetryParams::Method::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/lithic/models/payment_simulate_action_params.rbi

@@ -163,6 +163,11 @@ module Lithic
             :ACH_RETURN_SETTLED,
             Lithic::PaymentSimulateActionParams::EventType::TaggedSymbol
           )
+        STABLECOIN_REVIEWED =
+          T.let(
+            :STABLECOIN_REVIEWED,
+            Lithic::PaymentSimulateActionParams::EventType::TaggedSymbol
+          )
 
         sig do
           override.returns(