privy_ruby 0.0.2 → 0.1.0

data/lib/privy/public_api/services/earn/ethereum.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Privy
+  module Services
+    class Earn
+      class Ethereum < Privy::Resources::Wallets::Earn::Ethereum
+        attr_reader :privy_client
+
+        # @return [Privy::Services::Earn::Ethereum::Incentive]
+        attr_reader :incentive
+
+        def initialize(client:, privy_client:)
+          super(client: client)
+          @privy_client = privy_client
+          @incentive = Privy::Services::Earn::Ethereum::Incentive.new(
+            client: client,
+            privy_client: privy_client
+          )
+        end
+
+        # Deposit assets into an ERC-4626 vault.
+        #
+        # @example Deposit by human-readable amount
+        #   client.wallets.earn.ethereum.deposit("wallet-id", earn_deposit_params: {
+        #     vault_id: "vault-id",
+        #     amount: "1.5"
+        #   }, authorization_context: ctx)
+        #
+        # @example Deposit by raw amount
+        #   client.wallets.earn.ethereum.deposit("wallet-id", earn_deposit_params: {
+        #     vault_id: "vault-id",
+        #     raw_amount: "1500000"
+        #   })
+        #
+        # @param wallet_id [String] ID of the wallet to deposit from.
+        # @param earn_deposit_params [Hash] Body parameters for the deposit operation.
+        # @option earn_deposit_params [String] :vault_id ID of the vault to deposit into.
+        # @option earn_deposit_params [String, nil] :amount Human-readable decimal amount to deposit. Exactly one of
+        #   :amount or :raw_amount must be provided.
+        # @option earn_deposit_params [String, nil] :raw_amount Amount in the smallest unit to deposit. Exactly one of
+        #   :amount or :raw_amount must be provided.
+        # @param authorization_context [Privy::Authorization::AuthorizationContext, nil] Authorization context for owned wallets.
+        # @param idempotency_key [String, nil] Ensures the request is executed only once.
+        # @param request_expiry [Integer, nil] Absolute Unix-ms timestamp at which the
+        #   request expires. Defaults to the value computed by the client's
+        #   PrivyRequestExpiryOptions.
+        # @param request_options [Privy::RequestOptions, Hash, nil] Transport-level config (timeouts, retries).
+        #
+        # @return [Privy::Models::EarnDepositActionResponse]
+        def deposit(
+          wallet_id,
+          earn_deposit_params:,
+          authorization_context: nil,
+          idempotency_key: nil,
+          request_expiry: nil,
+          request_options: nil
+        )
+          prepared = Privy::Authorization.prepare_request(
+            privy_client,
+            method: :post,
+            url: Privy::Authorization.signed_url(
+              privy_client,
+              "v1/wallets/#{wallet_id}/earn/ethereum/deposit"
+            ),
+            body: earn_deposit_params,
+            authorization_context: authorization_context,
+            idempotency_key: idempotency_key,
+            request_expiry: privy_client.compute_request_expiry(request_expiry)
+          )
+          combined_params = earn_deposit_params.merge(request_options: request_options)
+          Privy::Authorization.merge_prepared_headers!(combined_params, prepared.headers)
+          _deposit(wallet_id, combined_params)
+        end
+
+        # Withdraw assets from an ERC-4626 vault.
+        #
+        # @example Withdraw by human-readable amount
+        #   client.wallets.earn.ethereum.withdraw("wallet-id", earn_withdraw_params: {
+        #     vault_id: "vault-id",
+        #     amount: "1.5"
+        #   }, authorization_context: ctx)
+        #
+        # @example Withdraw by raw amount
+        #   client.wallets.earn.ethereum.withdraw("wallet-id", earn_withdraw_params: {
+        #     vault_id: "vault-id",
+        #     raw_amount: "1500000"
+        #   })
+        #
+        # @param wallet_id [String] ID of the wallet to withdraw from.
+        # @param earn_withdraw_params [Hash] Body parameters for the withdraw operation.
+        # @option earn_withdraw_params [String] :vault_id ID of the vault to withdraw from.
+        # @option earn_withdraw_params [String, nil] :amount Human-readable decimal amount to withdraw. Exactly one of
+        #   :amount or :raw_amount must be provided.
+        # @option earn_withdraw_params [String, nil] :raw_amount Amount in the smallest unit to withdraw. Exactly one of
+        #   :amount or :raw_amount must be provided.
+        # @param authorization_context [Privy::Authorization::AuthorizationContext, nil] Authorization context for owned wallets.
+        # @param idempotency_key [String, nil] Ensures the request is executed only once.
+        # @param request_expiry [Integer, nil] Absolute Unix-ms timestamp at which the
+        #   request expires. Defaults to the value computed by the client's
+        #   PrivyRequestExpiryOptions.
+        # @param request_options [Privy::RequestOptions, Hash, nil] Transport-level config (timeouts, retries).
+        #
+        # @return [Privy::Models::EarnWithdrawActionResponse]
+        def withdraw(
+          wallet_id,
+          earn_withdraw_params:,
+          authorization_context: nil,
+          idempotency_key: nil,
+          request_expiry: nil,
+          request_options: nil
+        )
+          prepared = Privy::Authorization.prepare_request(
+            privy_client,
+            method: :post,
+            url: Privy::Authorization.signed_url(
+              privy_client,
+              "v1/wallets/#{wallet_id}/earn/ethereum/withdraw"
+            ),
+            body: earn_withdraw_params,
+            authorization_context: authorization_context,
+            idempotency_key: idempotency_key,
+            request_expiry: privy_client.compute_request_expiry(request_expiry)
+          )
+          combined_params = earn_withdraw_params.merge(request_options: request_options)
+          Privy::Authorization.merge_prepared_headers!(combined_params, prepared.headers)
+          _withdraw(wallet_id, combined_params)
+        end
+      end
+    end
+  end
+end

