Class: DPay::Broadcast

Inherits:
Object
  • Object
show all
Extended by:
Retriable
Defined in:
lib/dpay/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_DPAY_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 DPay 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?

Class Method Details

.account_create(options, &block) ⇒ Object

Create an account.

options = {
  wif: wif,
  params: {
    fee: '1.000 BEX',
    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: '{}'
  }
}

DPay::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:



491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
 
# File 'lib/dpay/broadcast.rb', line 491

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 DPay::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:



1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
 
# File 'lib/dpay/broadcast.rb', line 1064

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 DPay::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: '{}'
  }
}

DPay::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:



551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
 
# File 'lib/dpay/broadcast.rb', line 551

def self.(options, &block)
  required_fields = %i(account)
  params = options[:params]

  if !!params[:metadata] && !!params[:json_metadata]
    raise DPay::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:



642
643
644
645
646
647
648
649
650
 
# File 'lib/dpay/broadcast.rb', line 642

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:



625
626
627
628
629
630
631
632
633
 
# File 'lib/dpay/broadcast.rb', line 625

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:



994
995
996
997
998
999
1000
1001
1002
 
# File 'lib/dpay/broadcast.rb', line 994

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:



802
803
804
805
806
807
808
809
810
811
812
 
# File 'lib/dpay/broadcast.rb', line 802

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

.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)
    }
  }
}

DPay::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}
    ]
  }
}

DPay::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
  }
}

DPay::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 BBD) Maximum accepted payout, set to ‘0.000 BBD’ to deline payout

    • :percent_dpay_dollars (Numeric) (5000) Percent BEX Dollars is used to set 50/50 or 100% BEX 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:



146
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
 
# File 'lib/dpay/broadcast.rb', line 146

def self.comment(options, &block)
  required_fields = %i(author body permlink parent_permlink)
  params = options[:params]

  if !!params[:metadata] && !!params[:json_metadata]
    raise DPay::ArgumentError, 'Assign either metadata or json_metadata, not both.'
  end

  metadata = params[:metadata] || {}
  metadata ||= (JSON[params[:json_metadata]] || nil) || {}
  metadata['app'] ||= DPay::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_dpay_dollars: params[:percent_dpay_dollars] || 10000,
    allow_votes: allow_votes,
    allow_curation_rewards: allow_curation_rewards,
    extensions: []
  }

  if !!params[:beneficiaries]
    comment_options[:extensions] << [0, {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 BEX and BBD, 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:



436
437
438
439
440
441
442
443
444
445
446
 
# File 'lib/dpay/broadcast.rb', line 436

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

.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:



663
664
665
666
667
668
669
670
671
 
# File 'lib/dpay/broadcast.rb', line 663

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:



683
684
685
686
687
688
689
690
691
 
# File 'lib/dpay/broadcast.rb', line 683

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:



706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
 
# File 'lib/dpay/broadcast.rb', line 706

def self.custom_json(options, &block)
  required_fields = %i(id)
  params = options[:params]

  if !!params[:data] && !!params[:json]
    raise DPay::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:



1017
1018
1019
1020
1021
1022
1023
1024
1025
 
# File 'lib/dpay/broadcast.rb', line 1017

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:



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

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.

DPay::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:



237
238
239
240
241
242
243
244
245
 
# File 'lib/dpay/broadcast.rb', line 237

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:



930
931
932
933
934
935
936
937
938
 
# File 'lib/dpay/broadcast.rb', line 930

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:



877
878
879
880
881
882
883
884
885
 
# File 'lib/dpay/broadcast.rb', line 877

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)

    • :bbd_amount (String)

    • :dpay_amount (String)

  • :pretend (Boolean) —

    Just validate, do not broadcast.

See Also:



903
904
905
906
907
908
909
910
911
912
913
914
 
# File 'lib/dpay/broadcast.rb', line 903

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[:bbd_amount] = normalize_amount(options.merge amount: params[:bbd_amount])
  params[:dpay_amount] = normalize_amount(options.merge amount: params[:dpay_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)

    • :bbd_amount (String)

    • :dpay_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:



833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
 
# File 'lib/dpay/broadcast.rb', line 833

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 DPay::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[:bbd_amount] = normalize_amount(options.merge amount: params[:bbd_amount])
  params[:dpay_amount] = normalize_amount(options.merge amount: params[:dpay_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 dpay 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:



409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
 
# File 'lib/dpay/broadcast.rb', line 409

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:



388
389
390
391
392
393
394
395
396
 
# File 'lib/dpay/broadcast.rb', line 388

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:



360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
 
# File 'lib/dpay/broadcast.rb', line 360

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.



1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
 
# File 'lib/dpay/broadcast.rb', line 1090

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:



781
782
783
784
785
786
787
788
789
790
 
# File 'lib/dpay/broadcast.rb', line 781

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:



761
762
763
764
765
766
767
768
769
770
 
# File 'lib/dpay/broadcast.rb', line 761

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:



740
741
742
743
744
745
746
747
748
 
# File 'lib/dpay/broadcast.rb', line 740

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
  }
}

DPay::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:



272
273
274
275
276
277
278
279
280
281
282
 
# File 'lib/dpay/broadcast.rb', line 272

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:



974
975
976
977
978
979
980
981
982
983
984
985
 
# File 'lib/dpay/broadcast.rb', line 974

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:



951
952
953
954
955
956
957
958
959
960
961
962
 
# File 'lib/dpay/broadcast.rb', line 951

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 BEX into VFS (Vesting Fund Shares) at the current exchange rate.

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

DPay::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:



308
309
310
311
312
313
314
315
316
317
318
 
# File 'lib/dpay/broadcast.rb', line 308

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
  }
}

DPay::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:



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

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.

DPay::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:



334
335
336
337
338
339
340
341
342
343
344
 
# File 'lib/dpay/broadcast.rb', line 334

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_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 BEX',
      maximum_block_size: 131072,
      bbd_interest_rate:1000
    },
    fee: '0.000 BEX',
  }
}

DPay::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:



600
601
602
603
604
605
606
607
608
609
610
611
612
 
# File 'lib/dpay/broadcast.rb', line 600

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