coinbase-sdk 0.0.14 → 0.1.0

data/lib/coinbase/wallet.rb

@@ -5,25 +5,18 @@ require 'json'
 require 'money-tree'
 require 'securerandom'
 
+require_relative 'wallet/data'
+
 module Coinbase
   # A representation of a Wallet. Wallets come with a single default Address, but can expand to have a set of Addresses,
   # each of which can hold a balance of one or more Assets. Wallets can create new Addresses, list their addresses,
   # list their balances, and transfer Assets to other Addresses.
   class Wallet
+    extend Forwardable
+
     # The maximum number of addresses in a Wallet.
     MAX_ADDRESSES = 20
 
-    # A representation of ServerSigner status in a Wallet.
-    module ServerSignerStatus
-      # The Wallet is awaiting seed creation by the ServerSigner. At this point,
-      # the Wallet cannot create addresses or sign transactions.
-      PENDING = 'pending_seed_creation'
-
-      # The Wallet has an associated seed created by the ServerSigner. It is ready
-      # to create addresses and sign transactions.
-      ACTIVE = 'active_seed'
-    end
-
     class << self
       # Imports a Wallet from previously exported wallet data.
       # @param data [Coinbase::Wallet::Data] the Wallet data to import
@@ -43,7 +36,7 @@ module Coinbase
       # converted to an array, etc...
       # @return [Enumerable<Coinbase::Wallet>] Enumerator that returns wallets
       def list
-        Coinbase::Pagination.enumerate(lambda(&method(:fetch_wallets_page))) do |wallet|
+        Coinbase::Pagination.enumerate(method(:fetch_wallets_page)) do |wallet|
           Coinbase::Wallet.new(wallet, seed: '')
         end
       end
@@ -63,18 +56,19 @@ module Coinbase
       end
 
       # Creates a new Wallet on the specified Network and generate a default address for it.
-      # @param network_id [String] (Optional) the ID of the blockchain network. Defaults to 'base-sepolia'.
+      # @param network [Coinbase::Network, Symbol] (Optional) The network object or ID to create the
+      #   Wallet on. When omitted this uses the SDK configured default network.
       # @param interval_seconds [Integer] The interval at which to poll the CDPService for the Wallet to
       # have an active seed, if using a ServerSigner, in seconds
       # @param timeout_seconds [Integer] The maximum amount of time to wait for the ServerSigner to
       # create a seed for the Wallet, in seconds
       # @return [Coinbase::Wallet] the new Wallet
