This interface is used to set default account by given base58 encode address.

        :param b58_address: a base58 encode address.
328457
def set_default_account_by_address(self, b58_address: str):
        
        flag = True
        index = -1
        for acct in self.accounts:
            index += 1
            if acct.b58_address == b58_address:
                flag = False
                break
        if flag:
            raise SDKException(ErrorCode.get_account_by_address_err)
        for i in range(len(self.accounts)):
            self.accounts[i].is_default = False
        self.accounts[index].is_default = True
        self.default_account_address = b58_address
114321
private void setupDefaultAccountInfoHandler() {
		final BitfinexAccountSymbol accountSymbol = BitfinexSymbols.account(BitfinexApiKeyPermissions.NO_PERMISSIONS);
		final AccountInfoHandler accountInfoHandler = new AccountInfoHandler(ACCCOUNT_INFO_CHANNEL, accountSymbol);
		accountInfoHandler.onHeartbeatEvent(timestamp -> this.updateConnectionHeartbeat());
		channelIdToHandlerMap.put(ACCCOUNT_INFO_CHANNEL, accountInfoHandler);
	}
696249
def _factory_default(self, confirm=False):
        
        if confirm is True:
            self._write(('DFLT', Integer), 99)
        else:
            raise ValueError('Reset to factory defaults was not confirmed.')
932442
def btc_is_p2sh_address( address ):
    
    vb = keylib.b58check.b58check_version_byte( address )
    if vb == multisig_version_byte:
        return True
    else:
        return False
338939
function getBase58CheckAddress(addressBytes) {
  var hash0 = SHA256(addressBytes);
  var hash1 = SHA256(hash0);
  var checkSum = hash1.slice(0, 4);
  checkSum = addressBytes.concat(checkSum);
  var base58Check = encode58(checkSum);

  return base58Check;
}
519417
def set_default(eng, algorithms=0xFFFF):
    
    if not isinstance(eng,Engine):
        eng=Engine(eng)
    global default
    libcrypto.ENGINE_set_default(eng.ptr, c_int(algorithms))
    default = eng
686951
def to_b58check(self, testnet=False):
        
        b = self.testnet_bytes if testnet else bytes(self)
        return base58.b58encode_check(b)
803734
def encode_bu64(b):
    
    s = base64.standard_b64encode(b)
    s = s.rstrip('=')
    s = s.replace('+', '-')
    s = s.replace('/', '_')
    return s
664570
def is_valid_address_for_coinsymbol(b58_address, coin_symbol):
    '''
    
    '''
    assert is_valid_coin_symbol(coin_symbol)

    if b58_address[0] in COIN_SYMBOL_MAPPINGS[coin_symbol]['address_first_char_list']:
        if is_valid_address(b58_address):
            return True
    return False
