Class: Steem::Broadcast

Inherits:
Object
  • Object
show all
Extended by:
Retriable, Utils
Defined in:
lib/steem/broadcast.rb

Overview

These class methods make it simple to do things like broacast a Broadcast.vote or Broadcast.comment operation. They accept all of the fields expected by the blockchain plus the following additional options:

* wif
* url (optional)
* database_api (optional)
* block_api (optional)
* network_broadcast_api (optional)
* pretend (optional)

These options are not sent in the broadcast. The ‘wif` authorities can be posting, active, and owner.

Setting ‘url` will allow you to specify a different node instead of taking the default: (ChainConfig::NETWORKS_STEEM_DEFAULT_NODE).

Setting ‘database_api`, `block_api`, and `network_broadcast_api` is optional, doing so will allow you to override the default node and/or the RPC Client.

When passing the ‘pretend` field, if it is set to True, nothing is broadcasted, but the `wif` is checked for the proper authority.

For details on what to pass to these methods, check out the Steem Developer Portal Broadcast Operations page.

Constant Summary collapse

DEFAULT_MAX_ACCEPTED_PAYOUT = 
Type::Amount.new(amount: '1000000000', precision: 3, nai: '@@000000013')

Constants included from Retriable

Retriable::MAX_BACKOFF, Retriable::MAX_RETRY_COUNT, Retriable::MAX_RETRY_ELAPSE, Retriable::RETRYABLE_EXCEPTIONS

Class Method Summary collapse

Methods included from Retriable

can_retry?

Methods included from Utils

hexlify, unhexlify

Class Method Details

.account_create(options, &block) ⇒ Object

Create an account.

options = {
  wif: wif,
  params: {
    fee: '1.000 STEEM',
    creator: ,
    new_account_name: ,
    owner: {
      weight_threshold: 1,
      account_auths: [],
      key_auths: [[owner_public_key, 1]],
    },
    active: {
      weight_threshold: 1,
      account_auths: [],
      key_auths: [[active_public_key, 1]],
    },
    posting: {
      weight_threshold: 1,
      account_auths: [],
      key_auths: [[posting_public_key, 1]],
    },
    memo_key: memo_public_key,
    json_metadata: '{}'
  }
}

Steem::Broadcast.(options)

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :fee (String)

    • :creator (String)

    • :new_account_name (String)

    • :owner (Hash)

    • :active (Hash)

    • :posting (Hash)

    • :memo_key (String)

    • :metadata (Hash) Metadata of the account, becomes ‘json_metadata`.

    • :json_metadata (String) String version of ‘metadata` (use one or the other).

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
 
# File 'lib/steem/broadcast.rb', line 496

def self.(options, &block)
  required_fields = %i(fee creator new_account_name owner active posting memo_key json_metadata)
  params = options[:params]
  
  if !!params[:metadata] && !!params[:json_metadata]
    raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
  end
  
  metadata = params.delete(:metadata) || {}
  metadata ||= (JSON[params[:json_metadata]] || nil) || {}
  params[:json_metadata] = metadata.to_json
  
  check_required_fields(params, *required_fields)
  
  params[:fee] = normalize_amount(options.merge amount: params[:fee])
  
  ops = [[:account_create, params]]
  
  process(options.merge(ops: ops), &block)
end

.account_create_with_delegation(options, &block) ⇒ Object

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :fee (String)

    • :delegation (String)

    • :creator (String)

    • :new_account_name (String)

    • :owner (String)

    • :active (String)

    • :posting (String)

    • :memo_key (String)

    • :metadata (Hash) Metadata of the account, becomes ‘json_metadata`.

    • :json_metadata (String) String version of ‘metadata` (use one or the other).

    • :extensions (Array)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
 
# File 'lib/steem/broadcast.rb', line 1198

def self.(options, &block)
  required_fields = %i(fee delegation creator new_account_name owner active posting memo_key)
  params = options[:params]
  
  if !!params[:metadata] && !!params[:json_metadata]
    raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
  end
  
  metadata = params.delete(:metadata) || {}
  metadata ||= (JSON[params[:json_metadata]] || nil) || {}
  params[:json_metadata] = metadata.to_json
  
  check_required_fields(params, *required_fields)
  
  params[:fee] = normalize_amount(options.merge amount: params[:fee])
  params[:delegation] = normalize_amount(options.merge amount: params[:delegation])
  params[:extensions] ||= []
  
  ops = [[:account_create_with_delegation, params]]
  
  process(options.merge(ops: ops), &block)
