digitalbits-base 0.27.1 → 0.27.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01d8ef68986ef49901cc412969186d4226d2c1d8f0eb25261bebba931a56c0cf
-  data.tar.gz: f2e2905199fcaa6860250d676a60b6a296f2d370571905f71ddb5406f7fc9ccb
+  metadata.gz: f31c7fa834751bbf8148e8e3a8f2aa90deba9f0c4bbeecac1d4d1cee634466d4
+  data.tar.gz: d14e6159b2c5d6368872f7a832aac9eb3d47746a0cd838f7bd39a9ee646f4d2f
 SHA512:
-  metadata.gz: 032a7799de807ba1df906b9078b3cd5b1403adf4921df5f693e536d161f86c6b180cd6bb3b81649060b5bf1c73abe224d4e8a481fa4b950bed9703d91b13ca2c
-  data.tar.gz: c5c109b2ecc3b7cabb803a2507809c2089fa56dd7c9325b674c0ece5f89a064fa915c3c1ecd509ca02cc62f89481651f1b8e292d910317643d6e3d901251007b
+  metadata.gz: 8f4637ab1f4192110e981cf74f3dbc22b20ad8f0a925a17b2b6a619ae0ac47debad7ef642b09af1957bfc4661441c63159c86a74ef17436be72792f2ed6602f7
+  data.tar.gz: 53a232621f4300038f8c84f09e308028ff234b7adfb4acf22b6270ff7074200177e4044818da9c4fcea2ea22c00a3f0e24135488534ffe7013ded67222d128dd

data/README.md

@@ -31,19 +31,19 @@ It seems as though jruby is particularly slow when it comes to BigDecimal math;
 
 In addition to the code generated from the XDR definition files, this library also provides some digitalbits specific features.  Let's look at some of them.
 
-We wrap rbnacl with `DigitalBits::KeyPair`, providing some digitalbits specific functionality as seen below:
+We wrap rbnacl with `Digitalbits::KeyPair`, providing some digitalbits specific functionality as seen below:
 
 ```ruby
 
 # Create a keypair from a digitalbits secret seed
-signer = DigitalBits::KeyPair.from_seed("SCBASSEX34FJNIPLUYQPSMZHHYXXQNWOOV42XYZFXM6EGYX2DPIZVIA3")
+signer = Digitalbits::KeyPair.from_seed("SCBASSEX34FJNIPLUYQPSMZHHYXXQNWOOV42XYZFXM6EGYX2DPIZVIA3")
 
 # Create a keypair from a digitalbits address
-verifier = DigitalBits::KeyPair.from_address("GBQWWBFLRP3BXD2RI2FH7XNNU2MKIYVUI7QXUAIVG34JY6MQGXVUO3RX")
+verifier = Digitalbits::KeyPair.from_address("GBQWWBFLRP3BXD2RI2FH7XNNU2MKIYVUI7QXUAIVG34JY6MQGXVUO3RX")
 
 # Produce a digitalbits compliant "decorated signature" that is compliant with digitalbits transactions
 
-signer.sign_decorated("Hello world!") # => #<DigitalBits::DecoratedSignature ...>
+signer.sign_decorated("Hello world!") # => #<Digitalbits::DecoratedSignature ...>
 
 ```
 
@@ -51,15 +51,15 @@ This library also provides an impementation of DigitalBits's "StrKey" encoding (
 
 ```ruby
 
-DigitalBits::Util::StrKey.check_encode(:account_id, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF") # => "GD777777777764TU"
-DigitalBits::Util::StrKey.check_encode(:seed, "\x00\x00\x00\x00\x00\x00\x39") # => "SAAAAAAAAAADST3H"
+Digitalbits::Util::StrKey.check_encode(:account_id, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF") # => "GD777777777764TU"
+Digitalbits::Util::StrKey.check_encode(:seed, "\x00\x00\x00\x00\x00\x00\x39") # => "SAAAAAAAAAADST3H"
 
 # To prevent interpretation mistakes, you must pass the expected version byte
 # when decoding a check_encoded value
 
-encoded = DigitalBits::Util::StrCheck.check_encode(:account_id, "\x61\x6b\x04\xab\x8b\xf6\x1b")
-DigitalBits::Util::StrKey.check_decode(:account_id, encoded) # => "\x61\x6b\x04\xab\x8b\xf6\x1b"
-DigitalBits::Util::StrKey.check_decode(:seed, encoded) # => throws ArgumentError: Unexpected version: :account_id
+encoded = Digitalbits::Util::StrCheck.check_encode(:account_id, "\x61\x6b\x04\xab\x8b\xf6\x1b")
+Digitalbits::Util::StrKey.check_decode(:account_id, encoded) # => "\x61\x6b\x04\xab\x8b\xf6\x1b"
+Digitalbits::Util::StrKey.check_decode(:seed, encoded) # => throws ArgumentError: Unexpected version: :account_id
 
 ```
 

data/lib/digitalbits-base.rb

@@ -14,12 +14,12 @@ require_relative "digitalbits/ext/xdr"
 silence_warnings do
   require "digitalbits-base-generated"
 end
-DigitalBits.load_all!
+Digitalbits.load_all!
 
 require_relative "digitalbits/version"
 
-DigitalBits::ONE = 1_0000000
-DigitalBits::Deprecation = ActiveSupport::Deprecation.new("next release", "digitalbits-base")
+Digitalbits::ONE = 1_0000000
+Digitalbits::Deprecation = ActiveSupport::Deprecation.new("next release", "digitalbits-base")
 
 # extensions onto the generated files must be loaded manually, below
 

data/lib/digitalbits/account_flags.rb

@@ -1,10 +1,10 @@
-module DigitalBits
+module Digitalbits
   class AccountFlags
     #
-    # Converts an array of DigitalBits::AccountFlags members into
+    # Converts an array of Digitalbits::AccountFlags members into
     # an Integer suitable for use in a SetOptionsOp.
     #
-    # @param flags [Array<DigitalBits::AccountFlags>] the flags to combine
+    # @param flags [Array<Digitalbits::AccountFlags>] the flags to combine
     #
     # @return [Fixnum] the combined result
     def self.make_mask(flags = nil)
@@ -15,10 +15,10 @@ module DigitalBits
 
     #
     # Converts an integer used in SetOptionsOp on the set/clear flag options
-    # into an array of DigitalBits::AccountFlags members
+    # into an array of Digitalbits::AccountFlags members
     #
     #  @param combined [Fixnum]
-    #  @return [Array<DigitalBits::AccountFlags>]
+    #  @return [Array<Digitalbits::AccountFlags>]
     def self.parse_mask(combined)
       members.values.select { |m| (m.value & combined) != 0 }
     end

data/lib/digitalbits/asset.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   class Asset
     TYPES = %i[native alphanum4 alphanum12]
 
@@ -9,7 +9,7 @@ module DigitalBits
     # @param code   [String] asset code
     # @param issuer [#to_keypair] asset issuer
     #