-      def create(network_id: 'base-sepolia', interval_seconds: 0.2, timeout_seconds: 20)
+      def create(network: Coinbase.default_network, interval_seconds: 0.2, timeout_seconds: 20)
         model = Coinbase.call_api do
           wallets_api.create_wallet(
             create_wallet_request: {
               wallet: {
-                network_id: Coinbase.normalize_network(network_id),
+                network_id: Coinbase.normalize_network(network),
                 use_server_signer: Coinbase.use_server_signer?
               }
             }
@@ -107,7 +101,7 @@ module Coinbase
             wallets_api.get_wallet(wallet_id)
           end
 
-          return self if model.server_signer_status == ServerSignerStatus::ACTIVE
+          return self if model.server_signer_status == ServerSigner::Status::ACTIVE
 
           if Time.now - start_time > timeout_seconds
             raise Timeout::Error, 'Wallet creation timed out. Check status of your Server-Signer'
@@ -132,8 +126,7 @@ module Coinbase
       end
     end
 
-    # Returns a new Wallet object. Do not use this method directly. Instead, use User#create_wallet or
-    # User#import_wallet.
+    # Returns a new Wallet object. Do not use this method directly. Instead use Coinbase::Wallet.create.
     # @param model [Coinbase::Client::Wallet] The underlying Wallet object
     # @param seed [String] (Optional) The seed to use for the Wallet. Expects a 32-byte hexadecimal with no 0x prefix.
     #   If nil, a new seed will be generated. If the empty string, no seed is generated, and the Wallet will be
@@ -149,19 +142,98 @@ module Coinbase
       @master = master_node(seed)
     end
 
+    # @!method transfer
+    # Transfers the amount of the Asset from the default address to the specified destination.
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to send
+    # @param asset_id [Symbol] The ID of the Asset to send
+    # @param destination [Wallet | Address | String] The destination of the transfer.
+    #  If a Wallet, sends to the Wallet's default address.
+    #  If a String, interprets it as the address ID.
+    # @param gasless [Boolean] Whether the transfer should be gasless. Defaults to false.
+    # @return [Coinbase::Transfer] The Transfer object.
+    # (see Coinbase::Address::WalletAddress#transfer)
+
+    # @!method trade
+    # Trades the specified amount from one asset to another using the default address.
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to send.
+    # @param from_asset_id [Symbol] The ID of the Asset to trade from.
+    # @param to_asset_id [Symbol] The ID of the Asset to trade to.
+    #  default address. If a String, interprets it as the address ID.
+    # @return [Coinbase::Trade] The Trade object.
+
+    # @!method faucet
+    # Requests funds from the faucet for the Wallet's default address and returns the faucet transaction.
+    # This is only supported on testnet networks.
+    # @return [Coinbase::FaucetTransaction] The successful faucet transaction
+    # @raise [Coinbase::FaucetLimitReachedError] If the faucet limit has been reached for the address or user.
+    # @raise [Coinbase::Client::ApiError] If an unexpected error occurs while requesting faucet funds.
+
+    # @!method stake
+    # Stakes the given amount of the given Asset for the default address.
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to stake.
+    # @param asset_id [Symbol] The ID of the Asset to stake.
+    # @param mode [Symbol] (Optional) The staking mode. Defaults to :default.
+    # @param options [Hash] (Optional) Additional options for the staking operation.
+    # @return [Coinbase::StakingOperation] The stake operation
+
+    # @!method unstake
+    # Unstakes the given amount of the given Asset on the default address.
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to unstake.
+    # @param asset_id [Symbol] The ID of the Asset to unstake.
+    # @param mode [Symbol] (Optional) The staking mode. Defaults to :default.
+    # @param options [Hash] (Optional) Additional options for the unstaking operation.
+    # @return [Coinbase::StakingOperation] The unstake operation
+
+    # @!method claim_stake
+    # Claims stake of the given amount of the given Asset for the default address.
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to claim_stake.
+    # @param asset_id [Symbol] The ID of the Asset to claim_stake.
+    # @param mode [Symbol] (Optional) The staking mode. Defaults to :default.
+    # @param options [Hash] (Optional) Additional options for the unstaking operation.
+    # @return [Coinbase::StakingOperation] The claim_stake operation
+
+    # @!method staking_balances
+    # Retrieves the balances used for staking for the supplied asset for the default address.
+    # @param asset_id [Symbol] The asset to retrieve staking balances for
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the staking operation
+    # @return [Hash] The staking balances
+    # @return [BigDecimal] :stakeable_balance The amount of the asset that can be staked
+    # @return [BigDecimal] :unstakeable_balance The amount of the asset that is currently staked and cannot be unstaked
+    # @return [BigDecimal] :claimable_balance The amount of the asset that can be claimed
+
+    # @!method stakeable_balance
+    # Retrieves the stakeable balance of the supplied asset for the default address.
+    # @param asset_id [Symbol] The asset to retrieve the stakeable balance for
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the staking operation
+    # @return [BigDecimal] The stakeable balance
+
+    # @!method unstakeable_balance
+    # Retrieves the unstakeable balance for the supplied asset.
+    # Currently only the default_address is used to source the unstakeable balance.
+    # @param asset_id [Symbol] The asset to retrieve the unstakeable balance for
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the staking operation
+    # @return [BigDecimal] The unstakeable balance
+
+    # @!method claimable_balance
+    # Retrieves the claimable balance for the supplied asset.
+    # Currently only the default_address is used to source the claimable balance.
+    # @param asset_id [Symbol] The asset to retrieve the claimable balance for
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the staking operation
+    # @return [BigDecimal] The claimable balance
+
+    def_delegators :default_address, :transfer, :trade, :faucet, :stake, :unstake, :claim_stake, :staking_balances,
+                   :stakeable_balance, :unstakeable_balance, :claimable_balance
+
     # Returns the addresses belonging to the Wallet.
     # @return [Array<Coinbase::WalletAddress>] The addresses belonging to the Wallet
     def addresses
-      @addresses ||= begin
-        address_list = Coinbase.call_api do
-          addresses_api.list_addresses(@model.id, { limit: MAX_ADDRESSES })
-        end
+      return @addresses unless @addresses.nil?
 
-        # Build the WalletAddress objects, injecting the key if available.
-        address_list.data.each_with_index.map do |address_model, index|
-          build_wallet_address(address_model, index)
-        end
-      end
+      set_addresses
     end
 
     # Returns the Wallet ID.
@@ -170,10 +242,10 @@ module Coinbase
       @model.id
     end
 
-    # Returns the Network ID of the Wallet.
-    # @return [Symbol] The Network ID
-    def network_id
-      Coinbase.to_sym(@model.network_id)
+    # Returns the Network of the Wallet.
+    # @return [Coinbase::Network] The Network of the Wallet
+    def network
+      @network ||= Coinbase::Network.from_id(@model.network_id)
     end
 
     # Returns the ServerSigner Status of the Wallet.
@@ -207,7 +279,12 @@ module Coinbase
     # Creates a new Address in the Wallet.
     # @return [Address] The new Address
     def create_address
-      opts = { create_address_request: {} }
+      req = {}
+
+      # Ensure that the address cache is set before creating a new address.
+      # This ensures that for a server signer, the addresses have been loaded and we
+      # can create a new address and add it to a cache.
+      set_addresses if @addresses.nil?
 
       unless Coinbase.use_server_signer?
         # The index for the next address is the number of addresses already registered.
@@ -215,22 +292,25 @@ module Coinbase
 
         key = derive_key(private_key_index)
 
-        opts = {
-          create_address_request: {
-            public_key: key.public_key.compressed.unpack1('H*'),
-            attestation: create_attestation(key)
-          }
+        req = {
+          public_key: key.public_key.compressed.unpack1('H*'),
+          attestation: create_attestation(key),
+          address_index: private_key_index
         }
       end
 
       address_model = Coinbase.call_api do
-        addresses_api.create_address(id, opts)
+        addresses_api.create_address(id, { create_address_request: req })
       end
 
-      # Auto-reload wallet to set default address on first address creation.
+      # Default address can be nil because either this is the first address being
+      # created for this wallet or the addresses cache has not yet been loaded.
+
+      # If the default address is nil, we must reload the wallet model after creating
+      # the address, in order for the default address to be set.
       reload if default_address.nil?
 
-      # Cache the address in our memoized list
+      # The addreses cache is already created, so we can add the new address to the cache.
       address = WalletAddress.new(address_model, key)
       @addresses << address
       address
@@ -272,106 +352,8 @@ module Coinbase
       Coinbase::Balance.from_model_and_asset_id(response, asset_id).amount
     end
 
-    # Transfers the given amount of the given Asset to the specified address or wallet.
-    # Only same-network Transfers are supported. Currently only the default_address is used to source the Transfer.
-    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to send
-    # @param asset_id [Symbol] The ID of the Asset to send
-    # @param destination [Wallet | Address | String] The destination of the transfer. If a Wallet, sends to the Wallet's
-    #  default address. If a String, interprets it as the address ID.
-    # @return [Coinbase::Transfer] The Transfer object.
-    def transfer(amount, asset_id, destination)
-      default_address.transfer(amount, asset_id, destination)
-    end
-
-    # Trades the given amount of the given Asset for another Asset.
-    # Currently only the default_address is used to source the Trade
-    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to send.
-    # @param from_asset_id [Symbol] The ID of the Asset to trade from. For Ether, :eth, :gwei, and :wei are supported.
-    # @param to_asset_id [Symbol] The ID of the Asset to trade to. For Ether, :eth, :gwei, and :wei are supported.
-    #  default address. If a String, interprets it as the address ID.
-    # @return [Coinbase::Trade] The Trade object.
-    def trade(amount, from_asset_id, to_asset_id)
-      default_address.trade(amount, from_asset_id, to_asset_id)
-    end
-
-    # Stakes the given amount of the given Asset.
-    # Currently only the default_address is used to source the Stake.
-    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to stake.
-    # @param asset_id [Symbol] The ID of the Asset to stake.
-    # @param mode [Symbol] (Optional) The staking mode. Defaults to :default.
-    # @param options [Hash] (Optional) Additional options for the staking operation.
-    # @return [Coinbase::StakingOperation] The stake operation
-    def stake(amount, asset_id, mode: :default, options: {})
-      default_address.stake(amount, asset_id, mode: mode, options: options)
-    end
-
-    # Unstakes the given amount of the given Asset.
-    # Currently only the default_address is used to source the Unstake.
-    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to unstake.
-    # @param asset_id [Symbol] The ID of the Asset to unstake.
-    # @param mode [Symbol] (Optional) The staking mode. Defaults to :default.
-    # @param options [Hash] (Optional) Additional options for the unstaking operation.
-    # @return [Coinbase::StakingOperation] The unstake operation
-    def unstake(amount, asset_id, mode: :default, options: {})
-      default_address.unstake(amount, asset_id, mode: mode, options: options)
-    end
-
-    # Claims stake of the given amount of the given Asset.
-    # Currently only the default_address is used as the source for claim_stake.
-    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to claim_stake.
-    # @param asset_id [Symbol] The ID of the Asset to claim_stake.
-    # @param mode [Symbol] (Optional) The staking mode. Defaults to :default.
-    # @param options [Hash] (Optional) Additional options for the unstaking operation.
-    # @return [Coinbase::StakingOperation] The claim_stake operation
-    def claim_stake(amount, asset_id, mode: :default, options: {})
-      default_address.claim_stake(amount, asset_id, mode: mode, options: options)
-    end
-
-    # Retrieves the balances used for staking for the supplied asset.
-    # Currently only the default_address is used to source the staking balances.
-    # @param asset_id [Symbol] The asset to retrieve staking balances for
-    # @param mode [Symbol] The staking mode. Defaults to :default.
-    # @param options [Hash] Additional options for the staking operation
-    # @return [Hash] The staking balances
-    # @return [BigDecimal] :stakeable_balance The amount of the asset that can be staked
-    # @return [BigDecimal] :unstakeable_balance The amount of the asset that is currently staked and cannot be unstaked
-    # @return [BigDecimal] :claimable_balance The amount of the asset that can be claimed
-    def staking_balances(asset_id, mode: :default, options: {})
-      default_address.staking_balances(asset_id, mode: mode, options: options)
-    end
-
-    # Retrieves the stakeable balance for the supplied asset.
-    # Currently only the default_address is used to source the stakeable balance.
-    # @param asset_id [Symbol] The asset to retrieve the stakeable balance for
-    # @param mode [Symbol] The staking mode. Defaults to :default.
-    # @param options [Hash] Additional options for the staking operation
-    # @return [BigDecimal] The stakeable balance
-    def stakeable_balance(asset_id, mode: :default, options: {})
-      default_address.stakeable_balance(asset_id, mode: mode, options: options)
-    end
-
-    # Retrieves the unstakeable balance for the supplied asset.
-    # Currently only the default_address is used to source the unstakeable balance.
-    # @param asset_id [Symbol] The asset to retrieve the unstakeable balance for
-    # @param mode [Symbol] The staking mode. Defaults to :default.
-    # @param options [Hash] Additional options for the staking operation
-    # @return [BigDecimal] The unstakeable balance
-    def unstakeable_balance(asset_id, mode: :default, options: {})
-      default_address.unstakeable_balance(asset_id, mode: mode, options: options)
-    end
-
-    # Retrieves the claimable balance for the supplied asset.
-    # Currently only the default_address is used to source the claimable balance.
-    # @param asset_id [Symbol] The asset to retrieve the claimable balance for
-    # @param mode [Symbol] The staking mode. Defaults to :default.
-    # @param options [Hash] Additional options for the staking operation
-    # @return [BigDecimal] The claimable balance
-    def claimable_balance(asset_id, mode: :default, options: {})
-      default_address.claimable_balance(asset_id, mode: mode, options: options)
-    end
-
     # Exports the Wallet's data to a Data object.
-    # @return [Data] The Wallet data
+    # @return [Coinbase::Wallet::Data] The Wallet data
     def export
       # TODO: Improve this check by relying on the backend data to decide whether a wallet is server-signer backed.
       raise 'Cannot export data for Server-Signer backed Wallet' if Coinbase.use_server_signer?
@@ -381,11 +363,6 @@ module Coinbase
       Data.new(wallet_id: id, seed: @master.seed_hex)
     end
 
-    # Requests funds from the faucet for the Wallet's default address and returns the faucet transaction.
-    # This is only supported on testnet networks.
-    # @return [Coinbase::FaucetTransaction] The successful faucet transaction
-    # @raise [Coinbase::FaucetLimitReachedError] If the faucet limit has been reached for the address or user.
-    # @raise [Coinbase::Client::ApiError] If an unexpected error occurs while requesting faucet funds.
     def faucet
       Coinbase.call_api do
         Coinbase::FaucetTransaction.new(addresses_api.request_faucet_funds(id, default_address.id))
@@ -433,9 +410,7 @@ module Coinbase
         iv: iv
       }
 
-      File.open(file_path, 'w') do |file|
-        file.write(JSON.pretty_generate(existing_seeds_in_store))
-      end
+      File.write(file_path, JSON.pretty_generate(existing_seeds_in_store))
 
       "Successfully saved seed for wallet #{id} to #{file_path}."
     end
@@ -482,8 +457,12 @@ module Coinbase
     # Returns a String representation of the Wallet.
     # @return [String] a String representation of the Wallet
     def to_s
-      "Coinbase::Wallet{wallet_id: '#{id}', network_id: '#{network_id}', " \
-        "default_address: '#{@model.default_address&.address_id}'}"
+      Coinbase.pretty_print_object(
+        self.class,
+        id: id,
+        network_id: network.id,
+        default_address: @model.default_address&.address_id
+      )
     end
 
     # Same as to_s.
@@ -492,32 +471,6 @@ module Coinbase
       to_s
     end
 
-    # The data required to recreate a Wallet.
-    class Data
-      attr_reader :wallet_id, :seed
-
-      # Returns a new Data object.
-      # @param wallet_id [String] The ID of the Wallet
-      # @param seed [String] The seed of the Wallet
-      def initialize(wallet_id:, seed:)
-        @wallet_id = wallet_id
-        @seed = seed
-      end
-
-      # Converts the Data object to a Hash.
-      # @return [Hash] The Hash representation of the Data object
-      def to_hash
-        { wallet_id: wallet_id, seed: seed }
-      end
-
-      # Creates a Data object from the given Hash.
-      # @param data [Hash] The Hash to create the Data object from
-      # @return [Data] The new Data object
-      def self.from_hash(data)
-        Data.new(wallet_id: data['wallet_id'], seed: data['seed'])
-      end
-    end
-
     private
 
     # Reloads the Wallet with the latest data.
@@ -538,13 +491,11 @@ module Coinbase
     end
 
     def address_path_prefix
-      # TODO: Push this logic to the backend.
-      @address_path_prefix ||= case network_id.to_s.split('_').first
-                               when 'base', 'ethereum'
-                                 "m/44'/60'/0'/0"
-                               else
-                                 raise ArgumentError, "Unsupported network ID: #{network_id}"
-                               end
+      if network.address_path_prefix.nil? || network.address_path_prefix.empty?
+        raise ArgumentError, "Cannot create address for network #{network.id}"
+      end
+
+      network.address_path_prefix
     end
 
     # Derives a key for the given address index.
@@ -626,5 +577,15 @@ module Coinbase
     def wallets_api
       @wallets_api ||= Coinbase::Client::WalletsApi.new(Coinbase.configuration.api_client)
     end
+
+    def set_addresses
+      address_list = Coinbase.call_api do
+        addresses_api.list_addresses(@model.id, { limit: MAX_ADDRESSES })
+      end
+
+      @addresses = address_list.data.each_with_index.map do |address_model, index|
+        build_wallet_address(address_model, index)
+      end
+    end
   end
 end

data/lib/coinbase/webhook.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Coinbase
+  # A representation of a Webhook.
+  # This class provides methods to create, list, update, and delete webhooks
+  # that are used to receive notifications of specific events.
+  class Webhook
+    # Event type for ERC20 transfer
+    ERC20_TRANSFER_EVENT = 'erc20_transfer'
+
+    # Event type for ERC721 transfer
+    ERC721_TRANSFER_EVENT = 'erc721_transfer'
+
+    class << self
+      # Creates a new webhook for a specified network.
+      #
+      # @param network_id [String] The network ID for which the webhook is created.
+      # @param notification_uri [String] The URI where notifications should be sent.
+      # @param event_type [String] The type of event for the webhook. Must be one of the following:
+      #   - `Coinbase::Webhook::ERC20_TRANSFER_EVENT`
+      #   - `Coinbase::Webhook::ERC721_TRANSFER_EVENT`
+      # @param event_filters [Array<Hash>] Filters applied to the events that determine
+      #   which specific events trigger the webhook. Each filter should be a hash that
+      #   can include keys like `contract_address`, `from_address`, or `to_address`.
+      # @return [Coinbase::Webhook] A new instance of Webhook.
+      #
+      # @example Create a new webhook
+      #   webhook = Coinbase::Webhook.create(
+      #     network_id: :ethereum_mainnet,
+      #     notification_uri: 'https://example.com/callback',
+      #     event_type: 'transaction',
+      #     event_filters: [{ 'contract_address' => '0x...', 'from_address' => '0x...', 'to_address' => '0x...' }]
+      #   )
+      def create(network_id:, notification_uri:, event_type:, event_filters:)
+        model = Coinbase.call_api do
+          webhooks_api.create_webhook(
+            create_webhook_request: {
+              network_id: Coinbase.normalize_network(network_id),
+              notification_uri: notification_uri,
+              event_type: event_type,
+              event_filters: event_filters
+            }
+          )
+        end
+
+        new(model)
+      end
+
+      # Enumerates the webhooks.
+      # The result is an enumerator that lazily fetches from the server, and can be iterated over,
+      # converted to an array, etc...
+      # @return [Enumerable<Coinbase::Webhook>] Enumerator that returns webhooks
+      def list
+        Coinbase::Pagination.enumerate(method(:fetch_webhooks_page).to_proc) do |webhook|
+          Coinbase::Webhook.new(webhook)
+        end
+      end
+
+      private
+
+      def webhooks_api
+        Coinbase::Client::WebhooksApi.new(Coinbase.configuration.api_client)
+      end
+
+      def fetch_webhooks_page(page)
+        webhooks_api.list_webhooks({ limit: DEFAULT_PAGE_LIMIT, page: page })
+      end
+    end
+
+    # Initializes a new Webhook object.
+    #
+    # @param model [Coinbase::Client::Webhook] The underlying Webhook object.
+    # @raise [ArgumentError] If the model is not a Coinbase::Client::Webhook.
+    def initialize(model)
+      raise ArgumentError, 'model must be a Webhook' unless model.is_a?(Coinbase::Client::Webhook)
+
+      @model = model
+    end
+
+    # Returns the ID of the webhook.
+    #
+    # @return [String] The ID of the webhook.
+    def id
+      @model.id
+    end
+
+    # Returns the network ID associated with the webhook.
+    #
+    # @return [Symbol] The network ID of the webhook.
+    def network_id
+      Coinbase.to_sym(@model.network_id)
+    end
+
+    # Returns the notification URI of the webhook.
+    #
+    # @return [String] The URI where notifications are sent.
+    def notification_uri
+      @model.notification_uri
+    end
+
+    # Returns the event type of the webhook.
+    #
+    # @return [String] The type of event the webhook listens for.
+    def event_type
+      @model.event_type
+    end
+
+    # Returns the event filters applied to the webhook.
+    #
+    # @return [Array<Coinbase::Client::WebhookEventFilter>] An array of event filters used by the webhook.
+    def event_filters
+      @model.event_filters
+    end
+
+    # Updates the webhook with a new notification URI.
+    #
+    # @param notification_uri [String] The new URI for webhook notifications.
+    # @return [self] Returns the updated Webhook object.
+    #
+    # @example Update the notification URI of a webhook
+    #   webhook.update(notification_uri: 'https://new-url.com/callback')
+    def update(notification_uri:)
+      model = Coinbase.call_api do
+        webhooks_api.update_webhook(
+          id,
+          update_webhook_request: {
+            network_id: network_id,
+            notification_uri: notification_uri,
+            event_type: event_type,
+            event_filters: event_filters.map(&:to_hash)
+          }
+        )
+      end
+
+      @model = model
+
+      self
+    end
+
+    # Deletes the webhook.
+    #
+    # @return [self] Returns the Webhook object with nil attributes.
+    #
+    # @example Delete a webhook
+    #   webhook.delete
+    def delete
+      Coinbase.call_api do
+        webhooks_api.delete_webhook(id)
+      end
+
+      @model = nil
+
+      self
+    end
+
+    # Returns a String representation of the Webhook.
+    # @return [String] a String representation of the Webhook
+    def to_s
+      Coinbase.pretty_print_object(
+        self.class,
+        id: @model.id,
+        network_id: @model.network_id,
+        event_type: @model.event_type,
+        notification_uri: @model.notification_uri,
+        event_filters: @model.event_filters.map(&:to_hash).to_json
+      )
+    end
+
+    # Same as to_s.
+    # @return [String] a String representation of the Webhook
+    def inspect
+      to_s
+    end
+
+    private
+
+    def webhooks_api
+      @webhooks_api ||= Coinbase::Client::WebhooksApi.new(Coinbase.configuration.api_client)
+    end
+  end
+end