end

.account_update(options, &block) ⇒ Object

Update an account.

options = {
  wif: wif,
  params: {
    account: ,
    owner: {
      weight_threshold: 1,
      account_auths: [],
      key_auths: [[owner_public_key, 1]],
    },
     active: {
      weight_threshold: 1,
      account_auths: [],
       key_auths: [[active_public_key, 1]],
    },
    posting: {
      weight_threshold: 1,
      account_auths: [],
      key_auths: [[posting_public_key, 1]],
    },
    memo_key: memo_public_key,
    json_metadata: '{}'
  }
}

Steem::Broadcast.(options)

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :account (String)

    • :owner (Hash) (optional)

    • :active (Hash) (optional)

    • :posting (Hash) (optional)

    • :memo_key (String) (optional)

    • :metadata (Hash) Metadata of the account, becomes ‘json_metadata`.

    • :json_metadata (String) String version of ‘metadata` (use one or the other).

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
 
# File 'lib/steem/broadcast.rb', line 618

def self.(options, &block)
  required_fields = %i(account)
  params = options[:params]
  
  if !!params[:metadata] && !!params[:json_metadata]
    raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
  end
  
  metadata = params.delete(:metadata) || {}
  metadata ||= (JSON[params[:json_metadata]] || nil) || {}
  params[:json_metadata] = metadata.to_json
  
  check_required_fields(params, *required_fields)
  
  ops = [[:account_update, params]]
  
  process(options.merge(ops: ops), &block)
end

.account_witness_proxy(options, &block) ⇒ Object

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :account (String)

    • :proxy (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



776
777
778
779
780
781
782
783
784
 
# File 'lib/steem/broadcast.rb', line 776

def self.(options, &block)
  required_fields = %i(account proxy)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:account_witness_proxy, params]]
  
  process(options.merge(ops: ops), &block)
end

.account_witness_vote(options, &block) ⇒ Object

All accounts with a VFS (Vesting Fund Shares) can vote for or against any witness.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :account (String)

    • :witness (String)

    • :approve (Boolean)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



759
760
761
762
763
764
765
766
767
 
# File 'lib/steem/broadcast.rb', line 759

def self.(options, &block)
  required_fields = %i(account witness approve)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:account_witness_vote, params]]
  
  process(options.merge(ops: ops), &block)
end

.cancel_transfer_from_savings(options, &block) ⇒ Object

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :from (String)

    • :request_id (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



1128
1129
1130
1131
1132
1133
1134
1135
1136
 
# File 'lib/steem/broadcast.rb', line 1128

def self.cancel_transfer_from_savings(options, &block)
  required_fields = %i(from request_id)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:cancel_transfer_from_savings, params]]
  
  process(options.merge(ops: ops), &block)
end

.change_recovery_account(options, &block) ⇒ Object

Each account lists another account as their recovery account.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Posting wif

  • :params (Hash) —

    • :account_to_recover (String)

    • :new_recovery_account (String)

    • :extensions (Array) (optional)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



936
937
938
939
940
941
942
943
944
945
946
 
# File 'lib/steem/broadcast.rb', line 936

def self.(options, &block)
  required_fields = %i(account_to_recover)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:new_recovery_account] ||= ''
  params[:extensions] ||= []
  ops = [[:change_recovery_account, params]]
  
  process(options.merge(ops: ops), &block)
end

.claim_account(options, &block) ⇒ Object

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :creator (String)

    • :fee (String)

    • :extensions (Array)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
 
# File 'lib/steem/broadcast.rb', line 1229

def self.(options, &block)
  required_fields = %i(creator fee)
  params = options[:params]
  
  check_required_fields(params, *required_fields)
  
  params[:fee] = normalize_amount(options.merge amount: params[:fee])
  params[:extensions] ||= []
  
  ops = [[:claim_account, params]]
  
  process(options.merge(ops: ops), &block)
end

.comment(options, &block) ⇒ Object

Creates a post/comment. This method simplifies content creation by combining ‘comment` and `comment_options` into one transaction.

options = {
  wif: wif,
  params: {
    author: author,
    title: 'This is my fancy post title.',
    body: 'This is my fancy post body.',
    metadata: {
      tags: %w(these are my fancy tags)
    } 
  }
}

Steem::Broadcast.comment(options)

options = {
  wif: wif,
  params: {
    author: author,
    title: 'This is my fancy post title.',
    body: 'This is my fancy post body.',
    metadata: {
      tags: %w(these are my fancy tags)
    },
    beneficiaries: [
      {account: "david", weight: 500},
      {account: "erin", weight: 500},
      {account: "faythe", weight: 1000},
      {account: "frank", weight: 500}
    ]
  }
}

Steem::Broadcast.comment(options)

In addition to the above denormalized ‘comment_options` fields, the author can also vote for the content in the same transaction by setting `author_vote_weight`:

options = {
  wif: wif,
  params: {
    author: author,
    title: 'This is my fancy post title.',
    body: 'This is my fancy post body.',
    metadata: {
      tags: %w(these are my fancy tags)
    },
    author_vote_weight: 10000
  }
}

Steem::Broadcast.comment(options)

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Posting wif

  • :params (Hash) —

    • :author (String)

    • :title (String) Title of the content.

    • :body (String) Body of the content.

    • :metadata (Hash) Metadata of the content, becomes ‘json_metadata`.

    • :json_metadata (String) String version of ‘metadata` (use one or the other).

    • :permlink (String) (automatic) Permlink of the content, defaults to formatted title.

    • :parent_permlink (String) (automatic) Parent permlink of the content, defaults to first tag.

    • :parent_author (String) (optional) Parent author of the content (only used if reply).

    • :max_accepted_payout (String) (1000000.000 SBD) Maximum accepted payout, set to ‘0.000 SBD’ to deline payout

    • :percent_steem_dollars (Numeric) (5000) Percent STEEM Dollars is used to set 50/50 or 100% STEEM Power

    • :allow_votes (Numeric) (true) Allow votes for this content.

    • :allow_curation_rewards (Numeric) (true) Allow curation rewards for this content.

    • :beneficiaries (Array<Hash>) Sets the beneficiaries of this content.

    • :author_vote_weight (Number) (optional) Cast a vote by the author in the same transaction.

    • :pretend (Boolean) Just validate, do not broadcast.

See Also:



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/steem/broadcast.rb', line 147

def self.comment(options, &block)
  required_fields = %i(author body permlink parent_permlink)
  params = options[:params]
  
  if !!params[:metadata] && !!params[:json_metadata]
    raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
  end
  
  metadata = params[:metadata] || {}
  metadata ||= (JSON[params[:json_metadata]] || nil) || {}
  metadata['app'] ||= Steem::AGENT_ID
  tags = metadata['tags'] || []
  params[:parent_permlink] ||= tags.first
  
  if !!params[:title]
    params[:permlink] ||= params[:title].downcase.gsub(/[^a-z0-9\-]+/, '-')
  end
  
  check_required_fields(params, *required_fields)
  
  ops = [[:comment, {
    parent_author: params[:parent_author] || '',
    parent_permlink: params[:parent_permlink],
    author: params[:author],
    permlink: params[:permlink],
    title: params[:title] || '',
    body: params[:body],
    json_metadata: metadata.to_json
  }]]
  
  max_accepted_payout = if params.keys.include? :max_accepted_payout
    normalize_amount(options.merge amount: params[:max_accepted_payout])
  else
    normalize_amount(options.merge amount: DEFAULT_MAX_ACCEPTED_PAYOUT)
  end
  
  allow_votes = if params.keys.include? :allow_votes
    !!params[:allow_votes]
  else
    true
  end
  
  allow_curation_rewards = if params.keys.include? :allow_curation_rewards
    !!params[:allow_curation_rewards]
  else
    true
  end
  
  comment_options = {
    author: params[:author],
    permlink: params[:permlink],
    max_accepted_payout: max_accepted_payout,
    percent_steem_dollars: params[:percent_steem_dollars] || 10000,
    # allow_replies: allow_replies,
    allow_votes: allow_votes,
    allow_curation_rewards: allow_curation_rewards,
    extensions: []
  }
  
  if !!params[:beneficiaries]
    comment_options[:extensions] << [
      comment_options[:extensions].size,
      normalize_beneficiaries(options.merge(beneficiaries: params[:beneficiaries]))
    ]
  end
  
  ops << [:comment_options, comment_options]
  
  if !!params[:author_vote_weight]
    author_vote = {
      voter: params[:author],
      author: params[:author],
      permlink: params[:permlink],
      weight: params[:author_vote_weight]
    }
    
    ops << [:vote, author_vote]
  end
  
  process(options.merge(ops: ops), &block)
end

.convert(options, &block) ⇒ Object