-    # @return [DigitalBits::Asset::AlphaNum4] asset4 representation
+    # @return [Digitalbits::Asset::AlphaNum4] asset4 representation
     def self.alphanum4(code, issuer)
       issuer = issuer.to_keypair if issuer.respond_to?(:to_keypair)
       raise ArgumentError, "Bad :issuer" unless issuer.is_a?(KeyPair)
@@ -21,7 +21,7 @@ module DigitalBits
     # @param code   [String] asset code
     # @param issuer [#to_keypair] asset issuer
     #
-    # @return [DigitalBits::Asset::AlphaNum4] asset4 representation
+    # @return [Digitalbits::Asset::AlphaNum4] asset4 representation
     def self.alphanum12(code, issuer)
       issuer = issuer.to_keypair if issuer.respond_to?(:to_keypair)
       raise ArgumentError, "Bad :issuer" unless issuer.is_a?(KeyPair)
@@ -36,18 +36,18 @@ module DigitalBits
         "native"
       when AssetType.asset_type_credit_alphanum4
         anum = alpha_num4!
-        issuer_address = DigitalBits::Convert.pk_to_address(anum.issuer)
+        issuer_address = Digitalbits::Convert.pk_to_address(anum.issuer)
         "#{anum.asset_code}/#{issuer_address}"
       when AssetType.asset_type_credit_alphanum12
         anum = alpha_num12!
-        issuer_address = DigitalBits::Convert.pk_to_address(anum.issuer)
+        issuer_address = Digitalbits::Convert.pk_to_address(anum.issuer)
         "#{anum.asset_code}/#{issuer_address}"
       end
     end
 
     def inspect
       # label = switch.to_s
-      "#<DigitalBits::Asset #{self}>"
+      "#<Digitalbits::Asset #{self}>"
     end
 
     def code

data/lib/digitalbits/claim_predicate.rb

@@ -2,7 +2,7 @@
 require "active_support/core_ext/integer/time"
 require "active_support/core_ext/string/conversions"
 
-module DigitalBits
+module Digitalbits
   # Represents claim predicate on DigitalBits network.
   #
   class ClaimPredicate
@@ -19,7 +19,7 @@ module DigitalBits
       # Constructs a `before_relative_time` claim predicate.
       #
       # This predicate will be fulfilled if the closing time of the ledger that includes
-      # the DigitalBits::CreateClaimableBalance operation plus this relative time delta (in seconds)
+      # the Digitalbits::CreateClaimableBalance operation plus this relative time delta (in seconds)
       # is less than the current time.
       #
       # @param seconds [#to_int|#to_i] seconds since `closeTime` of the ledger in which
@@ -32,7 +32,7 @@ module DigitalBits
       # Constructs an `before_absolute_time` claim predicate.
       #
       # This predicate will be fulfilled if the closing time of the ledger that includes
-      # the DigitalBits::CreateClaimableBalance operation is less than provided timestamp.
+      # the Digitalbits::CreateClaimableBalance operation is less than provided timestamp.
       #
       # @param timestamp [#to_time|#to_int|#to_i] time value or timestamp
       #

data/lib/digitalbits/compat.rb

@@ -1,8 +1,8 @@
-class << DigitalBits::Operation
+class << Digitalbits::Operation
   alias_method :manage_offer, :manage_sell_offer
   alias_method :create_passive_offer, :create_passive_sell_offer
 
-  deprecate deprecator: DigitalBits::Deprecation,
+  deprecate deprecator: Digitalbits::Deprecation,
             manage_offer: :manage_sell_offer,
             create_passive_offer: :create_passive_sell_offer,
             allow_trust: :set_trust_line_flags

data/lib/digitalbits/concerns/transaction.rb

@@ -1,4 +1,4 @@
-module DigitalBits::Concerns
+module Digitalbits::Concerns
   module Transaction
     # Returns the string of bytes that, when hashed, provide the value which
     # should be signed to create a valid digitalbits transaction signature
@@ -32,7 +32,7 @@ module DigitalBits::Concerns
     #
     # @return [Array<Operation>] the operations
     def to_operations
-      codec = XDR::VarArray[DigitalBits::Operation]
+      codec = XDR::VarArray[Digitalbits::Operation]
       ops = respond_to?(:operations) ? operations : inner_tx.value.tx.operations
       cloned = codec.from_xdr(codec.to_xdr(ops))
       cloned.each do |op|
@@ -43,8 +43,8 @@ module DigitalBits::Concerns
     def apply_defaults
       self.operations ||= []
       self.fee ||= 100
-      self.memo ||= DigitalBits::Memo.new(:memo_none)
-      self.ext ||= DigitalBits::Transaction::Ext.new 0
+      self.memo ||= Digitalbits::Memo.new(:memo_none)
+      self.ext ||= Digitalbits::Transaction::Ext.new 0
     end
   end
 end

data/lib/digitalbits/convert.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   #
   # Generic format conversion module
   #
@@ -21,10 +21,10 @@ module DigitalBits
       Base64.strict_decode64(base64_string)
     end
 
-    ## Converts a DigitalBits::PublicKey instance (or any typedef of it such as
-    # DigitalBits::AccountID) to an address
+    ## Converts a Digitalbits::PublicKey instance (or any typedef of it such as
+    # Digitalbits::AccountID) to an address
     def pk_to_address(pk)
-      DigitalBits::Util::StrKey.check_encode(:account_id, pk.ed25519!)
+      Digitalbits::Util::StrKey.check_encode(:account_id, pk.ed25519!)
     end
 
     extend self

data/lib/digitalbits/dsl.rb

@@ -1,17 +1,17 @@
-module DigitalBits
+module Digitalbits
   module DSL
     module_function
 
     # Constructs a new ClaimPredicate using DSL
     #
     # @example fulfilled during [T+5min, T+60min] period, where T refers to claimable balance entry creation time
-    #   DigitalBits::ClaimPredicate { before_relative_time(1.hour) & ~before_relative_time(5.minutes) }
+    #   Digitalbits::ClaimPredicate { before_relative_time(1.hour) & ~before_relative_time(5.minutes) }
     #
     # @example not fulfilled starting from today midnight until tomorrow midnight,
-    #   DigitalBits::ClaimPredicate { before_absolute_time(Date.today.end_of_day) | ~before_absolute_time(Date.tomorrow.end_of_day) }
+    #   Digitalbits::ClaimPredicate { before_absolute_time(Date.today.end_of_day) | ~before_absolute_time(Date.tomorrow.end_of_day) }
     #
     # @example always fulfilled
-    #   DigitalBits::ClaimPredicate { }
+    #   Digitalbits::ClaimPredicate { }
     def ClaimPredicate(&block)
       return ClaimPredicate.unconditional unless block
       ClaimPredicate.compose(&block)
@@ -28,8 +28,8 @@ module DigitalBits
     end
 
     # @param [Asset, String, nil] subject
