coinbase-sdk 0.5.0 → 0.7.0

data/lib/coinbase/client.rb

@@ -37,12 +37,14 @@ Coinbase::Client.autoload :CreateAddressRequest, 'coinbase/client/models/create_
 Coinbase::Client.autoload :CreateContractInvocationRequest, 'coinbase/client/models/create_contract_invocation_request'
 Coinbase::Client.autoload :CreatePayloadSignatureRequest, 'coinbase/client/models/create_payload_signature_request'
 Coinbase::Client.autoload :CreateServerSignerRequest, 'coinbase/client/models/create_server_signer_request'
+Coinbase::Client.autoload :CreateSmartContractRequest, 'coinbase/client/models/create_smart_contract_request'
 Coinbase::Client.autoload :CreateStakingOperationRequest, 'coinbase/client/models/create_staking_operation_request'
 Coinbase::Client.autoload :CreateTradeRequest, 'coinbase/client/models/create_trade_request'
 Coinbase::Client.autoload :CreateTransferRequest, 'coinbase/client/models/create_transfer_request'
 Coinbase::Client.autoload :CreateWalletRequest, 'coinbase/client/models/create_wallet_request'
 Coinbase::Client.autoload :CreateWalletRequestWallet, 'coinbase/client/models/create_wallet_request_wallet'
 Coinbase::Client.autoload :CreateWebhookRequest, 'coinbase/client/models/create_webhook_request'
+Coinbase::Client.autoload :DeploySmartContractRequest, 'coinbase/client/models/deploy_smart_contract_request'
 Coinbase::Client.autoload :ERC20TransferEvent, 'coinbase/client/models/erc20_transfer_event'
 Coinbase::Client.autoload :ERC721TransferEvent, 'coinbase/client/models/erc721_transfer_event'
 Coinbase::Client.autoload :Error, 'coinbase/client/models/error'
@@ -58,6 +60,8 @@ Coinbase::Client.autoload :FetchStakingRewards200Response, 'coinbase/client/mode
 Coinbase::Client.autoload :FetchStakingRewardsRequest, 'coinbase/client/models/fetch_staking_rewards_request'
 Coinbase::Client.autoload :GetStakingContextRequest, 'coinbase/client/models/get_staking_context_request'
 Coinbase::Client.autoload :HistoricalBalance, 'coinbase/client/models/historical_balance'
+Coinbase::Client.autoload :MultiTokenContractOptions, 'coinbase/client/models/multi_token_contract_options'
+Coinbase::Client.autoload :NFTContractOptions, 'coinbase/client/models/nft_contract_options'
 Coinbase::Client.autoload :Network, 'coinbase/client/models/network'
 Coinbase::Client.autoload :NetworkIdentifier, 'coinbase/client/models/network_identifier'
 Coinbase::Client.autoload :PayloadSignature, 'coinbase/client/models/payload_signature'
@@ -72,6 +76,10 @@ Coinbase::Client.autoload :ServerSignerList, 'coinbase/client/models/server_sign
 Coinbase::Client.autoload :SignatureCreationEvent, 'coinbase/client/models/signature_creation_event'
 Coinbase::Client.autoload :SignatureCreationEventResult, 'coinbase/client/models/signature_creation_event_result'
 Coinbase::Client.autoload :SignedVoluntaryExitMessageMetadata, 'coinbase/client/models/signed_voluntary_exit_message_metadata'
+Coinbase::Client.autoload :SmartContract, 'coinbase/client/models/smart_contract'
+Coinbase::Client.autoload :SmartContractList, 'coinbase/client/models/smart_contract_list'
+Coinbase::Client.autoload :SmartContractOptions, 'coinbase/client/models/smart_contract_options'
+Coinbase::Client.autoload :SmartContractType, 'coinbase/client/models/smart_contract_type'
 Coinbase::Client.autoload :SponsoredSend, 'coinbase/client/models/sponsored_send'
 Coinbase::Client.autoload :StakingBalance, 'coinbase/client/models/staking_balance'
 Coinbase::Client.autoload :StakingContext, 'coinbase/client/models/staking_context'