This operation instructs the blockchain to start a conversion between STEEM and SBD, the funds are deposited after 3.5 days.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :owner (String)

    • :requestid (String)

    • :amount (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



441
442
443
444
445
446
447
448
449
450
451
 
# File 'lib/steem/broadcast.rb', line 441

def self.convert(options, &block)
  required_fields = %i(owner requestid amount)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:amount] = normalize_amount(options.merge amount: params[:amount])
  
  ops = [[:convert, params]]
  
  process(options.merge(ops: ops), &block)
end

.create_claimed_account(options, &block) ⇒ Object

Create a claimed account.

options = {
  wif: wif,
  params: {
    creator: ,
    new_account_name: ,
    owner: {
      weight_threshold: 1,
      account_auths: [],
      key_auths: [[owner_public_key, 1]],
    },
    active: {
      weight_threshold: 1,
      account_auths: [],
      key_auths: [[active_public_key, 1]],
    },
    posting: {
      weight_threshold: 1,
      account_auths: [],
      key_auths: [[posting_public_key, 1]],
    },
    memo_key: memo_public_key,
    json_metadata: '{}'
  }
}

Steem::Broadcast.(options)

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :creator (String)

    • :new_account_name (String)

    • :owner (Hash)

    • :active (Hash)

    • :posting (Hash)

    • :memo_key (String)

    • :metadata (Hash) Metadata of the account, becomes ‘json_metadata`.

    • :json_metadata (String) String version of ‘metadata` (use one or the other).

    • :extensions (Array) (optional)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
 
# File 'lib/steem/broadcast.rb', line 559

def self.(options, &block)
  required_fields = %i(creator new_account_name owner active posting memo_key json_metadata)
  params = options[:params]
  
  if !!params[:metadata] && !!params[:json_metadata]
    raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
  end
  
  metadata = params.delete(:metadata) || {}
  metadata ||= (JSON[params[:json_metadata]] || nil) || {}
  params[:json_metadata] = metadata.to_json
  
  check_required_fields(params, *required_fields)
  
  params[:extensions] ||= []
  ops = [[:create_claimed_account, params]]
  
  process(options.merge(ops: ops), &block)
end

.custom(options, &block) ⇒ Object

Provides a generic way to add higher level protocols on top of witness consensus.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :required_auths (Array<String>)

    • :id (String)

    • :data (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



797
798
799
800
801
802
803
804
805
 
# File 'lib/steem/broadcast.rb', line 797

def self.custom(options, &block)
  required_fields = %i(required_auths id data)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:custom, params]]
  
  process(options.merge(ops: ops), &block)
end

.custom_binary(options, &block) ⇒ Object

The semmantics for this operation are the same as the custom_json operation, but with a binary payload.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Posting wif

  • :params (Hash) —

    • :id (String)

    • :data (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



817
818
819
820
821
822
823
824
825
 
# File 'lib/steem/broadcast.rb', line 817

def self.custom_binary(options, &block)
  required_fields = %i(id data)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:custom_binary, params]]
  
  process(options.merge(ops: ops), &block)
end

.custom_json(options, &block) ⇒ Object

Serves the same purpose as custom but also supports required posting authorities.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Posting wif

  • :params (Hash) —

    • :required_auths (Array<String>)

    • :required_posting_auths (Arrat<String>)

    • :id (String)

    • :data (Hash) Data of the custom json, becomes ‘json`.

    • :json (String) String version of ‘data` (use one or the other).

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
 
# File 'lib/steem/broadcast.rb', line 840

def self.custom_json(options, &block)
  required_fields = %i(id)
  params = options[:params]
  
  if !!params[:data] && !!params[:json]
    raise Steem::ArgumentError, 'Assign either data or json, not both.'
  end
  
  data = params.delete(:data) || {}
  data ||= (JSON[params[:json]] || nil) || {}
  params[:json] = data.to_json
  
  check_required_fields(params, *required_fields)
  
  params[:required_auths] ||= []
  params[:required_posting_auths] ||= []
  ops = [[:custom_json, params]]
  
  process(options.merge(ops: ops), &block)
end

.decline_voting_rights(options, &block) ⇒ Object

An account can chose to decline their voting rights after a 30 day delay. This includes voting on content and witnesses. **The voting rights cannot be acquired again once they have been declined.** This is only to formalize a smart contract between certain accounts and the community that currently only exists as a social contract.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Owner wif

  • :params (Hash) —

    • :account (String)

    • :decline (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



1151
1152
1153
1154
1155
1156
1157
1158
1159
 
# File 'lib/steem/broadcast.rb', line 1151

def self.decline_voting_rights(options, &block)
  required_fields = %i(account decline)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:decline_voting_rights, params]]
  
  process(options.merge(ops: ops), &block)