data/lib/privy/public_api/services/earn.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Privy
+  module Services
+    class Earn < Privy::Resources::Wallets::Earn
+      attr_reader :privy_client
+
+      # @return [Privy::Services::Earn::Ethereum]
+      attr_reader :ethereum
+
+      def initialize(client:, privy_client:)
+        super(client: client)
+        @privy_client = privy_client
+        @ethereum = Privy::Services::Earn::Ethereum.new(client: client, privy_client: privy_client)
+      end
+    end
+  end
+end

data/lib/privy/public_api/services/key_quorums.rb

@@ -53,7 +53,13 @@ module Privy
       # @param request_options [Privy::RequestOptions, Hash, nil] Transport-level config (timeouts, retries).
       #
       # @return [Privy::Models::KeyQuorum]
-      def update(key_quorum_id, key_quorum_update_params:, authorization_context: nil, request_expiry: nil, request_options: nil)
+      def update(
+        key_quorum_id,
+        key_quorum_update_params:,
+        authorization_context: nil,
+        request_expiry: nil,
+        request_options: nil
+      )
         prepared = Privy::Authorization.prepare_request(
           privy_client,
           method: :patch,

data/lib/privy/public_api/services/policies.rb

@@ -72,7 +72,13 @@ module Privy
       # @param request_options [Privy::RequestOptions, Hash, nil] Transport-level config (timeouts, retries).
       #
       # @return [Privy::Models::Policy]
-      def update(policy_id, policy_update_params:, authorization_context: nil, request_expiry: nil, request_options: nil)
+      def update(
+        policy_id,
+        policy_update_params:,
+        authorization_context: nil,
+        request_expiry: nil,
+        request_options: nil
+      )
         prepared = Privy::Authorization.prepare_request(
           privy_client,
           method: :patch,
@@ -144,7 +150,13 @@ module Privy
       # @param request_options [Privy::RequestOptions, Hash, nil] Transport-level config (timeouts, retries).
       #
       # @return [Privy::Models::PolicyRuleResponse]
-      def create_rule(policy_id, policy_create_rule_params:, authorization_context: nil, request_expiry: nil, request_options: nil)
+      def create_rule(
+        policy_id,
+        policy_create_rule_params:,
+        authorization_context: nil,
+        request_expiry: nil,
+        request_options: nil
+      )
         prepared = Privy::Authorization.prepare_request(
           privy_client,
           method: :post,
@@ -227,7 +239,13 @@ module Privy
       # @param request_options [Privy::RequestOptions, Hash, nil] Transport-level config (timeouts, retries).
       #
       # @return [Privy::Models::SuccessResponse]
-      def delete_rule(rule_id, policy_id:, authorization_context: nil, request_expiry: nil, request_options: nil)
+      def delete_rule(
+        rule_id,
+        policy_id:,
+        authorization_context: nil,
+        request_expiry: nil,
+        request_options: nil
+      )
         prepared = Privy::Authorization.prepare_request(
           privy_client,
           method: :delete,

data/lib/privy/public_api/services/transactions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Privy
+  module Services
+    class Transactions < Privy::Resources::Transactions
+      attr_reader :privy_client
+
+      def initialize(client:, privy_client:)
+        super(client: client)
+        @privy_client = privy_client
+      end
+    end
+  end
+end

data/lib/privy/public_api/services/wallets.rb

@@ -5,9 +5,13 @@ module Privy
     class Wallets < Privy::Resources::Wallets
       attr_reader :privy_client
 
+      # @return [Privy::Services::Earn]
+      attr_reader :earn
+
       def initialize(client:, privy_client:)
         super(client: client)
         @privy_client = privy_client
+        @earn = Privy::Services::Earn.new(client: client, privy_client: privy_client)
       end
 
       # Create a new wallet on the requested chain and for the requested owner.
@@ -39,6 +43,74 @@ module Privy
         super(combined_params)
       end
 
+      # Import an externally generated wallet by encrypting its entropy with HPKE.
+      #
+      # @param wallet [Hash] Import wallet parameters plus :private_key entropy.
+      # @option wallet [String] :private_key Private key or seed phrase entropy to import.
+      # @option wallet [String, Symbol] :entropy_type "hd" or "private-key".
+      # @option wallet [String, Symbol] :chain_type "ethereum" or "solana".
+      # @param request_options [Privy::RequestOptions, Hash, nil] Transport-level config (timeouts, retries).
+      #
+      # @return [Privy::Models::Wallet]
+      def import(
+        wallet:,
+        additional_signers: nil,
+        display_name: nil,
+        external_id: nil,
+        owner: nil,
+        owner_id: nil,
+        policy_ids: nil,
+        request_options: nil
+      )
+        import_wallet = wallet.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+        private_key = import_wallet.delete(:private_key)
+        raise Privy::Errors::Error, "wallet.private_key is required" if private_key.nil?
+        if import_wallet.key?(:hpke_config)
+          raise Privy::Errors::Error,
+                "wallet.hpke_config is not supported: encryption parameters are fixed by the SDK"
+        end
+
+        private_key_bytes = Privy::WalletEntropy.entropy_to_bytes(
+          entropy: private_key,
+          entropy_type: import_wallet.fetch(:entropy_type),
+          chain_type: import_wallet.fetch(:chain_type)
+        )
+
+        init_response = _init_import(
+          body: import_wallet.merge(encryption_type: "HPKE"),
+          request_options: request_options
+        )
+        unless init_response.encryption_type.to_s == "HPKE"
+          raise Privy::Errors::Error, "Invalid encryption type: #{init_response.encryption_type}"
+        end
+
+        encrypted = Privy::Cryptography::HpkeSender.new.encrypt(
+          Base64.strict_decode64(init_response.encryption_public_key),
+          private_key_bytes
+        )
+
+        submit_params = {
+          wallet: import_wallet.merge(
+            encryption_type: "HPKE",
+            encapsulated_key: Base64.strict_encode64(encrypted.encapsulated_key),
+            ciphertext: Base64.strict_encode64(encrypted.ciphertext)
+          ),
+          request_options: request_options
+        }
+        {
+          additional_signers: additional_signers,
+          display_name: display_name,
+          external_id: external_id,
+          owner: owner,
+          owner_id: owner_id,
+          policy_ids: policy_ids
+        }.each do |key, value|
+          submit_params[key] = value unless value.nil?
+        end
+
+        _submit_import(submit_params)
+      end
+
       # Update a wallet's policies or authorization key configuration.
       #
       # @example Update wallet policies
@@ -60,7 +132,13 @@ module Privy
       # @param request_options [Privy::RequestOptions, Hash, nil] Transport-level config (timeouts, retries).
       #
       # @return [Privy::Models::Wallet]
-      def update(wallet_id, wallet_update_params:, authorization_context: nil, request_expiry: nil, request_options: nil)
+      def update(
+        wallet_id,
+        wallet_update_params:,
+        authorization_context: nil,
+        request_expiry: nil,
+        request_options: nil
+      )
         prepared = Privy::Authorization.prepare_request(
           privy_client,
           method: :patch,
@@ -221,6 +299,80 @@ module Privy
         Privy::Authorization.merge_prepared_headers!(combined_params, prepared.headers)
         _transfer(wallet_id, combined_params)
       end
+
+      # Export a wallet's private key or seed phrase via HPKE.
+      #
+      # @param wallet_id [String] ID of the wallet to export.
+      # @param export_seed_phrase [Boolean, nil] Whether to export the seed phrase instead of the private key.
+      # @param authorization_context [Privy::Authorization::AuthorizationContext, nil] Authorization context for owned wallets.
+      # @param request_expiry [Integer, nil] Absolute Unix-ms timestamp at which the request expires.
+      # @param request_options [Privy::RequestOptions, Hash, nil] Transport-level config (timeouts, retries).
+      #
+      # @return [Hash] {private_key: String}
+      def export(
+        wallet_id,
+        export_seed_phrase: nil,
+        authorization_context: nil,
+        request_expiry: nil,
+        request_options: nil
+      )
+        recipient = Privy::Cryptography::HpkeRecipient.new
+        export_params = {
+          encryption_type: "HPKE",
+          recipient_public_key: Base64.strict_encode64(recipient.public_key_spki)
+        }
+        export_params[:export_seed_phrase] = export_seed_phrase unless export_seed_phrase.nil?
+
+        prepared = Privy::Authorization.prepare_request(
+          privy_client,
+          method: :post,
+          url: Privy::Authorization.signed_url(privy_client, "v1/wallets/#{wallet_id}/export"),
+          body: export_params,
+          authorization_context: authorization_context,
+          request_expiry: privy_client.compute_request_expiry(request_expiry)
+        )
+        combined_params = export_params.merge(request_options: request_options)
+        Privy::Authorization.merge_prepared_headers!(combined_params, prepared.headers)
+
+        response = super(wallet_id, combined_params)
+        unless response.encryption_type.to_s == "HPKE"
+          raise Privy::Errors::Error, "Invalid encryption type: #{response.encryption_type}"
+        end
+
+        private_key = recipient.decrypt(
+          Base64.strict_decode64(response.encapsulated_key),
+          Base64.strict_decode64(response.ciphertext)
+        )
+
+        {private_key: private_key.force_encoding(Encoding::UTF_8)}
+      end
+
+      # Export a wallet's private key via HPKE.
+      #
+      # @return [Hash] {private_key: String}
+      def export_private_key(wallet_id, authorization_context: nil, request_expiry: nil, request_options: nil)
+        export(
+          wallet_id,
+          export_seed_phrase: false,
+          authorization_context: authorization_context,
+          request_expiry: request_expiry,
+          request_options: request_options
+        )
+      end
+
+      # Export a wallet's seed phrase via HPKE.
+      #
+      # @return [Hash] {seed_phrase: String}
+      def export_seed_phrase(wallet_id, authorization_context: nil, request_expiry: nil, request_options: nil)
+        exported = export(
+          wallet_id,
+          export_seed_phrase: true,
+          authorization_context: authorization_context,
+          request_expiry: request_expiry,
+          request_options: request_options
+        )
+        {seed_phrase: exported.fetch(:private_key)}
+      end
     end
   end
 end

data/lib/privy/resources/intents.rb

@@ -66,7 +66,7 @@ module Privy
       #
       # @param request_options [Privy::RequestOptions, Hash{Symbol=>Object}, nil]
       #
-      # @return [Privy::Models::RuleIntentResponse]
+      # @return [Privy::Models::RuleMutateIntentResponse]
       #
       # @see Privy::Models::IntentCreatePolicyRuleParams
       def create_policy_rule(policy_id, params)
@@ -77,7 +77,7 @@ module Privy
           path: ["v1/intents/policies/%1$s/rules", policy_id],
           headers: parsed.slice(*header_params.keys).transform_keys(header_params),
           body: parsed.except(*header_params.keys),
-          model: Privy::RuleIntentResponse,
+          model: Privy::RuleMutateIntentResponse,
           options: options
         )
       end
@@ -98,7 +98,7 @@ module Privy
       #
       # @param request_options [Privy::RequestOptions, Hash{Symbol=>Object}, nil]
       #
-      # @return [Privy::Models::RuleIntentResponse]
+      # @return [Privy::Models::RuleDeleteIntentResponse]
       #
       # @see Privy::Models::IntentDeletePolicyRuleParams
       def delete_policy_rule(rule_id, params)
@@ -111,7 +111,7 @@ module Privy
           method: :delete,
           path: ["v1/intents/policies/%1$s/rules/%2$s", policy_id, rule_id],
           headers: parsed.transform_keys(privy_request_expiry: "privy-request-expiry"),
-          model: Privy::RuleIntentResponse,
+          model: Privy::RuleDeleteIntentResponse,
           options: options
         )
       end
@@ -310,7 +310,7 @@ module Privy
       #
       # @param request_options [Privy::RequestOptions, Hash{Symbol=>Object}, nil]
       #
-      # @return [Privy::Models::RuleIntentResponse]
+      # @return [Privy::Models::RuleMutateIntentResponse]
       #
       # @see Privy::Models::IntentUpdatePolicyRuleParams
       def update_policy_rule(rule_id, params)
@@ -325,7 +325,7 @@ module Privy
           path: ["v1/intents/policies/%1$s/rules/%2$s", policy_id, rule_id],
           headers: parsed.slice(*header_params.keys).transform_keys(header_params),
           body: parsed.except(*header_params.keys),
-          model: Privy::RuleIntentResponse,
+          model: Privy::RuleMutateIntentResponse,
           options: options
         )
       end

data/lib/privy/resources/oauth.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Privy
+  module Resources
+    class OAuth
+      # @api private
+      #
+      # @param client [Privy::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/privy/resources/onramps.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Privy
+  module Resources
+    class Onramps
+      # @api private
+      #
+      # @param client [Privy::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/privy/resources/wallets/swap.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Privy
+  module Resources
+    class Wallets
+      # Operations for swapping tokens within wallets
+      class Swap
+        # Some parameter documentations has been truncated, see
+        # {Privy::Models::Wallets::SwapExecuteParams} for more details.
+        #
+        # Execute a token swap within a wallet.
+        #
+        # @overload execute(wallet_id, base_amount:, destination:, source:, amount_type: nil, fee_configuration: nil, slippage_bps: nil, privy_authorization_signature: nil, privy_idempotency_key: nil, request_options: {})
+        #
+        # @param wallet_id [String] Path param: ID of the wallet.
+        #
+        # @param base_amount [String] Body param: Amount in base units (e.g., wei for ETH). Must be a non-negative int
+        #
+        # @param destination [Privy::Models::SwapDestination] Body param: The output side of a swap execution request.
+        #
+        # @param source [Privy::Models::SwapSource] Body param: The input side of a swap request, including token and chain.
+        #
+        # @param amount_type [Symbol, Privy::Models::AmountType] Body param: Whether the amount refers to the input token or output token.
+        #
+        # @param fee_configuration [Privy::Models::FeeConfiguration] Body param: Total fees assessed on a transfer, in BPS
+        #
+        # @param slippage_bps [Float] Body param: Maximum slippage tolerance in basis points (e.g., 50 for 0.5%).
+        #
+        # @param privy_authorization_signature [String] Header param: Request authorization signature. If multiple signatures are requir
+        #
+        # @param privy_idempotency_key [String] Header param: Idempotency keys ensure API requests are executed only once within
+        #
+        # @param request_options [Privy::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Privy::Models::SwapActionResponse]
+        #
+        # @see Privy::Models::Wallets::SwapExecuteParams
+        def execute(wallet_id, params)
+          parsed, options = Privy::Wallets::SwapExecuteParams.dump_request(params)
+          header_params =
+            {
+              privy_authorization_signature: "privy-authorization-signature",
+              privy_idempotency_key: "privy-idempotency-key"
+            }
+          @client.request(
+            method: :post,
+            path: ["v1/wallets/%1$s/swap", wallet_id],
+            headers: parsed.slice(*header_params.keys).transform_keys(header_params),
+            body: parsed.except(*header_params.keys),
+            model: Privy::SwapActionResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Privy::Models::Wallets::SwapQuoteParams} for more details.
+        #
+        # Get a price quote for swapping tokens within a wallet.
+        #
+        # @overload quote(wallet_id, base_amount:, destination:, source:, amount_type: nil, fee_configuration: nil, slippage_bps: nil, privy_authorization_signature: nil, request_options: {})
+        #
+        # @param wallet_id [String] Path param: ID of the wallet.
+        #
+        # @param base_amount [String] Body param: Amount in base units (e.g., wei for ETH). Must be a non-negative int
+        #
+        # @param destination [Privy::Models::SwapQuoteDestination] Body param: The output side of a swap quote request.
+        #
+        # @param source [Privy::Models::SwapSource] Body param: The input side of a swap request, including token and chain.
+        #
+        # @param amount_type [Symbol, Privy::Models::AmountType] Body param: Whether the amount refers to the input token or output token.
+        #
+        # @param fee_configuration [Privy::Models::FeeConfiguration] Body param: Total fees assessed on a transfer, in BPS
+        #
+        # @param slippage_bps [Float] Body param: Maximum slippage tolerance in basis points (e.g., 50 for 0.5%). If o
+        #
+        # @param privy_authorization_signature [String] Header param: Request authorization signature. If multiple signatures are requir
+        #
+        # @param request_options [Privy::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Privy::Models::SwapQuoteResponse]
+        #
+        # @see Privy::Models::Wallets::SwapQuoteParams
+        def quote(wallet_id, params)
+          parsed, options = Privy::Wallets::SwapQuoteParams.dump_request(params)
+          header_params = {privy_authorization_signature: "privy-authorization-signature"}
+          @client.request(
+            method: :post,
+            path: ["v1/wallets/%1$s/swap/quote", wallet_id],
+            headers: parsed.slice(*header_params.keys).transform_keys(header_params),
+            body: parsed.except(*header_params.keys),
+            model: Privy::SwapQuoteResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Privy::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/privy/resources/wallets.rb

@@ -14,6 +14,10 @@ module Privy
       # @return [Privy::Resources::Wallets::Balance]
       attr_reader :balance
 
+      # Operations for swapping tokens within wallets
+      # @return [Privy::Resources::Wallets::Swap]
+      attr_reader :swap
+
       # Some parameter documentations has been truncated, see
       # {Privy::Models::WalletCreateParams} for more details.
       #
@@ -247,7 +251,8 @@ module Privy
       # Some parameter documentations has been truncated, see
       # {Privy::Models::WalletAuthenticateWithJwtParams} for more details.
       #
-      # Obtain a session key to enable wallet access.
+      # Exchange a user JWT for a session key authorized to act on the user's wallets.
+      # Returns the encrypted authorization key and the list of wallets it can access.
       #
       # @overload authenticate_with_jwt(encryption_type:, recipient_public_key:, user_jwt:, request_options: {})
       #
@@ -275,7 +280,9 @@ module Privy
 
       # @deprecated
       #
-      # Create wallets with an associated recovery user.
+      # Create one or more wallets associated with a recovery user, so the user can
+      # later regain wallet access via the linked accounts. Deprecated; prefer the
+      # standard wallet creation flow combined with a separate recovery setup.
       #
       # @overload create_wallets_with_recovery(primary_signer:, recovery_user:, wallets:, request_options: {})
       #
@@ -467,6 +474,7 @@ module Privy
         @earn = Privy::Resources::Wallets::Earn.new(client: client)
         @transactions = Privy::Resources::Wallets::Transactions.new(client: client)
         @balance = Privy::Resources::Wallets::Balance.new(client: client)
+        @swap = Privy::Resources::Wallets::Swap.new(client: client)
       end
     end
   end

data/lib/privy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Privy
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end