@@ -81,6 +89,7 @@ Coinbase::Client.autoload :StakingOperationMetadata, 'coinbase/client/models/sta
 Coinbase::Client.autoload :StakingReward, 'coinbase/client/models/staking_reward'
 Coinbase::Client.autoload :StakingRewardFormat, 'coinbase/client/models/staking_reward_format'
 Coinbase::Client.autoload :StakingRewardUSDValue, 'coinbase/client/models/staking_reward_usd_value'
+Coinbase::Client.autoload :TokenContractOptions, 'coinbase/client/models/token_contract_options'
 Coinbase::Client.autoload :Trade, 'coinbase/client/models/trade'
 Coinbase::Client.autoload :TradeList, 'coinbase/client/models/trade_list'
 Coinbase::Client.autoload :Transaction, 'coinbase/client/models/transaction'
@@ -89,6 +98,7 @@ Coinbase::Client.autoload :TransactionType, 'coinbase/client/models/transaction_
 Coinbase::Client.autoload :Transfer, 'coinbase/client/models/transfer'
 Coinbase::Client.autoload :TransferList, 'coinbase/client/models/transfer_list'
 Coinbase::Client.autoload :UpdateWebhookRequest, 'coinbase/client/models/update_webhook_request'
+Coinbase::Client.autoload :User, 'coinbase/client/models/user'
 Coinbase::Client.autoload :Validator, 'coinbase/client/models/validator'
 Coinbase::Client.autoload :ValidatorDetails, 'coinbase/client/models/validator_details'
 Coinbase::Client.autoload :ValidatorList, 'coinbase/client/models/validator_list'
@@ -98,7 +108,9 @@ Coinbase::Client.autoload :WalletList, 'coinbase/client/models/wallet_list'
 Coinbase::Client.autoload :Webhook, 'coinbase/client/models/webhook'
 Coinbase::Client.autoload :WebhookEventFilter, 'coinbase/client/models/webhook_event_filter'
 Coinbase::Client.autoload :WebhookEventType, 'coinbase/client/models/webhook_event_type'
+Coinbase::Client.autoload :WebhookEventTypeFilter, 'coinbase/client/models/webhook_event_type_filter'
 Coinbase::Client.autoload :WebhookList, 'coinbase/client/models/webhook_list'
+Coinbase::Client.autoload :WebhookWalletActivityFilter, 'coinbase/client/models/webhook_wallet_activity_filter'
 
 # APIs
 Coinbase::Client.autoload :AddressesApi, 'coinbase/client/api/addresses_api'
@@ -109,9 +121,12 @@ Coinbase::Client.autoload :ContractInvocationsApi, 'coinbase/client/api/contract
 Coinbase::Client.autoload :ExternalAddressesApi, 'coinbase/client/api/external_addresses_api'
 Coinbase::Client.autoload :NetworksApi, 'coinbase/client/api/networks_api'
 Coinbase::Client.autoload :ServerSignersApi, 'coinbase/client/api/server_signers_api'
+Coinbase::Client.autoload :SmartContractsApi, 'coinbase/client/api/smart_contracts_api'
 Coinbase::Client.autoload :StakeApi, 'coinbase/client/api/stake_api'
 Coinbase::Client.autoload :TradesApi, 'coinbase/client/api/trades_api'
+Coinbase::Client.autoload :TransactionHistoryApi, 'coinbase/client/api/transaction_history_api'
 Coinbase::Client.autoload :TransfersApi, 'coinbase/client/api/transfers_api'
+Coinbase::Client.autoload :UsersApi, 'coinbase/client/api/users_api'
 Coinbase::Client.autoload :ValidatorsApi, 'coinbase/client/api/validators_api'
 Coinbase::Client.autoload :WalletStakeApi, 'coinbase/client/api/wallet_stake_api'
 Coinbase::Client.autoload :WalletsApi, 'coinbase/client/api/wallets_api'

data/lib/coinbase/contract_invocation.rb

@@ -25,31 +25,30 @@ module Coinbase
         address_id:,
         wallet_id:,
         contract_address:,
-        abi:,
         method:,
-        amount:,
-        asset_id:,
         network:,