end

.delegate_vesting_shares(options, &block) ⇒ Object

Delegate vesting shares from one account to the other.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :delegator (String)

    • :delegatee (String)

    • :vesting_shares (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
 
# File 'lib/steem/broadcast.rb', line 1171

def self.delegate_vesting_shares(options, &block)
  required_fields = %i(delegator delegatee vesting_shares)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:vesting_shares] = normalize_amount(options.merge amount: params[:vesting_shares])
  ops = [[:delegate_vesting_shares, params]]
  
  process(options.merge(ops: ops), &block)
end

.delete_comment(options, &block) ⇒ Object

Deletes a post/comment.

Steem::Broadcast.delete_comment(wif: wif, params: {author: author, permlink: permlink}) do |result|
  puts result
end

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Posting wif

  • :params (Hash) —

    • :author (String)

    • :permlink (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



242
243
244
245
246
247
248
249
250
 
# File 'lib/steem/broadcast.rb', line 242

def self.delete_comment(options, &block)
  required_fields = %i(author permlink)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:delete_comment, params]]
  
  process(options.merge(ops: ops), &block)
end

.escrow_approve(options, &block) ⇒ Object

The agent and to accounts must approve an escrow transaction for it to be valid on the blockchain.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :from (String)

    • :to (String)

    • :agent (String)

    • :who (String)

    • :escrow_id (String)

    • :approve (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



1064
1065
1066
1067
1068
1069
1070
1071
1072
 
# File 'lib/steem/broadcast.rb', line 1064

def self.escrow_approve(options, &block)
  required_fields = %i(from to agent who escrow_id approve)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:escrow_approve, params]]
  
  process(options.merge(ops: ops), &block)
end

.escrow_dispute(options, &block) ⇒ Object

If either the sender or receiver of an escrow payment has an issue, they can raise it for dispute.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :from (String)

    • :to (String)

    • :agent (String)

    • :who (String)

    • :escrow_id (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



1011
1012
1013
1014
1015
1016
1017
1018
1019
 
# File 'lib/steem/broadcast.rb', line 1011

def self.escrow_dispute(options, &block)
  required_fields = %i(from to agent who escrow_id)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:escrow_dispute, params]]
  
  process(options.merge(ops: ops), &block)
end

.escrow_release(options, &block) ⇒ Object

This operation can be used by anyone associated with the escrow transfer to release funds if they have permission.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :from (String)

    • :to (String)

    • :agent (String)

    • :who (String)

    • :receiver (String)

    • :escrow_id (String)

    • :sbd_amount (String)

    • :steem_amount (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
 
# File 'lib/steem/broadcast.rb', line 1037

def self.escrow_release(options, &block)
  required_fields = %i(from to agent who receiver escrow_id)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:sbd_amount] = normalize_amount(options.merge amount: params[:sbd_amount])
  params[:steem_amount] = normalize_amount(options.merge amount: params[:steem_amount])

  ops = [[:escrow_release, params]]
  
  process(options.merge(ops: ops), &block)
end

.escrow_transfer(options, &block) ⇒ Object

The purpose of this operation is to enable someone to send money contingently to another individual.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :from (String)

    • :to (String)

    • :agent (String)

    • :escrow_id (String)

    • :sbd_amount (String)

    • :steem_amount (String)

    • :fee (String)

    • :ratification_deadline (String)

    • :escrow_expiration (String)

    • :meta (Hash) Meta of the escrow transfer, becomes ‘json_meta`.

    • :json_meta (String) String version of ‘metadata` (use one or the other).

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
 
# File 'lib/steem/broadcast.rb', line 967

