privy_ruby 0.1.0 → 0.3.0

data/rbi/privy/models/wallets/evm_transaction_wallet_action_step.rbi

@@ -0,0 +1,128 @@
+# typed: strong
+
+module Privy
+  module Models
+    module Wallets
+      class EvmTransactionWalletActionStep < Privy::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Privy::Wallets::EvmTransactionWalletActionStep,
+              Privy::Internal::AnyHash
+            )
+          end
+
+        # CAIP-2 chain identifier of the transaction, containing the chain ID.
+        sig { returns(String) }
+        attr_accessor :caip2
+
+        # Status of an EVM step in a wallet action.
+        sig { returns(Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol) }
+        attr_accessor :status
+
+        # The transaction hash for this step. May change while the step status is
+        # non-terminal.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :transaction_hash
+
+        sig do
+          returns(
+            Privy::Wallets::EvmTransactionWalletActionStep::Type::TaggedSymbol
+          )
+        end
+        attr_accessor :type
+
+        # A description of why a wallet action (or a step within a wallet action) failed.
+        sig { returns(T.nilable(Privy::Wallets::FailureReason)) }
+        attr_reader :failure_reason
+
+        sig do
+          params(failure_reason: Privy::Wallets::FailureReason::OrHash).void
+        end
+        attr_writer :failure_reason
+
+        # Whether this step has reached on-chain finality. Absent until finality is
+        # confirmed.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :finalized
+
+        sig { params(finalized: T::Boolean).void }
+        attr_writer :finalized
+
+        # A wallet action step consisting of an EVM transaction.
+        sig do
+          params(
+            caip2: String,
+            status: Privy::Wallets::EvmWalletActionStepStatus::OrSymbol,
+            transaction_hash: T.nilable(String),
+            type:
+              Privy::Wallets::EvmTransactionWalletActionStep::Type::OrSymbol,
+            failure_reason: Privy::Wallets::FailureReason::OrHash,
+            finalized: T::Boolean
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # CAIP-2 chain identifier of the transaction, containing the chain ID.
+          caip2:,
+          # Status of an EVM step in a wallet action.
+          status:,
+          # The transaction hash for this step. May change while the step status is
+          # non-terminal.
+          transaction_hash:,
+          type:,
+          # A description of why a wallet action (or a step within a wallet action) failed.
+          failure_reason: nil,
+          # Whether this step has reached on-chain finality. Absent until finality is
+          # confirmed.
+          finalized: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              caip2: String,
+              status: Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol,
+              transaction_hash: T.nilable(String),
+              type:
+                Privy::Wallets::EvmTransactionWalletActionStep::Type::TaggedSymbol,
+              failure_reason: Privy::Wallets::FailureReason,
+              finalized: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Type
+          extend Privy::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Privy::Wallets::EvmTransactionWalletActionStep::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EVM_TRANSACTION =
+            T.let(
+              :evm_transaction,
+              Privy::Wallets::EvmTransactionWalletActionStep::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Privy::Wallets::EvmTransactionWalletActionStep::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/privy/models/wallets/evm_user_operation_entrypoint_version.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Privy
+  module Models
+    module Wallets
+      # The ERC-4337 entrypoint contract version used by the user operation.
+      module EvmUserOperationEntrypointVersion
+        extend Privy::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Privy::Wallets::EvmUserOperationEntrypointVersion)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        EVM_USER_OPERATION_ENTRYPOINT_VERSION_0_6 =
+          T.let(
+            :"0.6",
+            Privy::Wallets::EvmUserOperationEntrypointVersion::TaggedSymbol
+          )
+        EVM_USER_OPERATION_ENTRYPOINT_VERSION_0_7 =
+          T.let(
+            :"0.7",
+            Privy::Wallets::EvmUserOperationEntrypointVersion::TaggedSymbol
+          )
+        EVM_USER_OPERATION_ENTRYPOINT_VERSION_0_8 =
+          T.let(
+            :"0.8",
+            Privy::Wallets::EvmUserOperationEntrypointVersion::TaggedSymbol
+          )
+        EVM_USER_OPERATION_ENTRYPOINT_VERSION_0_9 =
+          T.let(
+            :"0.9",
+            Privy::Wallets::EvmUserOperationEntrypointVersion::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Privy::Wallets::EvmUserOperationEntrypointVersion::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/privy/models/wallets/evm_user_operation_wallet_action_step.rbi

@@ -0,0 +1,163 @@
+# typed: strong
+
+module Privy
+  module Models
+    module Wallets
+      class EvmUserOperationWalletActionStep < Privy::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Privy::Wallets::EvmUserOperationWalletActionStep,
+              Privy::Internal::AnyHash
+            )
+          end
+
+        # Transaction hash of the bundle in which this user operation was included. Null
+        # until included by a bundler.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :bundle_transaction_hash
+
+        # CAIP-2 network identifier, containing the chain ID of the user operation.
+        sig { returns(String) }
+        attr_accessor :caip2
+
+        # The ERC-4337 entrypoint contract version used by the user operation.
+        sig do
+          returns(
+            Privy::Wallets::EvmUserOperationEntrypointVersion::TaggedSymbol
+          )
+        end
+        attr_accessor :entrypoint_version
+
+        # Status of an EVM step in a wallet action.
+        sig { returns(Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol) }
+        attr_accessor :status
+
+        sig do
+          returns(
+            Privy::Wallets::EvmUserOperationWalletActionStep::Type::TaggedSymbol
+          )
+        end
+        attr_accessor :type
+
+        # The user operation hash for this step. May change while the step status is
+        # non-terminal.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :user_operation_hash
+
+        # A description of why a wallet action (or a step within a wallet action) failed.
+        sig { returns(T.nilable(Privy::Wallets::FailureReason)) }
+        attr_reader :failure_reason
+
+        sig do
+          params(failure_reason: Privy::Wallets::FailureReason::OrHash).void
+        end
+        attr_writer :failure_reason
+
+        # Whether this step has reached on-chain finality. Absent until finality is
+        # confirmed.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :finalized
+
+        sig { params(finalized: T::Boolean).void }
+        attr_writer :finalized
+
+        # Amount charged in USD for gas sponsorship on this step.
+        sig { returns(T.nilable(String)) }
+        attr_reader :gas_credits_charged_usd
+
+        sig { params(gas_credits_charged_usd: String).void }
+        attr_writer :gas_credits_charged_usd
+
+        # A wallet action step consisting of an EVM user operation.
+        sig do
+          params(
+            bundle_transaction_hash: T.nilable(String),
+            caip2: String,
+            entrypoint_version:
+              Privy::Wallets::EvmUserOperationEntrypointVersion::OrSymbol,
+            status: Privy::Wallets::EvmWalletActionStepStatus::OrSymbol,
+            type:
+              Privy::Wallets::EvmUserOperationWalletActionStep::Type::OrSymbol,
+            user_operation_hash: T.nilable(String),
+            failure_reason: Privy::Wallets::FailureReason::OrHash,
+            finalized: T::Boolean,
+            gas_credits_charged_usd: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Transaction hash of the bundle in which this user operation was included. Null
+          # until included by a bundler.
+          bundle_transaction_hash:,
+          # CAIP-2 network identifier, containing the chain ID of the user operation.
+          caip2:,
+          # The ERC-4337 entrypoint contract version used by the user operation.
+          entrypoint_version:,
+          # Status of an EVM step in a wallet action.
+          status:,
+          type:,
+          # The user operation hash for this step. May change while the step status is
+          # non-terminal.
+          user_operation_hash:,
+          # A description of why a wallet action (or a step within a wallet action) failed.
+          failure_reason: nil,
+          # Whether this step has reached on-chain finality. Absent until finality is
+          # confirmed.
+          finalized: nil,
+          # Amount charged in USD for gas sponsorship on this step.
+          gas_credits_charged_usd: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              bundle_transaction_hash: T.nilable(String),
+              caip2: String,
+              entrypoint_version:
+                Privy::Wallets::EvmUserOperationEntrypointVersion::TaggedSymbol,
+              status: Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol,
+              type:
+                Privy::Wallets::EvmUserOperationWalletActionStep::Type::TaggedSymbol,
+              user_operation_hash: T.nilable(String),
+              failure_reason: Privy::Wallets::FailureReason,
+              finalized: T::Boolean,
+              gas_credits_charged_usd: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Type
+          extend Privy::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Privy::Wallets::EvmUserOperationWalletActionStep::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EVM_USER_OPERATION =
+            T.let(
+              :evm_user_operation,
+              Privy::Wallets::EvmUserOperationWalletActionStep::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Privy::Wallets::EvmUserOperationWalletActionStep::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/privy/models/wallets/evm_wallet_action_step_status.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module Privy
+  module Models
+    module Wallets
+      # Status of an EVM step in a wallet action.
+      module EvmWalletActionStepStatus
+        extend Privy::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Privy::Wallets::EvmWalletActionStepStatus)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PREPARING =
+          T.let(
+            :preparing,
+            Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol
+          )
+        QUEUED =
+          T.let(
+            :queued,
+            Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol
+          )
+        PENDING =
+          T.let(
+            :pending,
+            Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol
+          )
+        RETRYING =
+          T.let(
+            :retrying,
+            Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol
+          )
+        CONFIRMED =
+          T.let(
+            :confirmed,
+            Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol
+          )
+        REJECTED =
+          T.let(
+            :rejected,
+            Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol
+          )
+        REVERTED =
+          T.let(
+            :reverted,
+            Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol
+          )
+        REPLACED =
+          T.let(
+            :replaced,
+            Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol
+          )
+        ABANDONED =
+          T.let(
+            :abandoned,
+            Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Privy::Wallets::EvmWalletActionStepStatus::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/privy/models/wallets/external_transaction_wallet_action_step.rbi

@@ -0,0 +1,104 @@
+# typed: strong
+
+module Privy
+  module Models
+    module Wallets
+      class ExternalTransactionWalletActionStep < Privy::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Privy::Wallets::ExternalTransactionWalletActionStep,
+              Privy::Internal::AnyHash
+            )
+          end
+
+        # Status of an external transaction step in a wallet action.
+        sig do
+          returns(
+            Privy::Wallets::ExternalTransactionWalletActionStepStatus::TaggedSymbol
+          )
+        end
+        attr_accessor :status
+
+        sig do
+          returns(
+            Privy::Wallets::ExternalTransactionWalletActionStep::Type::TaggedSymbol
+          )
+        end
+        attr_accessor :type
+
+        # A description of why a wallet action (or a step within a wallet action) failed.
+        sig { returns(T.nilable(Privy::Wallets::FailureReason)) }
+        attr_reader :failure_reason
+
+        sig do
+          params(failure_reason: Privy::Wallets::FailureReason::OrHash).void
+        end
+        attr_writer :failure_reason
+
+        # A wallet action step representing a cross-chain/cross-asset fill by an external
+        # provider.
+        sig do
+          params(
+            status:
+              Privy::Wallets::ExternalTransactionWalletActionStepStatus::OrSymbol,
+            type:
+              Privy::Wallets::ExternalTransactionWalletActionStep::Type::OrSymbol,
+            failure_reason: Privy::Wallets::FailureReason::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Status of an external transaction step in a wallet action.
+          status:,
+          type:,
+          # A description of why a wallet action (or a step within a wallet action) failed.
+          failure_reason: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              status:
+                Privy::Wallets::ExternalTransactionWalletActionStepStatus::TaggedSymbol,
+              type:
+                Privy::Wallets::ExternalTransactionWalletActionStep::Type::TaggedSymbol,
+              failure_reason: Privy::Wallets::FailureReason
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Type
+          extend Privy::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Privy::Wallets::ExternalTransactionWalletActionStep::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EXTERNAL_TRANSACTION =
+            T.let(
+              :external_transaction,
+              Privy::Wallets::ExternalTransactionWalletActionStep::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Privy::Wallets::ExternalTransactionWalletActionStep::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/privy/models/wallets/external_transaction_wallet_action_step_status.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Privy
+  module Models
+    module Wallets
+      # Status of an external transaction step in a wallet action.
+      module ExternalTransactionWalletActionStepStatus
+        extend Privy::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Privy::Wallets::ExternalTransactionWalletActionStepStatus
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PREPARING =
+          T.let(
+            :preparing,
+            Privy::Wallets::ExternalTransactionWalletActionStepStatus::TaggedSymbol
+          )
+        QUEUED =
+          T.let(
+            :queued,
+            Privy::Wallets::ExternalTransactionWalletActionStepStatus::TaggedSymbol
+          )
+        PENDING =
+          T.let(
+            :pending,
+            Privy::Wallets::ExternalTransactionWalletActionStepStatus::TaggedSymbol
+          )
+        CONFIRMED =
+          T.let(
+            :confirmed,
+            Privy::Wallets::ExternalTransactionWalletActionStepStatus::TaggedSymbol
+          )
+        REJECTED =
+          T.let(
+            :rejected,
+            Privy::Wallets::ExternalTransactionWalletActionStepStatus::TaggedSymbol
+          )
+        FAILED =
+          T.let(
+            :failed,
+            Privy::Wallets::ExternalTransactionWalletActionStepStatus::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Privy::Wallets::ExternalTransactionWalletActionStepStatus::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/privy/models/wallets/failure_reason.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Privy
+  module Models
+    module Wallets
+      class FailureReason < Privy::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Privy::Wallets::FailureReason, Privy::Internal::AnyHash)
+          end
+
+        # Human-readable failure message.
+        sig { returns(String) }
+        attr_accessor :message
+
+        # Additional error details, if available.
+        sig { returns(T.nilable(T.anything)) }
+        attr_reader :details
+
+        sig { params(details: T.anything).void }
+        attr_writer :details
+
+        # A description of why a wallet action (or a step within a wallet action) failed.
+        sig do
+          params(message: String, details: T.anything).returns(T.attached_class)
+        end
+        def self.new(
+          # Human-readable failure message.
+          message:,
+          # Additional error details, if available.
+          details: nil
+        )
+        end
+
+        sig { override.returns({ message: String, details: T.anything }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/privy/models/wallets/list_wallet_actions_query.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Privy
+  module Models
+    module Wallets
+      class ListWalletActionsQuery < Privy::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Privy::Wallets::ListWalletActionsQuery,
+              Privy::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :cursor
+
+        sig { params(cursor: String).void }
+        attr_writer :cursor
+
+        sig { returns(T.nilable(Float)) }
+        attr_accessor :limit
+
+        # Type of wallet action
+        sig { returns(T.nilable(Privy::Wallets::WalletActionType::OrSymbol)) }
+        attr_reader :type
+
+        sig { params(type: Privy::Wallets::WalletActionType::OrSymbol).void }
+        attr_writer :type
+
+        # Query parameters for listing wallet actions.
+        sig do
+          params(
+            cursor: String,
+            limit: T.nilable(Float),
+            type: Privy::Wallets::WalletActionType::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          cursor: nil,
+          limit: nil,
+          # Type of wallet action
+          type: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              cursor: String,
+              limit: T.nilable(Float),
+              type: Privy::Wallets::WalletActionType::OrSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end