-        args: {}
+        args: {},
+        amount: nil,
+        abi: nil,
+        asset_id: nil
       )
-        atomic_amount = nil
+        req = {
+          method: method,
+          args: args.to_json,
+          contract_address: contract_address
+        }
 
+        req[:abi] = abi.to_json unless abi.nil?
+
+        # For payable contract invocations, convert the amount to atomic units of specified asset.
         if amount && asset_id && network
-          network = Coinbase::Network.from_id(network)
-          asset = network.get_asset(asset_id)
-          atomic_amount = asset.to_atomic_amount(amount).to_i_to_s
+          asset = Coinbase::Asset.fetch(network, asset_id)
+
+          req[:amount] = asset.to_atomic_amount(amount).to_i.to_s
         end
 
         model = Coinbase.call_api do
-          contract_invocation_api.create_contract_invocation(
-            wallet_id,
-            address_id,
-            contract_address: contract_address,
-            abi: abi.to_json,
-            method: method,
-            args: args.to_json,
-            amount: atomic_amount
-          )
+          contract_invocation_api.create_contract_invocation(wallet_id, address_id, **req)
         end
 
         new(model)

data/lib/coinbase/smart_contract.rb

@@ -23,63 +23,118 @@ module Coinbase
     )
       Coinbase::Pagination.enumerate(
         lambda { |page|
-          list_events_page(network_id, protocol_name, contract_address, contract_name, event_name, from_block_height,
-                           to_block_height, page)
+          list_events_page(
+            network_id,
+            protocol_name,
+            contract_address,
+            contract_name,
+            event_name,
+            from_block_height,
+            to_block_height,
+            page
+          )
         }
       ) do |contract_event|
         Coinbase::ContractEvent.new(contract_event)
       end
     end
 
-    # Returns a new SmartContract object.
-    # @param model [Coinbase::Client::SmartContract] The underlying SmartContract object
-    def initialize(model)
-      @model = model
-    end
+    # Creates a new ERC20 token contract, that can subsequently be deployed to
+    # the blockchain.
+    # @param address_id [String] The address ID of deployer
+    # @param wallet_id [String] The wallet ID of the deployer
+    # @param name [String] The name of the token
+    # @param symbol [String] The symbol of the token
+    # @param total_supply [String] The total supply of the token, denominate in whole units.
+    # @return [SmartContract] The new ERC20 Token SmartContract object
+    def self.create_token_contract(
+      address_id:,
+      wallet_id:,
+      name:,
+      symbol:,
+      total_supply:
+    )
+      contract = Coinbase.call_api do
+        smart_contracts_api.create_smart_contract(
+          wallet_id,
+          address_id,
+          {
+            type: Coinbase::Client::SmartContractType::ERC20,
+            options: Coinbase::Client::TokenContractOptions.new(
+              name: name,
+              symbol: symbol,
+              total_supply: BigDecimal(total_supply).to_i.to_s
+            ).to_body
+          }
+        )
+      end
 
-    # Returns the network ID of the SmartContract.
-    # @return [String] The network ID
-    def network_id
-      Coinbase.to_sym(@model.network_id)
+      new(contract)
     end
 
-    # Returns the protocol name of the SmartContract.
-    # @return [String] The protocol name
-    def protocol_name
-      @model.protocol_name
-    end
+    # Creates a new ERC721 token contract, that can subsequently be deployed to
+    # the blockchain.
+    # @param address_id [String] The address ID of deployer
+    # @param wallet_id [String] The wallet ID of the deployer
+    # @param name [String] The name of the token
+    # @param symbol [String] The symbol of the token
+    # @param base_uri [String] The base URI for the token metadata
+    # @return [SmartContract] The new ERC721 Token SmartContract object
+    def self.create_nft_contract(
+      address_id:,
+      wallet_id:,
+      name:,
+      symbol:,
+      base_uri:
+    )
+      contract = Coinbase.call_api do
+        smart_contracts_api.create_smart_contract(
+          wallet_id,
+          address_id,
+          {
+            type: Coinbase::Client::SmartContractType::ERC721,
+            options: Coinbase::Client::NFTContractOptions.new(
+              name: name,
+              symbol: symbol,
+              base_uri: base_uri
+            ).to_body
+          }
+        )
+      end
 