-    # @return [DigitalBits::Asset] instance of the DigitalBits::Asset
-    # @raise [TypeError] if subject cannot be converted to DigitalBits::Asset
+    # @return [Digitalbits::Asset] instance of the Digitalbits::Asset
+    # @raise [TypeError] if subject cannot be converted to Digitalbits::Asset
     def Asset(subject = nil)
       case subject
       when Asset
@@ -41,14 +41,14 @@ module DigitalBits
       when /^([0-9A-Z]{5,12})[-:](G[A-Z0-9]{55})$/
         Asset.alphanum12($1, KeyPair($2))
       else
-        raise TypeError, "Cannot convert #{subject.inspect} to DigitalBits::Asset"
+        raise TypeError, "Cannot convert #{subject.inspect} to Digitalbits::Asset"
       end
     end
 
-    # Generates DigitalBits::Keypair from subject, use DigitalBits::Client.to_keypair as shortcut.
-    # @param subject [String|DigitalBits::Account|DigitalBits::PublicKey|DigitalBits::SignerKey|DigitalBits::Keypair] subject.
-    # @return [DigitalBits::Keypair] DigitalBits::Keypair instance.
-    # @raise [TypeError] if subject cannot be converted to DigitalBits::KeyPair
+    # Generates Digitalbits::Keypair from subject, use Digitalbits::Client.to_keypair as shortcut.
+    # @param subject [String|Digitalbits::Account|Digitalbits::PublicKey|Digitalbits::SignerKey|Digitalbits::Keypair] subject.
+    # @return [Digitalbits::Keypair] Digitalbits::Keypair instance.
+    # @raise [TypeError] if subject cannot be converted to Digitalbits::KeyPair
     def KeyPair(subject = nil)
       case subject
       when ->(subj) { subj.respond_to?(:to_keypair) }
@@ -66,21 +66,21 @@ module DigitalBits
       when nil
         KeyPair.random
       else
-        raise TypeError, "cannot convert #{subject.inspect} to DigitalBits::KeyPair"
+        raise TypeError, "cannot convert #{subject.inspect} to Digitalbits::KeyPair"
       end
     end
 
     # Provides conversion from different input types into the SignerKey to use in ManageData operation.
-    # @param input [String|zDigitalBits::Account|DigitalBits::PublicKey|DigitalBits::SignerKey|DigitalBits::Keypair] subject.
-    # @return [DigitalBits::SignerKey] DigitalBits::Keypair instance.
+    # @param input [String|zDigitalbits::Account|Digitalbits::PublicKey|Digitalbits::SignerKey|Digitalbits::Keypair] subject.
+    # @return [Digitalbits::SignerKey] Digitalbits::Keypair instance.
     def SignerKey(input = nil)
       case input
       when Transaction
         SignerKey.pre_auth_tx(input.hash)
       when /^[0-9A-Za-z+\/=]{44}$/
-        SignerKey.hash_x(DigitalBits::Convert.from_base64(input))
+        SignerKey.hash_x(Digitalbits::Convert.from_base64(input))
       when /^[0-9a-f]{64}$/
-        SignerKey.hash_x(DigitalBits::Convert.from_hex(input))
+        SignerKey.hash_x(Digitalbits::Convert.from_hex(input))
       when /^.{32}$/
         SignerKey.hash_x(input)
       else

data/lib/digitalbits/fee_bump_transaction.rb

@@ -1,6 +1,6 @@
-module DigitalBits
+module Digitalbits
   class FeeBumpTransaction
-    include DigitalBits::Concerns::Transaction
+    include Digitalbits::Concerns::Transaction
 
     def to_envelope(*key_pairs)
       signatures = (key_pairs || []).map(&method(:sign_decorated))
@@ -9,9 +9,9 @@ module DigitalBits
     end
 
     def signature_base_prefix
-      val = DigitalBits::EnvelopeType.envelope_type_tx_fee_bump
+      val = Digitalbits::EnvelopeType.envelope_type_tx_fee_bump
 
-      DigitalBits.current_network_id + DigitalBits::EnvelopeType.to_xdr(val)
+      Digitalbits.current_network_id + Digitalbits::EnvelopeType.to_xdr(val)
     end
 
     def source_account

data/lib/digitalbits/key_pair.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   class KeyPair
     module FactoryMethods
       def from_seed(seed)
@@ -34,7 +34,7 @@ module DigitalBits
       end
 
       def master
-        from_raw_seed(DigitalBits.current_network_id)
+        from_raw_seed(Digitalbits.current_network_id)
       end
     end
 
@@ -56,19 +56,19 @@ module DigitalBits
     end
 
     def account_id
-      DigitalBits::AccountID.new :public_key_type_ed25519, raw_public_key
+      Digitalbits::AccountID.new :public_key_type_ed25519, raw_public_key
     end
 
     def muxed_account
-      DigitalBits::MuxedAccount.new :key_type_ed25519, raw_public_key
+      Digitalbits::MuxedAccount.new :key_type_ed25519, raw_public_key
     end
 
     def public_key
-      DigitalBits::PublicKey.new :public_key_type_ed25519, raw_public_key
+      Digitalbits::PublicKey.new :public_key_type_ed25519, raw_public_key
     end
 
     def signer_key
-      DigitalBits::SignerKey.new :signer_key_type_ed25519, raw_public_key
+      Digitalbits::SignerKey.new :signer_key_type_ed25519, raw_public_key
     end
 
     def signature_hint
@@ -105,7 +105,7 @@ module DigitalBits
 
     def sign_decorated(message)
       raw_signature = sign(message)
