Class: Coinbase::SmartContract

Inherits:
Object
  • Object
show all
Defined in:
lib/coinbase/smart_contract.rb

Overview

A representation of a SmartContract on the blockchain.

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(model) ⇒ SmartContract

Returns a new SmartContract object.

Parameters:



259
260
261
262
263
 
# File 'lib/coinbase/smart_contract.rb', line 259

def initialize(model)
  raise unless model.is_a?(Coinbase::Client::SmartContract)

  @model = model
end

Class Method Details

.create_multi_token_contract(address_id:, wallet_id:, uri:) ⇒ SmartContract

Creates a new ERC1155 multi-token contract, that can subsequently be deployed to the blockchain.

Parameters:

  • address_id (String) —

    The address ID of deployer

  • wallet_id (String) —

    The wallet ID of the deployer

  • uri (String) —

    The URI for the token metadata

Returns:

  • (SmartContract) —

    The new ERC1155 Multi-Token SmartContract object



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/coinbase/smart_contract.rb', line 114

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

  new(contract)
end

.create_nft_contract(address_id:, wallet_id:, name:, symbol:, base_uri:) ⇒ SmartContract

Creates a new ERC721 token contract, that can subsequently be deployed to the blockchain.

Parameters:

  • address_id (String) —

    The address ID of deployer

  • wallet_id (String) —

    The wallet ID of the deployer

  • name (String) —

    The name of the token

  • symbol (String) —

    The symbol of the token

  • base_uri (String) —

    The base URI for the token metadata

Returns:



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/coinbase/smart_contract.rb', line 83

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

  new(contract)
end

.create_token_contract(address_id:, wallet_id:, name:, symbol:, total_supply:) ⇒ SmartContract

Creates a new ERC20 token contract, that can subsequently be deployed to the blockchain.

Parameters:

  • address_id (String) —

    The address ID of deployer

  • wallet_id (String) —

    The wallet ID of the deployer

  • name (String) —

    The name of the token

  • symbol (String) —

    The symbol of the token

  • total_supply (String) —

    The total supply of the token, denominate in whole units.

Returns:



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/coinbase/smart_contract.rb', line 50

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

  new(contract)
end

.list_events(network_id:, protocol_name:, contract_address:, contract_name:, event_name:, from_block_height:, to_block_height:) ⇒ Enumerable<Coinbase::ContractEvent>

Returns a list of ContractEvents for the provided network, contract, and event details.

Parameters:

  • network_id (Symbol) —

    The network ID

  • protocol_name (String) —

    The protocol name

  • contract_address (String) —

    The contract address

  • contract_name (String) —

    The contract name

  • event_name (String) —

    The event name

  • from_block_height (Integer) —

    The start block height

  • to_block_height (Integer) —

    The end block height

Returns:



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/coinbase/smart_contract.rb', line 15

def self.list_events(
  network_id:,
  protocol_name:,
  contract_address:,
  contract_name:,
  event_name:,
  from_block_height:,
  to_block_height:
)
  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
      )
    }
  ) do |contract_event|
    Coinbase::ContractEvent.new(contract_event)
  end
end

.read(network:, contract_address:, method:, abi: nil, args: {}) ⇒ Object

Reads data from a deployed smart contract.

Parameters:

  • network (Coinbase::Network, Symbol) —

    The Network or Network ID of the Asset

  • contract_address (String) —

    The address of the deployed contract

  • method (String) —

    The name of the method to call on the contract

  • abi (Array, nil) (defaults to: nil) —

    The ABI of the contract. If nil, the method will attempt to use a cached ABI

  • args (Hash) (defaults to: {}) —

    The arguments to pass to the contract method. The keys should be the argument names, and the values should be the argument values.

Returns:

  • (Object) —

    The result of the contract call, converted to an appropriate Ruby type

Raises:

  • (Coinbase::ApiError) —

    If there’s an error in the API call



145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/coinbase/smart_contract.rb', line 145

def self.read(
  network:,
  contract_address:,
  method:,
  abi: nil,
  args: {}
)
  network = Coinbase::Network.from_id(network)

  response = Coinbase.call_api do
    smart_contracts_api.read_contract(
      network.normalized_id,
      contract_address,
      {
        method: method,
        args: (args || {}).to_json,
        abi: abi&.to_json
      }
    )
  end

  convert_solidity_value(response)
end

Instance Method Details

#abi ⇒ Array<Hash>

Returns the ABI of the Smart Contract.

Returns:

  • (Array<Hash>) —

    The ABI