-    # Returns the contract name of the SmartContract.
-    # @return [String] The contract name
-    def contract_name
-      @model.contract_name
+      new(contract)
     end
 
-    # Returns the address of the SmartContract.
-    # @return [String] The contract address
-    def address
-      @model.address
-    end
-
-    # Returns a string representation of the SmartContract.
-    # @return [String] a string representation of the SmartContract
-    def to_s
-      "Coinbase::SmartContract{
-        network_id: '#{network_id}',
-        protocol_name: '#{protocol_name}',
-        contract_name: '#{contract_name}',
-        address: '#{address}'}"
-    end
+    def self.create_multi_token_contract(
+      address_id:,
+      wallet_id:,
+      uri:
+    )
+      contract = Coinbase.call_api do
+        smart_contracts_api.create_smart_contract(
+          wallet_id,
+          address_id,
+          {
+            type: Coinbase::Client::SmartContractType::ERC1155,
+            options: Coinbase::Client::MultiTokenContractOptions.new(
+              uri: uri
+            ).to_body
+          }
+        )
+      end
 
-    # Same as to_s.
-    # @return [String] a string representation of the SmartContract
-    def inspect
-      to_s
+      new(contract)
     end
 
     def self.contract_events_api
       Coinbase::Client::ContractEventsApi.new(Coinbase.configuration.api_client)
     end
+    private_class_method :contract_events_api
+
+    def self.smart_contracts_api
+      Coinbase::Client::SmartContractsApi.new(Coinbase.configuration.api_client)
+    end
+    private_class_method :smart_contracts_api
 
     def self.list_events_page(
       network_id,
@@ -102,5 +157,175 @@ module Coinbase
         { next_page: page }
       )
     end