-      DigitalBits::DecoratedSignature.new({
+      Digitalbits::DecoratedSignature.new({
         hint: signature_hint,
         signature: raw_signature
       })

data/lib/digitalbits/ledger_key.rb

@@ -1,10 +1,10 @@
 require "digitalbits/convert"
 require "digitalbits/dsl"
 
-module DigitalBits
+module Digitalbits
   class LedgerKey
     class << self
-      include DigitalBits::DSL
+      include Digitalbits::DSL
 
       def switch_for_arm(name)
         (@switch_by_arm ||= switches.invert).fetch(name)
@@ -16,7 +16,7 @@ module DigitalBits
         when nil
           account(account_id: KeyPair(account_id).account_id)
         when :balance_id
-          claimable_balance(balance_id: ClaimableBalanceID.v0(DigitalBits::Convert.from_hex(value.to_s)))
+          claimable_balance(balance_id: ClaimableBalanceID.v0(Digitalbits::Convert.from_hex(value.to_s)))
         when :offer_id
           offer(seller_id: account_id, offer_id: Integer(value))
         when :data_name

data/lib/digitalbits/muxed_account.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   class MuxedAccount
     def to_keypair
       case arm

data/lib/digitalbits/networks.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   # Provides a container for well-known network passphrases, such as the main network and SDF test network
   module Networks
     PUBLIC = "LiveNet Global DigitalBits Network ; February 2021"
@@ -12,16 +12,16 @@ module DigitalBits
   #        methods of specifying a network if you need two threads in the same process to communicate with
   #        different networks
   #
-  # @see DigitalBits.on_network
+  # @see Digitalbits.on_network
   mattr_accessor :default_network, default: Networks::TESTNET
 
   # DigitalBits network passphrase selected for current thread
   #
-  # @see DigitalBits.current_network
-  # @see DigitalBits.on_network
+  # @see Digitalbits.current_network
+  # @see Digitalbits.on_network
   thread_mattr_accessor :network
 
-  # Returns the passphrase for the network currently active per-thread with a fallback to `DigitalBits.default_network`
+  # Returns the passphrase for the network currently active per-thread with a fallback to `Digitalbits.default_network`
   def self.current_network
     network.presence || default_network
   end

data/lib/digitalbits/operation.rb

@@ -1,35 +1,35 @@
 require "bigdecimal"
 
-module DigitalBits
+module Digitalbits
   class Operation
     MAX_INT64 = 2**63 - 1
     TRUST_LINE_FLAGS_MAPPING = {
-      full: DigitalBits::TrustLineFlags.authorized_flag,
-      maintain_liabilities: DigitalBits::TrustLineFlags.authorized_to_maintain_liabilities_flag,
-      clawback_enabled: DigitalBits::TrustLineFlags.trustline_clawback_enabled_flag
+      full: Digitalbits::TrustLineFlags.authorized_flag,
+      maintain_liabilities: Digitalbits::TrustLineFlags.authorized_to_maintain_liabilities_flag,
+      clawback_enabled: false
     }.freeze
 
     class << self
-      include DigitalBits::DSL
+      include Digitalbits::DSL
       #
-      # Construct a new DigitalBits::Operation from the provided
+      # Construct a new Digitalbits::Operation from the provided
       # source account and body
       #
       # @param [Hash] attributes the attributes to create the operation with
-      # @option attributes [DigitalBits::KeyPair] :source_account
-      # @option attributes [DigitalBits::Operation::Body] :body
+      # @option attributes [Digitalbits::KeyPair] :source_account
+      # @option attributes [Digitalbits::Operation::Body] :body
       #
-      # @return [DigitalBits::Operation] the built operation
+      # @return [Digitalbits::Operation] the built operation
       def make(attributes = {})
         source_account = attributes[:source_account]
 
-        if source_account && !source_account.is_a?(DigitalBits::KeyPair)
+        if source_account && !source_account.is_a?(Digitalbits::KeyPair)
           raise ArgumentError, "Bad :source_account"
         end
 
-        body = DigitalBits::Operation::Body.new(*attributes[:body])
+        body = Digitalbits::Operation::Body.new(*attributes[:body])
 
-        DigitalBits::Operation.new(
+        Digitalbits::Operation.new(
           body: body,
           source_account: source_account&.muxed_account
         )
@@ -40,13 +40,13 @@ module DigitalBits
       # in the necessary XDR structs to be included within a
       # transactions `operations` array.
       #
-      # @see DigitalBits::Asset
+      # @see Digitalbits::Asset
       #
       # @param [Hash] attributes the attributes to create the operation with
-      # @option attributes [DigitalBits::KeyPair] :destination the receiver of the payment
+      # @option attributes [Digitalbits::KeyPair] :destination the receiver of the payment
       # @option attributes [Array] :amount the amount to pay
-      # @return [DigitalBits::Operation] the built operation, containing a
-      #                              DigitalBits::PaymentOp body
+      # @return [Digitalbits::Operation] the built operation, containing a
+      #                              Digitalbits::PaymentOp body
       def payment(attributes = {})
         destination = attributes[:destination]
         asset, amount = get_asset_amount(attributes[:amount])
@@ -70,15 +70,15 @@ module DigitalBits
       #
       # @deprecated Please use Operation.path_payment_strict_receive
       #
-      # @see DigitalBits::Asset
+      # @see Digitalbits::Asset
       #
       # @param [Hash] attributes the attributes to create the operation with
-      # @option attributes [DigitalBits::KeyPair] :destination the receiver of the payment
+      # @option attributes [Digitalbits::KeyPair] :destination the receiver of the payment
       # @option attributes [Array] :amount the destination asset and the amount to pay
       # @option attributes [Array] :with the source asset and maximum allowed source amount to pay with
-      # @option attributes [Array<DigitalBits::Asset>] :path the payment path to use
+      # @option attributes [Array<Digitalbits::Asset>] :path the payment path to use
       #
-      # @return [DigitalBits::Operation] the built operation, containing a DigitalBits::PaymentOp body
+      # @return [Digitalbits::Operation] the built operation, containing a Digitalbits::PaymentOp body
       #
       def path_payment(attributes = {})
         path_payment_strict_receive(attributes)
@@ -89,22 +89,22 @@ module DigitalBits
       # in the necessary XDR structs to be included within a
       # transactions `operations` array.
       #
-      # @see DigitalBits::Asset
+      # @see Digitalbits::Asset
       #
       # @param [Hash] attributes the attributes to create the operation with
-      # @option attributes [DigitalBits::KeyPair] :destination the receiver of the payment
+      # @option attributes [Digitalbits::KeyPair] :destination the receiver of the payment
       # @option attributes [Array] :amount the destination asset and the amount to pay
       # @option attributes [Array] :with the source asset and maximum allowed source amount to pay with
-      # @option attributes [Array<DigitalBits::Asset>] :path the payment path to use
+      # @option attributes [Array<Digitalbits::Asset>] :path the payment path to use
       #
-      # @return [DigitalBits::Operation] the built operation, containing a DigitalBits::PaymentOp body
+      # @return [Digitalbits::Operation] the built operation, containing a Digitalbits::PaymentOp body
       #
       def path_payment_strict_receive(attributes = {})
         destination = attributes[:destination]
         asset, amount = get_asset_amount(attributes[:amount])
         send_asset, send_max = get_asset_amount(attributes[:with])
         path = (attributes[:path] || []).map { |p|
-          p.is_a?(Array) ? DigitalBits::Asset.send(*p) : p
+          p.is_a?(Array) ? Digitalbits::Asset.send(*p) : p
         }
 
         raise ArgumentError unless destination.is_a?(KeyPair)
@@ -127,22 +127,22 @@ module DigitalBits
       # in the necessary XDR structs to be included within a
       # transactions `operations` array.
       #
-      # @see DigitalBits::Asset
+      # @see Digitalbits::Asset
       #
       # @param [Hash] attributes the attributes to create the operation with
-      # @option attributes [DigitalBits::KeyPair] :destination the receiver of the payment
+      # @option attributes [Digitalbits::KeyPair] :destination the receiver of the payment
       # @option attributes [Array] :amount the destination asset and the minimum amount of destination asset to be received
       # @option attributes [Array] :with the source asset and amount to pay with
-      # @option attributes [Array<DigitalBits::Asset>] :path the payment path to use
+      # @option attributes [Array<Digitalbits::Asset>] :path the payment path to use
       #
-      # @return [DigitalBits::Operation] the built operation, containing a DigitalBits::PaymentOp body
+      # @return [Digitalbits::Operation] the built operation, containing a Digitalbits::PaymentOp body
       #
       def path_payment_strict_send(attributes = {})
         destination = attributes[:destination]
         asset, dest_min = get_asset_amount(attributes[:amount])
         send_asset, send_amount = get_asset_amount(attributes[:with])
         path = (attributes[:path] || []).map { |p|
-          p.is_a?(Array) ? DigitalBits::Asset.send(*p) : p
+          p.is_a?(Array) ? Digitalbits::Asset.send(*p) : p
         }
 
         raise ArgumentError unless destination.is_a?(KeyPair)
@@ -180,12 +180,12 @@ module DigitalBits
       # transactions `operations` array.
       #
       # @param [Hash] attributes the attributes to create the operation with
-      # @option attributes [DigitalBits::Asset] :line the asset to trust
+      # @option attributes [Digitalbits::Asset] :line the asset to trust
       # @option attributes [Fixnum] :limit the maximum amount to trust, defaults to max int64,
       #                                    if the limit is set to 0 it deletes the trustline.
       #
-      # @return [DigitalBits::Operation] the built operation, containing a
-      #                              DigitalBits::ChangeTrustOp body
+      # @return [Digitalbits::Operation] the built operation, containing a
+      #                              Digitalbits::ChangeTrustOp body
       def change_trust(attributes = {})
         line = attributes[:line]
         unless line.is_a?(Asset)
@@ -209,7 +209,7 @@ module DigitalBits
       # Helper method to create a valid CreateClaimableBalanceOp, ready to be used
       # within a transactions `operations` array.
       #
-      # @see DigitalBits::DSL::Claimant
+      # @see Digitalbits::DSL::Claimant
       #
       # @param asset [Asset] the asset to transfer to a claimable balance
       # @param amount [Fixnum] the amount of `asset` to put into a claimable balance
@@ -225,11 +225,11 @@ module DigitalBits
       # Helper method to create a valid CreateClaimableBalanceOp, ready to be used
       # within a transactions `operations` array.
       #
-      # @see DigitalBits::DSL::Claimant
+      # @see Digitalbits::DSL::Claimant
       #
       # @param balance_id [ClaimableBalanceID] unique ID of claimable balance
       #
-      # @return [Operation] the built operation, containing a DigitalBits::ChangeTrustOp body
+      # @return [Operation] the built operation, containing a Digitalbits::ChangeTrustOp body
       def claim_claimable_balance(balance_id:, **attributes)
         op = ClaimClaimableBalanceOp.new(balance_id: balance_id)
 
@@ -344,18 +344,18 @@ module DigitalBits
       # transactions `operations` array.
       #
       # @param [Hash] attributes the attributes to create the operation with
-      # @option attributes [DigitalBits::KeyPair] :inflation_dest
-      # @option attributes [Array<DigitalBits::AccountFlags>] :set flags to set
-      # @option attributes [Array<DigitalBits::AccountFlags>] :clear flags to clear
+      # @option attributes [Digitalbits::KeyPair] :inflation_dest
+      # @option attributes [Array<Digitalbits::AccountFlags>] :set flags to set
+      # @option attributes [Array<Digitalbits::AccountFlags>] :clear flags to clear
       # @option attributes [String] :thresholds
-      # @option attributes [DigitalBits::Signer] :signer
+      # @option attributes [Digitalbits::Signer] :signer
       #
-      # @return [DigitalBits::Operation] the built operation, containing a
-      #                              DigitalBits::SetOptionsOp body
+      # @return [Digitalbits::Operation] the built operation, containing a
+      #                              Digitalbits::SetOptionsOp body
       def set_options(attributes = {})
         op = SetOptionsOp.new
-        op.set_flags = DigitalBits::AccountFlags.make_mask attributes[:set]
-        op.clear_flags = DigitalBits::AccountFlags.make_mask attributes[:clear]
+        op.set_flags = Digitalbits::AccountFlags.make_mask attributes[:set]
+        op.clear_flags = Digitalbits::AccountFlags.make_mask attributes[:clear]
         op.master_weight = attributes[:master_weight]
         op.low_threshold = attributes[:low_threshold]
         op.med_threshold = attributes[:med_threshold]
@@ -366,7 +366,7 @@ module DigitalBits
 
         inflation_dest = attributes[:inflation_dest]
         if inflation_dest
-          raise ArgumentError, "Bad :inflation_dest" unless inflation_dest.is_a?(DigitalBits::KeyPair)
+          raise ArgumentError, "Bad :inflation_dest" unless inflation_dest.is_a?(Digitalbits::KeyPair)
           op.inflation_dest = inflation_dest.account_id
         end
 
@@ -375,15 +375,15 @@ module DigitalBits
         }))
       end
 