293
294
295
 
# File 'lib/coinbase/smart_contract.rb', line 293

def abi
  JSON.parse(@model.abi)
end

#contract_address ⇒ String

Returns the contract address of the SmartContract.

Returns:

  • (String) —

    The contract address



281
282
283
 
# File 'lib/coinbase/smart_contract.rb', line 281

def contract_address
  @model.contract_address
end

#deploy! ⇒ SmartContract

Deploys the signed SmartContract to the blockchain.

Returns:

Raises:



342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
 
# File 'lib/coinbase/smart_contract.rb', line 342

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

#deployer_address ⇒ String

Returns the address of the deployer of the SmartContract.

Returns:

  • (String) —

    The deployer address



287
288
289
 
# File 'lib/coinbase/smart_contract.rb', line 287

def deployer_address
  @model.deployer_address
end

#id ⇒ String

Returns the SmartContract ID. NOTE: This is not the contract address and is primarily used before the contract is deployed.

Returns:

  • (String) —

    The SmartContract ID



269
270
271
 
# File 'lib/coinbase/smart_contract.rb', line 269

def id
  @model.smart_contract_id
end

#inspect ⇒ String

Same as to_s.

Returns:

  • (String) —

    a string representation of the SmartContract



402
403
404
 
# File 'lib/coinbase/smart_contract.rb', line 402

def inspect
  to_s
end

#network ⇒ Coinbase::Network

Returns the Network of the SmartContract.

Returns:



275
276
277
 
# File 'lib/coinbase/smart_contract.rb', line 275

def network
  @network ||= Coinbase::Network.from_id(@model.network_id)
end

#options ⇒ Coinbase::Client::SmartContractOptions

Returns the options of the SmartContract.

Returns:



311
312
313
 
# File 'lib/coinbase/smart_contract.rb', line 311

def options
  @model.options
end

#reload ⇒ SmartContract

Reloads the Smart Contract model with the latest version from the server side.

Returns:

  • (SmartContract) —

    The most recent version of Smart Contract from the server



361
362
363
364
365
366
367
368
369
370
371
372
373
 
# File 'lib/coinbase/smart_contract.rb', line 361

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

#sign(key) ⇒ SmartContract

Signs the SmartContract deployment transaction with the given key. This is required before broadcasting the SmartContract.

Parameters:

  • key (Eth::Key) —

    The key to sign the SmartContract with

Returns:

Raises:



333
334
335
336
337
 
# File 'lib/coinbase/smart_contract.rb', line 333

def sign(key)
  raise unless key.is_a?(Eth::Key)

  transaction.sign(key)
end

#status ⇒ String

Returns the status of the SmartContract.

Returns:

  • (String) —

    The status



323
324
325
 
# File 'lib/coinbase/smart_contract.rb', line 323

def status
  transaction.status
end

#to_s ⇒ String

Returns a string representation of the SmartContract.

Returns:

  • (String) —

    a string representation of the SmartContract



408
409
410
411
412
413
414
415
416
417
418
 
# File 'lib/coinbase/smart_contract.rb', line 408

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

#transaction ⇒ Coinbase::Transaction

Returns the transaction.

Returns:



317
318
319
 
# File 'lib/coinbase/smart_contract.rb', line 317

def transaction
  @transaction ||= Coinbase::Transaction.new(@model.transaction)
end

#type ⇒ Coinbase::Client::SmartContractType

Returns the type of the SmartContract.

Returns:



305
306
307
 
# File 'lib/coinbase/smart_contract.rb', line 305

def type
  @model.type
end

#wait!(interval_seconds = 0.2, timeout_seconds = 20) ⇒ SmartContract

Waits until the Smart Contract deployment is signed or failed by polling the server at the given interval. deployment to land on-chain, in seconds

Parameters:

  • interval_seconds (Integer) (defaults to: 0.2) —

    The interval at which to poll the server, in seconds

  • timeout_seconds (Integer) (defaults to: 20) —

    The maximum amount of time to wait for the Smart Contract,

Returns:

Raises:

  • (Timeout::Error) —

    if the Contract Invocation takes longer than the given timeout



381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
 
# File 'lib/coinbase/smart_contract.rb', line 381

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

#wallet_id ⇒ String

Returns the ID of the wallet that deployed the SmartContract.

Returns:

  • (String) —

    The wallet ID



299
300
301
 
# File 'lib/coinbase/smart_contract.rb', line 299

def wallet_id
  @model.wallet_id
end