+    private_class_method :list_events_page
+
+    # Returns a new SmartContract object.
+    # @param model [Coinbase::Client::SmartContract] The underlying SmartContract object
+    def initialize(model)
+      raise unless model.is_a?(Coinbase::Client::SmartContract)
+
+      @model = model
+    end
+
+    # Returns the SmartContract ID.
+    # NOTE: This is not the contract address and is primarily used before
+    # the contract is deployed.
+    # @return [String] The SmartContract ID
+    def id
+      @model.smart_contract_id
+    end
+
+    # Returns the Network of the SmartContract.
+    # @return [Coinbase::Network] The Network
+    def network
+      @network ||= Coinbase::Network.from_id(@model.network_id)
+    end
+
+    # Returns the contract address of the SmartContract.
+    # @return [String] The contract address
+    def contract_address
+      @model.contract_address
+    end
+
+    # Returns the address of the deployer of the SmartContract.
+    # @return [String] The deployer address
+    def deployer_address
+      @model.deployer_address
+    end
+
+    # Returns the ABI of the Smart Contract.
+    # @return [Array<Hash>] The ABI
+    def abi
+      JSON.parse(@model.abi)
+    end
+
+    # Returns the ID of the wallet that deployed the SmartContract.
+    # @return [String] The wallet ID
+    def wallet_id
+      @model.wallet_id
+    end
+
+    # Returns the type of the SmartContract.
+    # @return [Coinbase::Client::SmartContractType] The SmartContract type
+    def type
+      @model.type
+    end
+
+    # Returns the options of the SmartContract.
+    # @return [Coinbase::Client::SmartContractOptions] The SmartContract options
+    def options
+      @model.options
+    end
+
+    # Returns the transaction.
+    # @return [Coinbase::Transaction] The SmartContracy deployment transaction
+    def transaction
+      @transaction ||= Coinbase::Transaction.new(@model.transaction)
+    end
+
+    # Returns the status of the SmartContract.
+    # @return [String] The status
+    def status
+      transaction.status
+    end
+
+    # Signs the SmartContract deployment transaction with the given key.
+    # This is required before broadcasting the SmartContract.
+    # @param key [Eth::Key] The key to sign the SmartContract with
+    # @return [SmartContract] The SmartContract object
+    # @raise [RuntimeError] If the key is not an Eth::Key
+    # @raise [Coinbase::AlreadySignedError] If the SmartContract has already been signed
+    def sign(key)
+      raise unless key.is_a?(Eth::Key)
+
+      transaction.sign(key)
+    end
+
+    # Deploys the signed SmartContract to the blockchain.
+    # @return [SmartContract] The SmartContract object
+    # @raise [Coinbase::TransactionNotSignedError] If the SmartContract has not been signed
+    def deploy!
+      raise TransactionNotSignedError unless transaction.signed?
+
+      @model = Coinbase.call_api do
+        smart_contracts_api.deploy_smart_contract(
+          wallet_id,
+          deployer_address,
+          id,
+          { signed_payload: transaction.signature }
+        )
+      end
+
+      @transaction = Coinbase::Transaction.new(@model.transaction)
+
+      self
+    end
+
+    # Reloads the Smart Contract model with the latest version from the server side.
+    # @return [SmartContract] The most recent version of Smart Contract from the server
+    def reload
+      @model = Coinbase.call_api do
+        smart_contracts_api.get_smart_contract(
+          wallet_id,
+          deployer_address,
+          id
+        )
+      end
+
+      @transaction = Coinbase::Transaction.new(@model.transaction)
+
+      self
+    end
+
+    # Waits until the Smart Contract deployment is signed or failed by polling the server at the given interval.
+    # @param interval_seconds [Integer] The interval at which to poll the server, in seconds
+    # @param timeout_seconds [Integer] The maximum amount of time to wait for the Smart Contract,
+    # deployment to land on-chain, in seconds
+    # @return [SmartContract] The completed Smart Contract object
+    # @raise [Timeout::Error] if the Contract Invocation takes longer than the given timeout
+    def wait!(interval_seconds = 0.2, timeout_seconds = 20)
+      start_time = Time.now
+
+      loop do
+        reload
+
+        return self if transaction.terminal_state?
+
+        if Time.now - start_time > timeout_seconds
+          raise Timeout::Error,
+                'SmartContract deployment timed out. Try waiting again.'
+        end
+
+        self.sleep interval_seconds
+      end
+
+      self
+    end
+
+    # Same as to_s.
+    # @return [String] a string representation of the SmartContract
+    def inspect
+      to_s
+    end
+
+    # Returns a string representation of the SmartContract.
+    # @return [String] a string representation of the SmartContract
+    def to_s
+      Coinbase.pretty_print_object(
+        self.class,
+        network: network.id,
+        contract_address: contract_address,
+        deployer_address: deployer_address,
+        type: type,
+        status: status,
+        options: Coinbase.pretty_print_object('Options', **options)
+      )
+    end
+
+    private
+
+    def smart_contracts_api
+      @smart_contracts_api ||= Coinbase::Client::SmartContractsApi.new(Coinbase.configuration.api_client)
+    end
   end
 end

data/lib/coinbase/transaction.rb

@@ -147,6 +147,9 @@ module Coinbase
     # Signs the Transaction with the provided key and returns the hex signing payload.
     # @return [String] The hex-encoded signed payload
     def sign(key)
+      raise 'Invalid key type' unless key.is_a?(Eth::Key)
+      raise Coinbase::AlreadySignedError if signed?
+
       raw.sign(key)
 
       signature

data/lib/coinbase/transfer.rb

@@ -84,7 +84,7 @@ module Coinbase
     end
 
     # Returns the Network of the Transfer.
-    # @return [Symbol] The Network
+    # @return [Coinbase::Network] The Network
     def network
       @network ||= Coinbase::Network.from_id(@model.network_id)
     end

data/lib/coinbase/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coinbase
-  VERSION = '0.5.0'
+  VERSION = '0.7.0'
 end

data/lib/coinbase/wallet.rb

@@ -234,10 +234,33 @@ module Coinbase
     # @!method invoke_contract
     # Invokes a contract with the given ABI, method, and arguments.
     # @param abi [Array<Hash>] The ABI of the contract
