privy_ruby 0.2.0 → 0.4.0

data/rbi/privy/models/wallet_archived_webhook_payload.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Privy
+  module Models
+    class WalletArchivedWebhookPayload < Privy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Privy::WalletArchivedWebhookPayload, Privy::Internal::AnyHash)
+        end
+
+      # Unix timestamp of when the wallet was archived.
+      sig { returns(Float) }
+      attr_accessor :archived_at
+
+      # The chain type of the archived wallet.
+      sig { returns(String) }
+      attr_accessor :chain_type
+
+      # The type of webhook event.
+      sig { returns(Privy::WalletArchivedWebhookPayload::Type::TaggedSymbol) }
+      attr_accessor :type
+
+      # The address of the archived wallet.
+      sig { returns(String) }
+      attr_accessor :wallet_address
+
+      # The ID of the archived wallet.
+      sig { returns(String) }
+      attr_accessor :wallet_id
+
+      # Payload for the wallet.archived webhook event.
+      sig do
+        params(
+          archived_at: Float,
+          chain_type: String,
+          type: Privy::WalletArchivedWebhookPayload::Type::OrSymbol,
+          wallet_address: String,
+          wallet_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unix timestamp of when the wallet was archived.
+        archived_at:,
+        # The chain type of the archived wallet.
+        chain_type:,
+        # The type of webhook event.
+        type:,
+        # The address of the archived wallet.
+        wallet_address:,
+        # The ID of the archived wallet.
+        wallet_id:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            archived_at: Float,
+            chain_type: String,
+            type: Privy::WalletArchivedWebhookPayload::Type::TaggedSymbol,
+            wallet_address: String,
+            wallet_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The type of webhook event.
+      module Type
+        extend Privy::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Privy::WalletArchivedWebhookPayload::Type)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        WALLET_ARCHIVED =
+          T.let(
+            :"wallet.archived",
+            Privy::WalletArchivedWebhookPayload::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Privy::WalletArchivedWebhookPayload::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/privy/models/wallet_asset.rbi

@@ -14,10 +14,12 @@ module Privy
       ETH = T.let(:eth, Privy::WalletAsset::TaggedSymbol)
       AVAX = T.let(:avax, Privy::WalletAsset::TaggedSymbol)
       POL = T.let(:pol, Privy::WalletAsset::TaggedSymbol)
+      BNB = T.let(:bnb, Privy::WalletAsset::TaggedSymbol)
       USDT = T.let(:usdt, Privy::WalletAsset::TaggedSymbol)
       EURC = T.let(:eurc, Privy::WalletAsset::TaggedSymbol)
       USDB = T.let(:usdb, Privy::WalletAsset::TaggedSymbol)
       SOL = T.let(:sol, Privy::WalletAsset::TaggedSymbol)
+      TRX = T.let(:trx, Privy::WalletAsset::TaggedSymbol)
 
       sig { override.returns(T::Array[Privy::WalletAsset::TaggedSymbol]) }
       def self.values

data/rbi/privy/models/wallet_asset_chain_name_input.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Privy
+  module Models
+    # Supported blockchain network names for wallet balance and transaction queries.
+    module WalletAssetChainNameInput
+      extend Privy::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Privy::WalletAssetChainNameInput) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      ETHEREUM =
+        T.let(:ethereum, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      ARBITRUM =
+        T.let(:arbitrum, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      AVALANCHE =
+        T.let(:avalanche, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      BASE = T.let(:base, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      TEMPO = T.let(:tempo, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      LINEA = T.let(:linea, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      OPTIMISM =
+        T.let(:optimism, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      POLYGON = T.let(:polygon, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      BSC = T.let(:bsc, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      SOLANA = T.let(:solana, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      TRON = T.let(:tron, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      ZKSYNC_ERA =
+        T.let(:zksync_era, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      SEPOLIA = T.let(:sepolia, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      ARBITRUM_SEPOLIA =
+        T.let(:arbitrum_sepolia, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      AVALANCHE_FUJI =
+        T.let(:avalanche_fuji, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      BASE_SEPOLIA =
+        T.let(:base_sepolia, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      LINEA_TESTNET =
+        T.let(:linea_testnet, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      OPTIMISM_SEPOLIA =
+        T.let(:optimism_sepolia, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      POLYGON_AMOY =
+        T.let(:polygon_amoy, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      SOLANA_DEVNET =
+        T.let(:solana_devnet, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      SOLANA_TESTNET =
+        T.let(:solana_testnet, Privy::WalletAssetChainNameInput::TaggedSymbol)
+      TRON_NILE =
+        T.let(:tron_nile, Privy::WalletAssetChainNameInput::TaggedSymbol)
+
+      sig do
+        override.returns(
+          T::Array[Privy::WalletAssetChainNameInput::TaggedSymbol]
+        )
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/privy/models/wallet_authenticate_bound_encrypted_request_body.rbi

@@ -0,0 +1,94 @@
+# typed: strong
+
+module Privy
+  module Models
+    class WalletAuthenticateBoundEncryptedRequestBody < Privy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Privy::WalletAuthenticateBoundEncryptedRequestBody,
+            Privy::Internal::AnyHash
+          )
+        end
+
+      # Bindings that scope the USK. The key can only authorize the bound values.
+      sig { returns(T::Array[Privy::UserSigningKeyBinding]) }
+      attr_accessor :bindings
+
+      sig do
+        returns(
+          Privy::WalletAuthenticateBoundEncryptedRequestBody::EncryptionType::OrSymbol
+        )
+      end
+      attr_accessor :encryption_type
+
+      sig { returns(String) }
+      attr_accessor :recipient_public_key
+
+      sig { returns(String) }
+      attr_accessor :user_jwt
+
+      # Request body for creating an encrypted, bound user signing key.
+      sig do
+        params(
+          bindings: T::Array[Privy::UserSigningKeyBinding::OrHash],
+          encryption_type:
+            Privy::WalletAuthenticateBoundEncryptedRequestBody::EncryptionType::OrSymbol,
+          recipient_public_key: String,
+          user_jwt: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Bindings that scope the USK. The key can only authorize the bound values.
+        bindings:,
+        encryption_type:,
+        recipient_public_key:,
+        user_jwt:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            bindings: T::Array[Privy::UserSigningKeyBinding],
+            encryption_type:
+              Privy::WalletAuthenticateBoundEncryptedRequestBody::EncryptionType::OrSymbol,
+            recipient_public_key: String,
+            user_jwt: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module EncryptionType
+        extend Privy::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              Privy::WalletAuthenticateBoundEncryptedRequestBody::EncryptionType
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        HPKE =
+          T.let(
+            :HPKE,
+            Privy::WalletAuthenticateBoundEncryptedRequestBody::EncryptionType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Privy::WalletAuthenticateBoundEncryptedRequestBody::EncryptionType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/privy/models/wallet_authenticate_bound_request_body.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Privy
+  module Models
+    # Request body for creating a user signing key scoped to specific bindings. The
+    # returned USK can only authorize the bound values and cannot sign other RPC
+    # requests.
+    module WalletAuthenticateBoundRequestBody
+      extend Privy::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Privy::WalletAuthenticateBoundEncryptedRequestBody,
+            Privy::WalletAuthenticateBoundUnencryptedRequestBody
+          )
+        end
+
+      sig do
+        override.returns(
+          T::Array[Privy::WalletAuthenticateBoundRequestBody::Variants]
+        )
+      end
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/privy/models/wallet_authenticate_bound_unencrypted_request_body.rbi

@@ -0,0 +1,44 @@
+# typed: strong
+
+module Privy
+  module Models
+    class WalletAuthenticateBoundUnencryptedRequestBody < Privy::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Privy::WalletAuthenticateBoundUnencryptedRequestBody,
+            Privy::Internal::AnyHash
+          )
+        end
+
+      # Bindings that scope the USK. The key can only authorize the bound values.
+      sig { returns(T::Array[Privy::UserSigningKeyBinding]) }
+      attr_accessor :bindings
+
+      sig { returns(String) }
+      attr_accessor :user_jwt
+
+      # Request body for creating an unencrypted, bound user signing key.
+      sig do
+        params(
+          bindings: T::Array[Privy::UserSigningKeyBinding::OrHash],
+          user_jwt: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Bindings that scope the USK. The key can only authorize the bound values.
+        bindings:,
+        user_jwt:
+      )
+      end
+
+      sig do
+        override.returns(
+          { bindings: T::Array[Privy::UserSigningKeyBinding], user_jwt: String }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/privy/models/wallet_authenticate_intents_response.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Privy
+  module Models
+    # The response from authenticating a wallet with intent bindings, containing an
+    # authorization key, wallet data, and the bindings the key is scoped to.
+    module WalletAuthenticateIntentsResponse
+      extend Privy::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Privy::EncryptedBoundAuthenticateResponse,
+            Privy::RawBoundAuthenticateResponse
+          )
+        end
+
+      sig do
+        override.returns(
+          T::Array[Privy::WalletAuthenticateIntentsResponse::Variants]
+        )
+      end
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/privy/models/wallet_authenticate_with_jwt_response.rbi

@@ -10,215 +10,11 @@ module Privy
       Variants =
         T.type_alias do
           T.any(
-            Privy::WalletAuthenticateWithJwtResponse::WithEncryption,
-            Privy::WalletAuthenticateWithJwtResponse::WithoutEncryption
+            Privy::EncryptedWalletAuthenticateResponse,
+            Privy::RawWalletAuthenticateResponse
           )
         end
 
-      class WithEncryption < Privy::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Privy::WalletAuthenticateWithJwtResponse::WithEncryption,
-              Privy::Internal::AnyHash
-            )
-          end
-
-        # The encrypted authorization key data.
-        sig do
-          returns(
-            Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey
-          )
-        end
-        attr_reader :encrypted_authorization_key
-
-        sig do
-          params(
-            encrypted_authorization_key:
-              Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey::OrHash
-          ).void
-        end
-        attr_writer :encrypted_authorization_key
-
-        # The expiration time of the authorization key in milliseconds since the epoch.
-        sig { returns(Float) }
-        attr_accessor :expires_at
-
-        sig { returns(T::Array[Privy::Wallet]) }
-        attr_accessor :wallets
-
-        sig do
-          params(
-            encrypted_authorization_key:
-              Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey::OrHash,
-            expires_at: Float,
-            wallets: T::Array[Privy::Wallet::OrHash]
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The encrypted authorization key data.
-          encrypted_authorization_key:,
-          # The expiration time of the authorization key in milliseconds since the epoch.
-          expires_at:,
-          wallets:
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              encrypted_authorization_key:
-                Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey,
-              expires_at: Float,
-              wallets: T::Array[Privy::Wallet]
-            }
-          )
-        end
-        def to_hash
-        end
-
-        class EncryptedAuthorizationKey < Privy::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey,
-                Privy::Internal::AnyHash
-              )
-            end
-
-          # The encrypted authorization key corresponding to the user's current
-          # authentication session.
-          sig { returns(String) }
-          attr_accessor :ciphertext
-
-          # Base64-encoded ephemeral public key used in the HPKE encryption process.
-          # Required for decryption.
-          sig { returns(String) }
-          attr_accessor :encapsulated_key
-
-          # The encryption type used. Currently only supports HPKE.
-          sig do
-            returns(
-              Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey::EncryptionType::TaggedSymbol
-            )
-          end
-          attr_accessor :encryption_type
-
-          # The encrypted authorization key data.
-          sig do
-            params(
-              ciphertext: String,
-              encapsulated_key: String,
-              encryption_type:
-                Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey::EncryptionType::OrSymbol
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            # The encrypted authorization key corresponding to the user's current
-            # authentication session.
-            ciphertext:,
-            # Base64-encoded ephemeral public key used in the HPKE encryption process.
-            # Required for decryption.
-            encapsulated_key:,
-            # The encryption type used. Currently only supports HPKE.
-            encryption_type:
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                ciphertext: String,
-                encapsulated_key: String,
-                encryption_type:
-                  Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey::EncryptionType::TaggedSymbol
-              }
-            )
-          end
-          def to_hash
-          end
-
-          # The encryption type used. Currently only supports HPKE.
-          module EncryptionType
-            extend Privy::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey::EncryptionType
-                )
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-            HPKE =
-              T.let(
-                :HPKE,
-                Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey::EncryptionType::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[
-                  Privy::WalletAuthenticateWithJwtResponse::WithEncryption::EncryptedAuthorizationKey::EncryptionType::TaggedSymbol
-                ]
-              )
-            end
-            def self.values
-            end
-          end
-        end
-      end
-
-      class WithoutEncryption < Privy::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Privy::WalletAuthenticateWithJwtResponse::WithoutEncryption,
-              Privy::Internal::AnyHash
-            )
-          end
-
-        # The raw authorization key data.
-        sig { returns(String) }
-        attr_accessor :authorization_key
-
-        # The expiration time of the authorization key in milliseconds since the epoch.
-        sig { returns(Float) }
-        attr_accessor :expires_at
-
-        sig { returns(T::Array[Privy::Wallet]) }
-        attr_accessor :wallets
-
-        sig do
-          params(
-            authorization_key: String,
-            expires_at: Float,
-            wallets: T::Array[Privy::Wallet::OrHash]
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The raw authorization key data.
-          authorization_key:,
-          # The expiration time of the authorization key in milliseconds since the epoch.
-          expires_at:,
-          wallets:
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              authorization_key: String,
-              expires_at: Float,
-              wallets: T::Array[Privy::Wallet]
-            }
-          )
-        end
-        def to_hash
-        end
-      end
-
       sig do
         override.returns(
           T::Array[Privy::WalletAuthenticateWithJwtResponse::Variants]

data/rbi/privy/models/wallet_creation_input.rbi

@@ -34,6 +34,15 @@ module Privy
       sig { params(create_smart_wallet: T::Boolean).void }
       attr_writer :create_smart_wallet
 
+      # A customer-provided identifier for mapping to external systems. Write-once, set
+      # only at creation. Must be alphanumeric, hyphens, or underscores, max 64
+      # characters.
+      sig { returns(T.nilable(String)) }
+      attr_reader :external_id
+
+      sig { params(external_id: String).void }
+      attr_writer :external_id
+
       # Policy IDs to enforce on the wallet. Currently, only one policy is supported per
       # wallet.
       sig { returns(T.nilable(T::Array[String])) }
@@ -50,6 +59,7 @@ module Privy
           additional_signers:
             T::Array[Privy::WalletCreationAdditionalSignerItem::OrHash],
           create_smart_wallet: T::Boolean,
+          external_id: String,
           policy_ids: T::Array[String]
         ).returns(T.attached_class)
       end
@@ -61,6 +71,10 @@ module Privy
         # Create a smart wallet with this wallet as the signer. Only supported for wallets
         # with `chain_type: "ethereum"`.
         create_smart_wallet: nil,
+        # A customer-provided identifier for mapping to external systems. Write-once, set
+        # only at creation. Must be alphanumeric, hyphens, or underscores, max 64
+        # characters.
+        external_id: nil,
         # Policy IDs to enforce on the wallet. Currently, only one policy is supported per
         # wallet.
         policy_ids: nil
@@ -74,6 +88,7 @@ module Privy
             additional_signers:
               T::Array[Privy::WalletCreationAdditionalSignerItem],
             create_smart_wallet: T::Boolean,
+            external_id: String,
             policy_ids: T::Array[String]
           }
         )

data/rbi/privy/models/wallet_ethereum_asset.rbi

@@ -14,6 +14,7 @@ module Privy
       ETH = T.let(:eth, Privy::WalletEthereumAsset::TaggedSymbol)
       AVAX = T.let(:avax, Privy::WalletEthereumAsset::TaggedSymbol)
       POL = T.let(:pol, Privy::WalletEthereumAsset::TaggedSymbol)
+      BNB = T.let(:bnb, Privy::WalletEthereumAsset::TaggedSymbol)
       USDT = T.let(:usdt, Privy::WalletEthereumAsset::TaggedSymbol)
       EURC = T.let(:eurc, Privy::WalletEthereumAsset::TaggedSymbol)
       USDB = T.let(:usdb, Privy::WalletEthereumAsset::TaggedSymbol)

data/rbi/privy/models/wallet_get_params.rbi

@@ -13,22 +13,36 @@ module Privy
       sig { returns(String) }
       attr_accessor :wallet_id
 
+      # Include archived wallets in lookup. Defaults to false.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :include_archived
+
+      sig { params(include_archived: T::Boolean).void }
+      attr_writer :include_archived
+
       sig do
         params(
           wallet_id: String,
+          include_archived: T::Boolean,
           request_options: Privy::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
         # ID of the wallet.
         wallet_id:,
+        # Include archived wallets in lookup. Defaults to false.
+        include_archived: nil,
         request_options: {}
       )
       end
 
       sig do
         override.returns(
-          { wallet_id: String, request_options: Privy::RequestOptions }
+          {
+            wallet_id: String,
+            include_archived: T::Boolean,
+            request_options: Privy::RequestOptions
+          }
         )
       end
       def to_hash

data/rbi/privy/models/wallet_import_supported_chains.rbi

@@ -2,8 +2,8 @@
 
 module Privy
   module Models
-    # The chain type of the wallet to import. Currently supports `ethereum` and
-    # `solana`.
+    # The chain type of the wallet to import. Supports `ethereum`, `solana`,
+    # `stellar`, `tron`, `sui`, and `aptos`.
     module WalletImportSupportedChains
       extend Privy::Internal::Type::Enum
 
@@ -14,6 +14,11 @@ module Privy
       ETHEREUM =
         T.let(:ethereum, Privy::WalletImportSupportedChains::TaggedSymbol)
       SOLANA = T.let(:solana, Privy::WalletImportSupportedChains::TaggedSymbol)
+      STELLAR =
+        T.let(:stellar, Privy::WalletImportSupportedChains::TaggedSymbol)
+      TRON = T.let(:tron, Privy::WalletImportSupportedChains::TaggedSymbol)
+      SUI = T.let(:sui, Privy::WalletImportSupportedChains::TaggedSymbol)
+      APTOS = T.let(:aptos, Privy::WalletImportSupportedChains::TaggedSymbol)
 
       sig do
         override.returns(