def self.escrow_transfer(options, &block)
  required_fields = %i(from to agent escrow_id fee ratification_deadline)
  params = options[:params]
  
  if !!params[:meta] && !!params[:json_meta]
    raise Steem::ArgumentError, 'Assign either meta or json_meta, not both.'
  end
  
  meta = params.delete(:meta) || {}
  meta ||= (JSON[params[:json_meta]] || nil) || {}
  params[:json_meta] = meta.to_json
  
  check_required_fields(params, *required_fields)
  
  params[:sbd_amount] = normalize_amount(options.merge amount: params[:sbd_amount])
  params[:steem_amount] = normalize_amount(options.merge amount: params[:steem_amount])
  params[:fee] = normalize_amount(options.merge amount: params[:fee])
  
  params[:ratification_deadline] = Time.parse(params[:ratification_deadline].to_s)
  params[:ratification_deadline] = params[:ratification_deadline].strftime('%Y-%m-%dT%H:%M:%S')
  
  if !!params[:escrow_expiration]
    params[:escrow_expiration] = Time.parse(params[:escrow_expiration].to_s)
    params[:escrow_expiration] = params[:escrow_expiration].strftime('%Y-%m-%dT%H:%M:%S')
  end

  ops = [[:escrow_transfer, params]]
  
  process(options.merge(ops: ops), &block)
end

.feed_publish(options, &block) ⇒ Object

Feeds can only be published by the top N witnesses which are included in every round and are used to define the exchange rate between steem and the dollar.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :publisher (String)

    • :exchange_rate (Hash)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
 
# File 'lib/steem/broadcast.rb', line 414

def self.feed_publish(options, &block)
  required_fields = %i(publisher exchange_rate)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  exchange_rate = params[:exchange_rate] rescue nil || {}
  base = exchange_rate[:base]
  quote = exchange_rate[:quote]
  params[:exchange_rate][:base] = normalize_amount(options.merge amount: base)
  params[:exchange_rate][:quote] = normalize_amount(options.merge amount: quote)
  
  ops = [[:feed_publish, params]]
  
  process(options.merge(ops: ops), &block)
end

.limit_order_cancel(options, &block) ⇒ Object

Cancels an order and returns the balance to owner.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :owner (String)

    • :orderid (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



393
394
395
396
397
398
399
400
401
 
# File 'lib/steem/broadcast.rb', line 393

def self.limit_order_cancel(options, &block)
  required_fields = %i(owner orderid)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:limit_order_cancel, params]]
  
  process(options.merge(ops: ops), &block)
end

.limit_order_create(options, &block) ⇒ Object

This operation creates a limit order and matches it against existing open orders.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :owner (String)

    • :orderid (String)

    • :amount_to_sell (String)

    • :min_to_receive (String)

    • :fill_or_kill (Boolean)

    • :expiration (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
 
# File 'lib/steem/broadcast.rb', line 365

def self.limit_order_create(options, &block)
  required_fields = %i(owner orderid amount_to_sell min_to_receive
    fill_or_kill)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:amount_to_sell] = normalize_amount(options.merge amount: params[:amount_to_sell])
  params[:min_to_receive] = normalize_amount(options.merge amount: params[:min_to_receive])
  
  if !!params[:expiration]
    params[:expiration] = Time.parse(params[:expiration].to_s)
    params[:expiration] = params[:expiration].strftime('%Y-%m-%dT%H:%M:%S')
  end
  
  ops = [[:limit_order_create, params]]
  
  process(options.merge(ops: ops), &block)
end

.process(options, &block) ⇒ Object

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • Array] (Array<Array<Hash>] :ops Operations to process.) —

    :ops Operations to process.

  • :pretend (Boolean) —

    Just validate, do not broadcast.



1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
 
# File 'lib/steem/broadcast.rb', line 1246

def self.process(options, &block)
  ops = options[:ops]
  tx = TransactionBuilder.new(options)
  response = nil
  
  loop do; begin
    tx.operations = ops
    trx = tx.transaction
    
    response = if !!options[:pretend]
      if !!options[:app_base]
        database_api(options).verify_authority(trx: trx)
      else
        database_api(options).verify_authority(trx)
      end
    else
      if !!options[:app_base]
        network_broadcast_api(options).broadcast_transaction(trx: trx)
      else
        network_broadcast_api(options).broadcast_transaction_synchronous(trx)
      end
    end
    
    break
  rescue => e
    if can_retry? e
      tx.expiration = nil
      redo
    end
    
    raise e
  end; end
  
  if !!block
    block.call response.result
  else
    return response.result
  end
end

.recover_account(options, &block) ⇒ Object

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :account_to_recover (String)

    • :new_owner_authority (Hash)

    • :recent_owner_authority (Hash)

    • :extensions (Array) (optional)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



915
916
917
918
919
920
921
922
923
924
 
# File 'lib/steem/broadcast.rb', line 915

def self.(options, &block)
  required_fields = %i(account_to_recover new_owner_authority recent_owner_authority)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:extensions] ||= []
  ops = [[:recover_account, params]]
  
  process(options.merge(ops: ops), &block)