-    #
+
+    # @!method deploy_token
+    # Deploys a new ERC20 token contract with the given name, symbol, and total supply.
+    # @param name [String] The name of the token.
+    # @param symbol [String] The symbol of the token.
+    # @param total_supply [Integer, BigDecimal] The total supply of the token, denominated in
+    # whole units.
+    # @return [Coinbase::SmartContract] The deployed token contract.
+    # @raise [AddressCannotSignError] if the Address does not have a private key backing it.
+
+    # @!method deploy_nft
+    # Deploys a new ERC721 NFT contract with the given name, symbol, and base URI.
+    # @param name [String] The name of the NFT contract.
+    # @param symbol [String] The symbol of the NFT contract.
+    # @param base_uri [String] The base URI for the NFT contract.
+    # @return [Coinbase::SmartContract] The deployed NFT contract.
+    # @raise [AddressCannotSignError] if the Address does not have a private key backing it.
+
+    # @!method deploy_multi_token
+    # Deploys a new ERC1155 multi-token contract with the given URI.
+    # @param uri [String] The URI for the token metadata, where {id} will be replaced with the token ID.
+    # @return [Coinbase::SmartContract] The deployed multi-token contract.
+    # @raise [AddressCannotSignError] if the Address does not have a private key backing it.
 
     def_delegators :default_address, :transfer, :trade, :faucet, :stake, :unstake, :claim_stake, :staking_balances,
-                   :stakeable_balance, :unstakeable_balance, :claimable_balance, :sign_payload, :invoke_contract
+                   :stakeable_balance, :unstakeable_balance, :claimable_balance, :sign_payload, :invoke_contract,
+                   :deploy_token, :deploy_nft, :deploy_multi_token
 
     # Returns the addresses belonging to the Wallet.
     # @return [Array<Coinbase::WalletAddress>] The addresses belonging to the Wallet
@@ -459,6 +482,22 @@ module Coinbase
       "Successfully loaded seed for wallet #{id} from #{file_path}."
     end
 
+    # Creates a new webhook on the current wallet for tracking wallet activity events.
+    #
+    # @param notification_uri [String] The URI to which the webhook notifications will be sent.
+    #
+    # @return [Coinbase::Client::Webhook] The newly created webhook instance.
+    def create_webhook(notification_uri:)
+      Coinbase.call_api do
+        webhooks_api.create_wallet_webhook(
+          id,
+          create_wallet_webhook_request: {
+            notification_uri: notification_uri
+          }
+        )
+      end
+    end
+
     # Returns a String representation of the Wallet.
     # @return [String] a String representation of the Wallet
     def to_s
@@ -583,6 +622,10 @@ module Coinbase
       @wallets_api ||= Coinbase::Client::WalletsApi.new(Coinbase.configuration.api_client)
     end
 
+    def webhooks_api
+      @webhooks_api ||= Coinbase::Client::WebhooksApi.new(Coinbase.configuration.api_client)
+    end
+
     def set_addresses
       address_list = Coinbase.call_api do
         addresses_api.list_addresses(@model.id, { limit: MAX_ADDRESSES })

data/lib/coinbase/webhook.rb

@@ -22,8 +22,6 @@ module Coinbase
       # @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`.
-      # @param signature_header [String] The custom header to be used for x-webhook-signature header on callbacks,
-      #   so developers can verify the requests are coming from Coinbase.
       # @return [Coinbase::Webhook] A new instance of Webhook.
       #
       # @example Create a new webhook
@@ -31,18 +29,16 @@ module Coinbase
       #     network_id: :ethereum_mainnet,
       #     notification_uri: 'https://example.com/callback',
       #     event_type: 'transaction',
-      #     event_filters: [{ 'contract_address' => '0x...', 'from_address' => '0x...', 'to_address' => '0x...' }],
-      #     signature_header: 'example_header'
+      #     event_filters: [{ 'contract_address' => '0x...', 'from_address' => '0x...', 'to_address' => '0x...' }]
       #   )
-      def create(network_id:, notification_uri:, event_type:, event_filters:, signature_header: '')
+      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,
-              signature_header: signature_header
+              event_filters: event_filters
             }
           )
         end