1234037
def set_defaults
      # Some UIDs should not be remapped even if uid anonymization has been requested:
      @static_uids = {
        # Private related:
        '0002,0100' => true,
        '0004,1432' => true,
        # Coding scheme related:
        '0008,010C' => true,
        '0008,010D' => true,
        # Transfer syntax related:
        '0002,0010' => true,
        '0400,0010' => true,
        '0400,0510' => true,
        '0004,1512' => true,
        # SOP class related:
        '0000,0002' => true,
        '0000,0003' => true,
        '0002,0002' => true,
        '0004,1510' => true,
        '0004,151A' => true,
        '0008,0016' => true,
        '0008,001A' => true,
        '0008,001B' => true,
        '0008,0062' => true,
        '0008,1150' => true,
        '0008,115A' => true
      }
      # Sets up default tags that will be anonymized, along with default replacement values and enumeration settings.
      # This data is stored in 3 separate instance arrays for tags, values and enumeration.
      data = [
        ['0008,0012', '20000101', false], # Instance Creation Date
        ['0008,0013', '000000.00', false], # Instance Creation Time
        ['0008,0020', '20000101', false], # Study Date
        ['0008,0021', '20000101', false], # Series Date
        ['0008,0022', '20000101', false], # Acquisition Date
        ['0008,0023', '20000101', false], # Image Date
        ['0008,0030', '000000.00', false], # Study Time
        ['0008,0031', '000000.00', false], # Series Time
        ['0008,0032', '000000.00', false], # Acquisition Time
        ['0008,0033', '000000.00', false], # Image Time
        ['0008,0050', '', true], # Accession Number
        ['0008,0080', 'Institution', true], # Institution name
        ['0008,0081', 'Address', true], # Institution Address
        ['0008,0090', 'Physician', true], # Referring Physician's name
        ['0008,1010', 'Station', true], # Station name
        ['0008,1040', 'Department', true], # Institutional Department name
        ['0008,1070', 'Operator', true], # Operator's Name
        ['0010,0010', 'Patient', true], # Patient's name
        ['0010,0020', 'ID', true], # Patient's ID
        ['0010,0030', '20000101', false], # Patient's Birth Date
        ['0010,0040', 'O', false], # Patient's Sex
        ['0010,1010', '', false], # Patient's Age
        ['0020,4000', '', false], # Image Comments
      ].transpose
      @tags = data[0]
      @values = data[1]
      @enumerations = data[2]
      # Tags to be deleted completely during anonymization:
      @delete = Hash.new
    end
760596
function getBase58CheckAddressFromPriKeyBase64String(priKeyBase64String) {
  var priKeyBytes = base64DecodeFromString(priKeyBase64String);
  var pubBytes = getPubKeyFromPriKey(priKeyBytes);
  var addressBytes = computeAddress(pubBytes);
  return getBase58CheckAddress(addressBytes);
}
647064
public function setDefaultErrorCode(int $default_error_code = 301) : CNabuDataObject
    {
        if ($default_error_code === null) {
            throw new ENabuCoreException(
                    ENabuCoreException::ERROR_NULL_VALUE_NOT_ALLOWED_IN,
                    array("\$default_error_code")
            );
        }
        $this->setValue('nb_site_default_error_code', $default_error_code);
        
        return $this;
    }
548242
public function decodeBase58($base58)
    {
        $this->preOpMethodParamsCheck(array($base58));

        try {
            $origbase58 = $base58;
            $return     = '0';
            $b58_len    = strlen($base58);

            for ($i = 0; $i < $b58_len; $i++) {
                $current = strpos($this->b58_chars, $base58[$i]);
                $return  = $this->math->mul($return, '58');
                $return  = $this->math->add($return, $current);
            }

            $return = $this->encodeHex($return);

            for ($i = 0; $i < strlen($origbase58) && $origbase58[$i] == '1'; $i++) {
                $return = '00' . $return;
            }

            return (strlen($return) % 2 != 0) ? '0' . $return : $return;

        } catch (\Exception $e) {
            throw $e;
        }
    }
238651
def to_b58check(self, testnet=False):
        
        version = self.TESTNET_VERSION if testnet else self.MAINNET_VERSION
        return base58.b58encode_check(bytes([version]) + bytes(self))
364429
def get_account(address)
      address = Utils.normalize_address address, allow_blank: true
      rlpdata = @state[address]

      if rlpdata == Trie::BLANK_NODE
        Account.build_blank db, config[:account_initial_nonce]
      else
        RLP.decode(rlpdata, sedes: Account, db: db).tap do |acct|
          acct.make_mutable!
          acct._cached_rlp = nil
        end
      end
    end
979802
def _set_address(self, address, force=None):
        
        force = force if force is not None else self.force
        if self.address != address or self._force_last != force:
            if force is True:
                ioctl(self.fd, I2C_SLAVE_FORCE, address)
            else:
                ioctl(self.fd, I2C_SLAVE, address)
            self.address = address
            self._force_last = force
1104506
def default_value(self, default_value):
        
        # For custom value
        if default_value not in self.default_values:
            if len(self.default_labels) == len(self.default_values):
                self.default_values[-1] = default_value
            else:
                self.default_values.append(default_value)

        self._default_value = default_value