end

.request_account_recovery(options, &block) ⇒ Object

All account recovery requests come from a listed recovery account.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :recovery_account (String)

    • :account_to_recover (String)

    • :new_owner_authority (Hash)

    • :extensions (Array) (optional)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



895
896
897
898
899
900
901
902
903
904
 
# File 'lib/steem/broadcast.rb', line 895

def self.(options, &block)
  required_fields = %i(recovery_account account_to_recover new_owner_authority)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:extensions] ||= []
  ops = [[:request_account_recovery, params]]
  
  process(options.merge(ops: ops), &block)
end

.set_withdraw_vesting_route(options, &block) ⇒ Object

Allows an account to setup a vesting withdraw but with the additional request for the funds to be transferred directly to another account’s balance rather than the withdrawing account.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :from_account (String)

    • :to_account (String)

    • :percent (Numeric)

    • :auto_vest (Boolean)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



874
875
876
877
878
879
880
881
882
 
# File 'lib/steem/broadcast.rb', line 874

def self.set_withdraw_vesting_route(options, &block)
  required_fields = %i(from_account to_account percent auto_vest)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:set_withdraw_vesting_route, params]]
  
  process(options.merge(ops: ops), &block)
end

.transfer(options, &block) ⇒ Object

Transfers asset from one account to another.

options = {
  wif: wif,
  params: {
    from: from,
    to: to,
    amount: amount,
    memo: memo
  }
}

Steem::Broadcast.transfer(options) do |result|
  puts result
end

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :from (String)

    • :to (String)

    • :amount (String)

    • :memo (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



277
278
279
280
281
282
283
284
285
286
287
 
# File 'lib/steem/broadcast.rb', line 277

def self.transfer(options, &block)
  required_fields = %i(from to amount memo)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:amount] = normalize_amount(options.merge amount: params[:amount])
  
  ops = [[:transfer, params]]
  
  process(options.merge(ops: ops), &block)
end

.transfer_from_savings(options, &block) ⇒ Object

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :from (String)

    • :request_id (String)

    • :to (String)

    • :amount (String)

    • :memo (String) (optional)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
 
# File 'lib/steem/broadcast.rb', line 1108

def self.transfer_from_savings(options, &block)
  required_fields = %i(from request_id to amount)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:memo] ||= ''
  params[:amount] = normalize_amount(options.merge amount: params[:amount])

  ops = [[:transfer_from_savings, params]]
  
  process(options.merge(ops: ops), &block)
end

.transfer_to_savings(options, &block) ⇒ Object

For time locked savings accounts.

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :from (String)

    • :to (String)

    • :amount (String)

    • :memo (String) (optional)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
 
# File 'lib/steem/broadcast.rb', line 1085

def self.transfer_to_savings(options, &block)
  required_fields = %i(from to amount)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:memo] ||= ''
  params[:amount] = normalize_amount(options.merge amount: params[:amount])

  ops = [[:transfer_to_savings, params]]
  
  process(options.merge(ops: ops), &block)
end

.transfer_to_vesting(options, &block) ⇒ Object

This operation converts STEEM into VFS (Vesting Fund Shares) at the current exchange rate.

options = {
  wif: wif,
  params: {
    from: from,
    to: to,
    amount: amount,
  }
}

Steem::Broadcast.transfer_to_vesting(options) do |result|
  puts result
end

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :from (String)

    • :to (String)

    • :amount (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



313
314
315
316
317
318
319
320
321
322
323
 
# File 'lib/steem/broadcast.rb', line 313

def self.transfer_to_vesting(options, &block)
  required_fields = %i(from to amount)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:amount] = normalize_amount(options.merge amount: params[:amount])
  
  ops = [[:transfer_to_vesting, params]]
  
  process(options.merge(ops: ops), &block)
end

.vote(options, &block) ⇒ Object

This operation is used to cast a vote on a post/comment.

options = {
  wif: wif,
  params: {
    voter: voter,
    author: author,
    permlink: permlink,
    weight: weight
  }
}

Steem::Broadcast.vote(options) do |result|
  puts result
end

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Posting wif

  • :params (Hash) —

    • :voter (String)

    • :author (String)

    • :permlink (String)

    • :weight (Number)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



63
64
65
66
67
68
69
70
71
 
# File 'lib/steem/broadcast.rb', line 63

def self.vote(options, &block)
  required_fields = %i(voter author permlink weight)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  ops = [[:vote, params]]
  
  process(options.merge(ops: ops), &block)