-      # @param asset [DigitalBits::Asset]
-      # @param trustor [DigitalBits::KeyPair]
-      # @param flags [{String, Symbol, DigitalBits::TrustLineFlags => true, false}] flags to to set or clear
-      # @param source_account [DigitalBits::KeyPair]  source account (default is `nil`, which will use the source account of transaction)
+      # @param asset [Digitalbits::Asset]
+      # @param trustor [Digitalbits::KeyPair]
+      # @param flags [{String, Symbol, Digitalbits::TrustLineFlags => true, false}] flags to to set or clear
+      # @param source_account [Digitalbits::KeyPair]  source account (default is `nil`, which will use the source account of transaction)
       def set_trust_line_flags(asset:, trustor:, flags: {}, source_account: nil)
-        op = DigitalBits::SetTrustLineFlagsOp.new
+        op = Digitalbits::SetTrustLineFlagsOp.new
         op.trustor = KeyPair(trustor).account_id
         op.asset = Asset(asset)
-        op.attributes = DigitalBits::TrustLineFlags.set_clear_masks(flags)
+        op.attributes = Digitalbits::TrustLineFlags.set_clear_masks(flags)
 
         make(
           source_account: source_account,
@@ -400,12 +400,12 @@ module DigitalBits
       # @deprecated Use `set_trustline_flags` operation
       #
       # @param [Hash] attributes the attributes to create the operation with
-      # @option attributes [DigitalBits::KeyPair] :trustor
-      # @option attributes [DigitalBits::Asset] :asset
+      # @option attributes [Digitalbits::KeyPair] :trustor
+      # @option attributes [Digitalbits::Asset] :asset
       # @option attributes [Symbol, Boolean] :authorize :full, maintain_liabilities or :none
       #
-      # @return [DigitalBits::Operation] the built operation, containing a
-      #                              DigitalBits::AllowTrustOp body
+      # @return [Digitalbits::Operation] the built operation, containing a
+      #                              Digitalbits::AllowTrustOp body
       def allow_trust(attributes = {})
         op = AllowTrustOp.new
 
@@ -417,7 +417,7 @@ module DigitalBits
           asset = Asset.send(*asset)
         end
 
-        raise ArgumentError, "Bad :trustor" unless trustor.is_a?(DigitalBits::KeyPair)
+        raise ArgumentError, "Bad :trustor" unless trustor.is_a?(Digitalbits::KeyPair)
 
         allowed_flags = TRUST_LINE_FLAGS_MAPPING.slice(:full, :maintain_liabilities)
 
@@ -430,7 +430,7 @@ module DigitalBits
           raise ArgumentError, "Bad :authorize, supported values: :full, :maintain_liabilities, :none"
         end
 
-        raise ArgumentError, "Bad :asset" unless asset.type == DigitalBits::AssetType.asset_type_credit_alphanum4
+        raise ArgumentError, "Bad :asset" unless asset.type == Digitalbits::AssetType.asset_type_credit_alphanum4
 
         op.trustor = trustor.account_id
         op.asset = AssetCode.new(:asset_type_credit_alphanum4, asset.code)
@@ -444,9 +444,9 @@ module DigitalBits
       # Helper method to create an account merge operation
       #
       # @param [Hash] attributes the attributes to create the operation with
-      # @option attributes [DigitalBits::KeyPair]  :destination
+      # @option attributes [Digitalbits::KeyPair]  :destination
       #
-      # @return [DigitalBits::Operation] the built operation
+      # @return [Digitalbits::Operation] the built operation
       def account_merge(attributes = {})
         destination = attributes[:destination]
 
@@ -464,7 +464,7 @@ module DigitalBits
       # @param [Hash] attributes the attributes to create the operation with
       # @option attributes [Integer]  :sequence
       #
-      # @return [DigitalBits::Operation] the built operation
+      # @return [Digitalbits::Operation] the built operation
       def inflation(attributes = {})
         sequence = attributes[:sequence]
 
@@ -482,7 +482,7 @@ module DigitalBits
       # @param [Hash] attributes the attributes to create the operation with
       # @option attributes [Integer]  :sequence
       #
-      # @return [DigitalBits::Operation] the built operation
+      # @return [Digitalbits::Operation] the built operation
       def manage_data(attributes = {})
         op = ManageDataOp.new
 
@@ -543,12 +543,12 @@ module DigitalBits
 
       # Helper method to create clawback claimable balance operation
       #
-      # @param [DigitalBits::KeyPair] source_account the attributes to create the operation with
+      # @param [Digitalbits::KeyPair] source_account the attributes to create the operation with
       # @param [String] balance_id `ClaimableBalanceID`, serialized in hex
       #
-      # @return [DigitalBits::Operation] the built operation
+      # @return [Digitalbits::Operation] the built operation
       def clawback_claimable_balance(source_account:, balance_id:)
-        balance_id = DigitalBits::ClaimableBalanceID.from_xdr(balance_id, :hex)
+        balance_id = Digitalbits::ClaimableBalanceID.from_xdr(balance_id, :hex)
         op = ClawbackClaimableBalanceOp.new(balance_id: balance_id)
 
         make(
@@ -563,10 +563,10 @@ module DigitalBits
 
       def get_asset_amount(values)
         amount = interpret_amount(values.last)
-        asset = if values[0].is_a?(DigitalBits::Asset)
+        asset = if values[0].is_a?(Digitalbits::Asset)
           values.first
         else
-          DigitalBits::Asset.send(*values[0...-1])
+          Digitalbits::Asset.send(*values[0...-1])
         end
 
         [asset, amount]
@@ -575,11 +575,11 @@ module DigitalBits
       def interpret_amount(amount)
         case amount
         when String
-          (BigDecimal(amount) * DigitalBits::ONE).floor
+          (BigDecimal(amount) * Digitalbits::ONE).floor
         when Integer
-          amount * DigitalBits::ONE
+          amount * Digitalbits::ONE
         when Numeric
-          (amount * DigitalBits::ONE).floor
+          (amount * Digitalbits::ONE).floor
         else
           raise ArgumentError, "Invalid amount type: #{amount.class}. Must be String or Numeric"
         end
@@ -592,10 +592,10 @@ module DigitalBits
           Price.from_f(bd)
         when Numeric
           Price.from_f(price)
-        when DigitalBits::Price
+        when Digitalbits::Price
           price
         else
-          raise ArgumentError, "Invalid price type: #{price.class}. Must be String, Numeric, or DigitalBits::Price"
+          raise ArgumentError, "Invalid price type: #{price.class}. Must be String, Numeric, or Digitalbits::Price"
         end
       end
     end

data/lib/digitalbits/path_payment_strict_receive_result.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   class PathPaymentStrictReceiveResult
     # send_amount returns the actual amount paid for the corresponding
     # PathPaymentOp to this result.

data/lib/digitalbits/price.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   # reopen class
   class Price
     MAX_PRECISION = (2**31) - 1
@@ -33,7 +33,7 @@ module DigitalBits
     end
 
     def inspect
-      "#<DigitalBits::Price #{self}>"
+      "#<Digitalbits::Price #{self}>"
     end
   end
 end

data/lib/digitalbits/signer_key.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   class SignerKey
     PREIMAGE_LENGTH = 32
 
@@ -22,20 +22,20 @@ module DigitalBits
     def to_s
       case switch
       when SignerKeyType.signer_key_type_ed25519
-        address = DigitalBits::Convert.pk_to_address(self)
+        address = Digitalbits::Convert.pk_to_address(self)
         "ed25519: #{address}"
       when SignerKeyType.signer_key_type_pre_auth_tx
-        tx = DigitalBits::Convert.to_hex(pre_auth_tx!)
+        tx = Digitalbits::Convert.to_hex(pre_auth_tx!)
         "pre_auth_tx: #{tx}"
       when SignerKeyType.signer_key_type_hash_x
-        hx = DigitalBits::Convert.to_hex(hash_x!)
+        hx = Digitalbits::Convert.to_hex(hash_x!)
         "hash_x: #{hx}"
       end
     end
 
     def inspect
       # label = switch.to_s
-      "#<DigitalBits::SignerKey #{self}>"
+      "#<Digitalbits::SignerKey #{self}>"
     end
 
     def signature_hint

data/lib/digitalbits/thresholds.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   class << Thresholds
     COMPONENTS = [:master_weight, :low, :medium, :high]
     VALID_RANGE = 0..255

data/lib/digitalbits/transaction.rb

@@ -1,9 +1,9 @@
-module DigitalBits
+module Digitalbits
   class Transaction
-    include DigitalBits::Concerns::Transaction
+    include Digitalbits::Concerns::Transaction
 
     def to_v0
-      ed25519 = if source_account.switch == DigitalBits::CryptoKeyType.key_type_ed25519
+      ed25519 = if source_account.switch == Digitalbits::CryptoKeyType.key_type_ed25519
         source_account.ed25519!
       else
         source_account.med25519!.ed25519
@@ -21,9 +21,9 @@ module DigitalBits
     end
 
     def signature_base
-      tagged_tx = DigitalBits::TransactionSignaturePayload::TaggedTransaction.new(:envelope_type_tx, self)
-      DigitalBits::TransactionSignaturePayload.new(
-        network_id: DigitalBits.current_network_id,
+      tagged_tx = Digitalbits::TransactionSignaturePayload::TaggedTransaction.new(:envelope_type_tx, self)
+      Digitalbits::TransactionSignaturePayload.new(
+        network_id: Digitalbits.current_network_id,
         tagged_transaction: tagged_tx
       ).to_xdr
     end

data/lib/digitalbits/transaction_builder.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   class TransactionBuilder
     attr_reader :source_account, :sequence_number, :base_fee, :time_bounds, :memo, :operations
 
@@ -9,17 +9,17 @@ module DigitalBits
       # It reduces the boilerplate, when you just need to
       # shoot a single operation in transaction
       def method_missing(method_name, *args, **kwargs)
-        unless DigitalBits::Operation.respond_to?(method_name)
+        unless Digitalbits::Operation.respond_to?(method_name)
           return super
         end
 
-        op = DigitalBits::Operation.send(method_name, **kwargs)
+        op = Digitalbits::Operation.send(method_name, **kwargs)
 
         new(**kwargs).add_operation(op).build
       end
 
       def respond_to_missing?(method_name, include_private = false)
-        DigitalBits::Operation.respond_to?(method_name) || super
+        Digitalbits::Operation.respond_to?(method_name) || super
       end
     end
 
@@ -31,9 +31,9 @@ module DigitalBits
       memo: nil,
       **_ # ignore any additional parameters without errors
     )
-      raise ArgumentError, "Bad :source_account" unless source_account.is_a?(DigitalBits::KeyPair)
+      raise ArgumentError, "Bad :source_account" unless source_account.is_a?(Digitalbits::KeyPair)
       raise ArgumentError, "Bad :sequence_number" unless sequence_number.is_a?(Integer) && sequence_number >= 0
-      raise ArgumentError, "Bad :time_bounds" unless time_bounds.is_a?(DigitalBits::TimeBounds) || time_bounds.nil?
+      raise ArgumentError, "Bad :time_bounds" unless time_bounds.is_a?(Digitalbits::TimeBounds) || time_bounds.nil?
       raise ArgumentError, "Bad :base_fee" unless base_fee.is_a?(Integer) && base_fee >= 100
 
       @source_account = source_account
@@ -65,18 +65,18 @@ module DigitalBits
         time_bounds: @time_bounds,
         memo: @memo,
         operations: @operations,
-        ext: DigitalBits::Transaction::Ext.new(0)
+        ext: Digitalbits::Transaction::Ext.new(0)
       }
 
       @sequence_number += 1
 
-      DigitalBits::Transaction.new(attrs)
+      Digitalbits::Transaction.new(attrs)
     end
 
     def build_fee_bump(inner_txe:)
-      if inner_txe.switch == DigitalBits::EnvelopeType.envelope_type_tx_v0
-        inner_txe = DigitalBits::TransactionEnvelope.v1(tx: inner_txe.tx.to_v1, signatures: inner_txe.signatures)
-      elsif inner_txe.switch != DigitalBits::EnvelopeType.envelope_type_tx
+      if inner_txe.switch == Digitalbits::EnvelopeType.envelope_type_tx_v0
+        inner_txe = Digitalbits::TransactionEnvelope.v1(tx: inner_txe.tx.to_v1, signatures: inner_txe.signatures)
+      elsif inner_txe.switch != Digitalbits::EnvelopeType.envelope_type_tx
         raise ArgumentError, "Invalid inner transaction type #{inner_txe.switch}"
       end
 
@@ -89,16 +89,16 @@ module DigitalBits
         raise "Insufficient base_fee, it should be at least #{inner_base_fee_rate} stroops."
       end
 
-      DigitalBits::FeeBumpTransaction.new(
+      Digitalbits::FeeBumpTransaction.new(
         fee_source: @source_account.muxed_account,
         fee: @base_fee * (inner_ops.length + 1),
-        inner_tx: DigitalBits::FeeBumpTransaction::InnerTx.new(:envelope_type_tx, inner_txe.v1!),
-        ext: DigitalBits::FeeBumpTransaction::Ext.new(0)
+        inner_tx: Digitalbits::FeeBumpTransaction::InnerTx.new(:envelope_type_tx, inner_txe.v1!),
+        ext: Digitalbits::FeeBumpTransaction::Ext.new(0)
       )
     end
 
     def add_operation(operation)
-      raise ArgumentError, "Bad operation" unless operation.is_a? DigitalBits::Operation
+      raise ArgumentError, "Bad operation" unless operation.is_a? Digitalbits::Operation
       @operations.push(operation)
       self
     end
@@ -109,7 +109,7 @@ module DigitalBits
     end
 
     def set_source_account(account_kp)
-      raise ArgumentError, "Bad source account" unless account_kp.is_a?(DigitalBits::KeyPair)
+      raise ArgumentError, "Bad source account" unless account_kp.is_a?(Digitalbits::KeyPair)
       @source_account = account_kp
       self
     end
@@ -126,7 +126,7 @@ module DigitalBits
       end
 
       if @time_bounds.nil?
-        @time_bounds = DigitalBits::TimeBounds.new(min_time: 0, max_time: nil)
+        @time_bounds = Digitalbits::TimeBounds.new(min_time: 0, max_time: nil)
       end
 
       @time_bounds.max_time = timeout == 0 ? timeout : Time.now.to_i + timeout
@@ -147,7 +147,7 @@ module DigitalBits
 
     def make_memo(memo)
       case memo
-      when DigitalBits::Memo
+      when Digitalbits::Memo
         memo
       when nil
         Memo.new(:memo_none)

data/lib/digitalbits/transaction_envelope.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   class TransactionEnvelope
     delegate :tx, :signatures, to: :value
     delegate :hash, to: :tx
@@ -9,7 +9,7 @@ module DigitalBits
     # NOTE: this does not do any authorization checks, which requires access to
     # the current ledger state.
     #
-    # @param key_pairs [Array<DigitalBits::KeyPair>] The key pairs to check the envelopes signatures against
+    # @param key_pairs [Array<Digitalbits::KeyPair>] The key pairs to check the envelopes signatures against
     #
     # @return [Boolean] true if all signatures are from the provided key_pairs and validly sign the tx's hash
     def signed_correctly?(*key_pairs)

data/lib/digitalbits/transaction_v0.rb

@@ -1,6 +1,6 @@
-module DigitalBits
+module Digitalbits
   class TransactionV0
-    include DigitalBits::Concerns::Transaction
+    include Digitalbits::Concerns::Transaction
 
     def to_v1
       Transaction.new(**attributes.except(:source_account_ed25519), source_account: source_account)
@@ -13,31 +13,31 @@ module DigitalBits
     end
 
     def signature_base_prefix
-      val = DigitalBits::EnvelopeType.envelope_type_tx_v0
+      val = Digitalbits::EnvelopeType.envelope_type_tx_v0
 
-      DigitalBits.current_network_id + DigitalBits::EnvelopeType.to_xdr(val)
+      Digitalbits.current_network_id + Digitalbits::EnvelopeType.to_xdr(val)
     end
 
     # Backwards Compatibility: Use ENVELOPE_TYPE_TX to sign ENVELOPE_TYPE_TX_V0
     # we need a Transaction to generate the signature base
     def signature_base
-      tx = DigitalBits::Transaction.from_xdr(
+      tx = Digitalbits::Transaction.from_xdr(
         # TransactionV0 is a transaction with the AccountID discriminant
         # stripped off, we need to put it back to build a valid transaction
         # which we can use to build a TransactionSignaturePayloadTaggedTransaction
-        DigitalBits::PublicKeyType.to_xdr(DigitalBits::PublicKeyType.public_key_type_ed25519) + to_xdr
+        Digitalbits::PublicKeyType.to_xdr(Digitalbits::PublicKeyType.public_key_type_ed25519) + to_xdr
       )
 
-      tagged_tx = DigitalBits::TransactionSignaturePayload::TaggedTransaction.new(:envelope_type_tx, tx)
+      tagged_tx = Digitalbits::TransactionSignaturePayload::TaggedTransaction.new(:envelope_type_tx, tx)
 
-      DigitalBits::TransactionSignaturePayload.new(
-        network_id: DigitalBits.current_network_id,
+      Digitalbits::TransactionSignaturePayload.new(
+        network_id: Digitalbits.current_network_id,
         tagged_transaction: tagged_tx
       ).to_xdr
     end
 
     def source_account
-      DigitalBits::MuxedAccount.ed25519(source_account_ed25519)
+      Digitalbits::MuxedAccount.ed25519(source_account_ed25519)
     end
   end
 end

data/lib/digitalbits/trust_line_flags.rb

@@ -1,9 +1,9 @@
-module DigitalBits
+module Digitalbits
   class TrustLineFlags
-    # Converts an array of DigitalBits::TrustLineFlags members into
+    # Converts an array of Digitalbits::TrustLineFlags members into
     # an integers suitable for use in in a SetTrustLineFlagsOp.
     #
-    # @param flags [Array<DigitalBits::TrustLineFlags>] the flags to combine
+    # @param flags [Array<Digitalbits::TrustLineFlags>] the flags to combine
     #
     # @return [Fixnum] the combined result
     def self.make_mask(flags)
@@ -11,23 +11,23 @@ module DigitalBits
     end
 
     # Converts an integer used in SetTrustLineFlagsOp on the set/clear flag options
-    # into an array of DigitalBits::TrustLineFlags members
+    # into an array of Digitalbits::TrustLineFlags members
     #
     #  @param combined [Fixnum]
-    #  @return [Array<DigitalBits::AccountFlags>]
+    #  @return [Array<Digitalbits::AccountFlags>]
     def self.parse_mask(combined)
       members.values.select { |m| (m.value & combined) != 0 }
     end
 
-    # Converts each element of the input array to DigitalBits::TrustLineFlags instance.
+    # Converts each element of the input array to Digitalbits::TrustLineFlags instance.
     #
-    # @param [Array<DigitalBits::TrustLineFlags,Symbol,#to_s>] input
-    # @return [Array<DigitalBits::TrustLineFlags>]
+    # @param [Array<Digitalbits::TrustLineFlags,Symbol,#to_s>] input
+    # @return [Array<Digitalbits::TrustLineFlags>]
     # @raise [TypeError] if any element of the input cannot be converted
     def self.normalize(input)
       input.map do |val|
         case val
-        when DigitalBits::TrustLineFlags
+        when Digitalbits::TrustLineFlags
           val
         when ->(_) { members.key?(val.to_s) }
           from_name(val.to_s)

data/lib/digitalbits/util/strkey.rb

@@ -1,4 +1,4 @@
-module DigitalBits
+module Digitalbits
   module Util
     require "base32"
     require "digest/crc16_xmodem"
@@ -21,11 +21,11 @@ module DigitalBits
         Base32.encode(payload + check).tr("=", "")
       end
 
-      # Converts an DigitalBits::MuxedAccount to its string representation, forcing the ed25519 representation.
-      # @param muxed_account [DigitalBits::MuxedAccount] account
+      # Converts an Digitalbits::MuxedAccount to its string representation, forcing the ed25519 representation.
+      # @param muxed_account [Digitalbits::MuxedAccount] account
       # @return [String] "G.."-like address
       def self.encode_muxed_account(muxed_account)
-        ed25519 = if muxed_account.switch == DigitalBits::CryptoKeyType.key_type_ed25519
+        ed25519 = if muxed_account.switch == Digitalbits::CryptoKeyType.key_type_ed25519
           muxed_account.ed25519!
         else
           muxed_account.med25519!.ed25519
@@ -34,12 +34,12 @@ module DigitalBits
         check_encode(:account_id, ed25519)
       end
 
-      # Returns a DigitalBits::MuxedAccount, forcing the ed25519 discriminant
+      # Returns a Digitalbits::MuxedAccount, forcing the ed25519 discriminant
       #
       # @param strkey [String] address string to decode
-      # @return [DigitalBits::MuxedAccount] MuxedAccount with ed25519 discriminant
+      # @return [Digitalbits::MuxedAccount] MuxedAccount with ed25519 discriminant
       def self.decode_muxed_account(strkey)
-        DigitalBits::MuxedAccount.new(:key_type_ed25519, check_decode(:account_id, strkey))
+        Digitalbits::MuxedAccount.new(:key_type_ed25519, check_decode(:account_id, strkey))
       end
 
       def self.check_decode(expected_version, str)

data/lib/digitalbits/version.rb

@@ -1,3 +1,3 @@
-module DigitalBits
-  VERSION = "0.27.1"
+module Digitalbits
+  VERSION = "0.27.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: digitalbits-base
 version: !ruby/object:Gem::Version
-  version: 0.27.1
+  version: 0.27.2
 platform: ruby
 authors:
 - XDB Foundation
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-08-02 00:00:00.000000000 Z
+date: 2021-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -431,11 +431,11 @@ licenses:
 - Apache-2.0
 metadata:
   bug_tracker_uri: https://github.com/xdbfoundation/ruby-digitalbits-sdk/issues
-  changelog_uri: https://github.com/xdbfoundation/ruby-digitalbits-sdk/blob/v0.27.1/base/CHANGELOG.md
-  documentation_uri: https://rubydoc.info/gems/digitalbits-base/0.27.1/
+  changelog_uri: https://github.com/xdbfoundation/ruby-digitalbits-sdk/blob/v0.27.2/base/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/digitalbits-base/0.27.2/
   github_repo: ssh://github.com/xdbfoundation/ruby-digitalbits-sdk
   homepage_uri: https://github.com/xdbfoundation/ruby-digitalbits-sdk/tree/main/base
-  source_code_uri: https://github.com/xdbfoundation/ruby-digitalbits-sdk/tree/v0.27.1/base
+  source_code_uri: https://github.com/xdbfoundation/ruby-digitalbits-sdk/tree/v0.27.2/base
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -452,7 +452,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: 'DigitalBits client library: XDR'