end

.withdraw_vesting(options, &block) ⇒ Object

At any given point in time an account can be withdrawing from their vesting shares.

Steem::Broadcast.withdraw_vesting(wif: wif, params: {account: , vesting_shares: vesting_shares}) do |result|
  puts result
end

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :account (String)

    • :vesting_shares (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



339
340
341
342
343
344
345
346
347
348
349
 
# File 'lib/steem/broadcast.rb', line 339

def self.withdraw_vesting(options, &block)
  required_fields = %i(account vesting_shares)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  params[:vesting_shares] = normalize_amount(options.merge amount: params[:vesting_shares])
  
  ops = [[:withdraw_vesting, params]]
  
  process(options.merge(ops: ops), &block)
end

.witness_set_properties(options, &block) ⇒ Object

Extensible replacement for #witness_update that supports additional properties added since HF20 and beyond.

options = {
  wif: wif,
  params: {
    owner: ,
    props: {
      account_creation_fee: '0.000 STEEM',
      maximum_block_size: 131072,
      sbd_interest_rate: 1000,
      account_subsidy_budget: 50000,
      account_subsidy_decay: 330782,
      sbd_exchange_rate: '1.000 STEEM',
      url: "https://steemit.com",
      new_signing_key: 'STM8LoQjQqJHvotqBo7HjnqmUbFW9oJ2theyqonzUd9DdJ7YYHsvD'
    }
  }
}

Steem::Broadcast.witness_set_properties(options)

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :owner (String)

    • :props (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
 
# File 'lib/steem/broadcast.rb', line 711

def self.witness_set_properties(options, &block)
  required_fields = %i(owner props)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
  if !!( = params[:props][:account_creation_fee] rescue nil)
    params[:props][:account_creation_fee] = normalize_amount(options.merge amount: , serialize: true)
  end
  
  if !!(sbd_exchange_rate = params[:props][:sbd_exchange_rate] rescue nil)
    params[:props][:sbd_exchange_rate][:base] = normalize_amount(options.merge amount: sbd_exchange_rate[:base], serialize: true)
    params[:props][:sbd_exchange_rate][:quote] = normalize_amount(options.merge amount: sbd_exchange_rate[:quote], serialize: true)
    params[:props][:sbd_exchange_rate] = params[:props][:sbd_exchange_rate].to_json
  end
  
  %i(key new_signing_key).each do |key|
    if !!params[key] && params[key].size == 53
      params[key] = params[key][3..-1]
    end
  end
  
  %i(account_creation_fee sbd_exchange_rate url new_signing_key).each do |key|
    next unless !!params[:props][key]
    
    val = params[:props][key].to_s
      
    params[:props][key] = hexlify val unless val =~ /^[0-9A-F]+$/i
  end
  
  params[:props] = params[:props].to_a
  
  params[:extensions] ||= []
  ops = [[:witness_set_properties, params]]
  
  process(options.merge(ops: ops), &block)
end

.witness_update(options, &block) ⇒ Object

Users who wish to become a witness must pay a fee acceptable to the current witnesses to apply for the position and allow voting to begin.

options = {
  wif: wif,
  params: {
    owner: ,
    url: '',
    block_signing_key: 'STM8ZSyzjPm48GmUuMSRufkVYkwYbZzbxeMysAVp7KFQwbTf98TcG',
    props: {
      account_creation_fee: '0.000 STEEM',
      maximum_block_size: 131072,
      sbd_interest_rate:1000
    },
    fee: '0.000 STEEM',
  }
}

Steem::Broadcast.witness_update(options)

Parameters:

  • options (Hash) —

    options

Options Hash (options):

  • :wif (String) —

    Active wif

  • :params (Hash) —

    • :owner (String)

    • :url (String) (optional)

    • :block_signing_key (String)

    • :props (String)

    • :fee (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



667
668
669
670
671
672
673
674
675
676
677
678
679
 
# File 'lib/steem/broadcast.rb', line 667

def self.witness_update(options, &block)
  required_fields = %i(owner block_signing_key props fee)
  params = options[:params]
  check_required_fields(params, *required_fields)
  
   = params[:props][:account_creation_fee] rescue nil
  params[:props][:account_creation_fee] = normalize_amount(options.merge amount: )
  params[:fee] = normalize_amount(options.merge amount: params[:fee])
  
  ops = [[:witness_update, params]]
  
  process(options.merge(ops: ops), &block)
end