I have heard about this prediction too but from the source I heard the bull will start on 22 instead of 21. but if we are looking at our market right now, it does seem like that. even if the bull does not start this month, I do not see any reason for not holding Bitcoin at least until next year. difficulty adjustment might trigger the bull but personally speaking, I think the biggest reason for the bull would be halving, going up or not this month it does not matter for me.
|
|
|
~snip
I have seen many project which prices increase hundreds of times....I think it is interesting to invest some, maybe with not too much money And I have seen them dropped hundred of times too. The hype days for new coins/tokens were long gone and we can never be sure if we will ever see that happen again. In the next bull run, we might see only established coins/tokens pumping while leaving new ones in the dirt. It's still your money though, do what you want with it. Just don't complain when you get rekt. As a matter of fact, these kind of POC project took maybe 3 month to get the cost back, but as long as the price increases, you can get a very good result! Do not forget the team has 10% shares over the block reward. just think how many coins are generated daily and went to their pocket? yes, you can get the ROI back in three months if nothing happens, but what will happen if the team decides to dump all of their savings to the market next week? can the market sustain it?
|
|
|
From my point of view in 2020 there will be a stricter requirement for the project that wants to run the IEO on the exchange because of the full AML procedure. the government might preparing something under their sleeve after the exchanges finished their AMLD 5 procedure. which also means there will be less IEO in 2020, but it is good for the investors because the project that runs the IEO is a promising project after a series of selection and the probability for the project tor each their softcap is higher too. while for bounty hunter, this does not look good because the promising project does not need this level of marketing because they can use a big platform to advertise their project.
|
|
|
What is the point of holding it for a few years if you give it up now? not to mention how low the price is right now compared to where you bought it. it does not make any sense for me to sell it at this price, I would rather hold it into dust other than losing the chance for my portfolio to breakeven or even make a profit. holding is fine but you must know what is the reason you are holding it.
|
|
|
It took so many spaces copy-pasting it directly, try to use "Insert code" function. and it will become like this; enerate_class_string(typename, props, description, namespace): """Dynamically generate class strings to have nicely formatted docstrings, keyword arguments, and repr. ---------- typename props description namespace Returns ------- string """ # TODO _prop_names, _type, _namespace, and available_properties # can be modified by a Dash JS developer via setattr # TODO - Tab out the repr for the repr of these components to make it # look more like a hierarchical tree # TODO - Include "description" "defaultValue" in the repr and docstring # # TODO - Handle "required" # # TODO - How to handle user-given `null` values? I want to include # an expanded docstring like Dropdown(value=None, id=None) # but by templating in those None values, I have no way of knowing # whether a property is None because the user explicitly wanted # it to be `null` or whether that was just the default value. # The solution might be to deal with default values better although # not all component authors will supply those. c = '''class {typename}(Component): """{docstring}""" @_explicitize_args def __init__(self, {default_argtext}): self._prop_names = {list_of_valid_keys} self._type = '{typename}' self._namespace = '{namespace}' self._valid_wildcard_attributes =\ {list_of_valid_wildcard_attr_prefixes} self.available_properties = {list_of_valid_keys} self.available_wildcard_properties =\ {list_of_valid_wildcard_attr_prefixes} _explicit_args = kwargs.pop('_explicit_args') _locals = locals() _locals.update(kwargs) # For wildcard attrs args = {{k: _locals[k] for k in _explicit_args if k != 'children'}} for k in {required_props}: if k not in args: raise TypeError( 'Required argument `' + k + '` was not specified.') super({typename}, self).__init__({argtext}) '''
filtered_props = reorder_props(filter_props(props)) wildcard_prefixes = repr(parse_wildcards(props)) list_of_valid_keys = repr(list(map(str, filtered_props.keys()))) docstring = create_docstring( component_name=typename, props=filtered_props, description=description).replace('\r\n', '\n')
prohibit_events(props)
# pylint: disable=unused-variable prop_keys = list(props.keys()) if 'children' in props: prop_keys.remove('children') default_argtext = "children=None, " argtext = 'children=children, **args' else: default_argtext = "" argtext = '**args' default_argtext += ", ".join( [('{:s}=Component.REQUIRED'.format(p) if props[p]['required'] else '{:s}=Component.UNDEFINED'.format(p)) for p in prop_keys if not p.endswith("-*") and p not in python_keywords and p != 'setProps'] + ["**kwargs"] ) required_args = required_props(props) return c.format( typename=typename, namespace=namespace, filtered_props=filtered_props, list_of_valid_wildcard_attr_prefixes=wildcard_prefixes, list_of_valid_keys=list_of_valid_keys, docstring=docstring, default_argtext=default_argtext, argtext=argtext, required_props=required_args )
def generate_class_file(typename, props, description, namespace): """Generate a python class file (.py) given a class string. Parameters ---------- typename props description namespace Returns ------- """ import_string =\ "# AUTO GENERATED FILE - DO NOT EDIT\n\n" + \ "from dash.development.base_component import " + \ "Component, _explicitize_args\n\n\n" class_string = generate_class_string( typename, props, description, namespace ) file_name = "{:s}.py".format(typename)
file_path = os.path.join(namespace, file_name) with open(file_path, 'w') as f: f.write(import_string) f.write(class_string)
print('Generated {}'.format(file_name))
def generate_imports(project_shortname, components): with open(os.path.join(project_shortname, '_imports_.py'), 'w') as f: imports_string = '{}\n\n{}'.format( '\n'.join( 'from .{0} import {0}'.format(x) for x in components), '__all__ = [\n{}\n]'.format( ',\n'.join(' "{}"'.format(x) for x in components)) )
f.write(imports_string)
def generate_classes_files(project_shortname, metadata, *component_generators): components = [] for component_path, component_data in metadata.items(): component_name = component_path.split('/')[-1].split('.')[0] components.append(component_name)
for generator in component_generators: generator( component_name, component_data['props'], component_data['description'], project_shortname )
return components
def generate_class(typename, props, description, namespace): """Generate a python class object given a class string. Parameters ---------- typename props description namespace Returns ------- """ string = generate_class_string(typename, props, description, namespace) scope = {'Component': Component, '_explicitize_args': _explicitize_args} # pylint: disable=exec-used exec(string, scope) result = scope[typename] return result
def required_props(props): """Pull names of required props from the props object. Parameters ---------- props: dict Returns ------- list List of prop names (str) that are required for the Component """ return [prop_name for prop_name, prop in list(props.items()) if prop['required']]
def create_docstring(component_name, props, description): """Create the Dash component docstring. Parameters ---------- component_name: str Component name props: dict Dictionary with {propName: propMetadata} structure description: str Component description Returns ------- str Dash component docstring """ # Ensure props are ordered with children first props = reorder_props(props=props)
return ( """A{n} {name} component.\n{description} Keyword arguments:\n{args}""" ).format( n='n' if component_name[0].lower() in ['a', 'e', 'i', 'o', 'u'] else '', name=component_name, description=description, args='\n'.join( create_prop_docstring( prop_name=p, type_object=prop['type'] if 'type' in prop else prop['flowType'], required=prop['required'], description=prop['description'], default=prop.get('defaultValue'), indent_num=0, is_flow_type='flowType' in prop and 'type' not in prop) for p, prop in list(filter_props(props).items())))
def prohibit_events(props): """Events have been removed. Raise an error if we see dashEvents or fireEvents. Parameters ---------- props: dict Dictionary with {propName: propMetadata} structure Raises ------- ? """ if 'dashEvents' in props or 'fireEvents' in props: raise NonExistentEventException( 'Events are no longer supported by dash. Use properties instead, ' 'eg `n_clicks` instead of a `click` event.')
def parse_wildcards(props): """Pull out the wildcard attributes from the Component props. Parameters ---------- props: dict Dictionary with {propName: propMetadata} structure Returns ------- list List of Dash valid wildcard prefixes """ list_of_valid_wildcard_attr_prefixes = [] for wildcard_attr in ["data-*", "aria-*"]: if wildcard_attr in props: list_of_valid_wildcard_attr_prefixes.append(wildcard_attr[:-1]) return list_of_valid_wildcard_attr_prefixes
def reorder_props(props): """If "children" is in props, then move it to the front to respect dash convention. Parameters ---------- props: dict Dictionary with {propName: propMetadata} structure Returns ------- dict Dictionary with {propName: propMetadata} structure """ if 'children' in props: # Constructing an OrderedDict with duplicate keys, you get the order # from the first one but the value from the last. # Doing this to avoid mutating props, which can cause confusion. props = OrderedDict([('children', '')] + list(props.items()))
return props
def filter_props(props): """Filter props from the Component arguments to exclude: - Those without a "type" or a "flowType" field - Those with arg.type.name in {'func', 'symbol', 'instanceOf'} Parameters ---------- props: dict Dictionary with {propName: propMetadata} structure Returns ------- dict Filtered dictionary with {propName: propMetadata} structure Examples -------- ```python prop_args = { 'prop1': { 'type': {'name': 'bool'}, 'required': False, 'description': 'A description', 'flowType': {}, 'defaultValue': {'value': 'false', 'computed': False}, }, 'prop2': {'description': 'A prop without a type'}, 'prop3': { 'type': {'name': 'func'}, 'description': 'A function prop', }, } # filtered_prop_args is now # { # 'prop1': { # 'type': {'name': 'bool'}, # 'required': False, # 'description': 'A description', # 'flowType': {}, # 'defaultValue': {'value': 'false', 'computed': False}, # }, # } filtered_prop_args = filter_props(prop_args) ``` """ filtered_props = copy.deepcopy(props)
for arg_name, arg in list(filtered_props.items()): if 'type' not in arg and 'flowType' not in arg: filtered_props.pop(arg_name) continue
# Filter out functions and instances -- # these cannot be passed from Python if 'type' in arg: # These come from PropTypes arg_type = arg['type']['name'] if arg_type in {'func', 'symbol', 'instanceOf'}: filtered_props.pop(arg_name) elif 'flowType' in arg: # These come from Flow & handled differently arg_type_name = arg['flowType']['name'] if arg_type_name == 'signature': # This does the same as the PropTypes filter above, but "func" # is under "type" if "name" is "signature" vs just in "name" if 'type' not in arg['flowType'] \ or arg['flowType']['type'] != 'object': filtered_props.pop(arg_name) else: raise ValueError
return filtered_props
# pylint: disable=too-many-arguments def create_prop_docstring(prop_name, type_object, required, description, default, indent_num, is_flow_type=False): """Create the Dash component prop docstring. Parameters ---------- prop_name: str Name of the Dash component prop type_object: dict react-docgen-generated prop type dictionary required: bool Component is required? description: str Dash component description default: dict Either None if a default value is not defined, or dict containing the key 'value' that defines a default value for the prop indent_num: int Number of indents to use for the context block (creates 2 spaces for every indent) is_flow_type: bool Does the prop use Flow types? Otherwise, uses PropTypes Returns ------- str Dash component prop docstring """ py_type_name = js_to_py_type( type_object=type_object, is_flow_type=is_flow_type, indent_num=indent_num + 1) indent_spacing = ' ' * indent_num
if default is None: default = '' else: default = default['value']
if default in ['true', 'false']: default = default.title()
is_required = 'optional' if required: is_required = 'required' elif default and default not in ['null', '{}', '[]']: is_required = 'default {}'.format( default.replace('\n', '\n' + indent_spacing) )
if '\n' in py_type_name: return '{indent_spacing}- {name} (dict; {is_required}): ' \ '{description}{period}' \ '{name} has the following type: {type}'.format( indent_spacing=indent_spacing, name=prop_name, type=py_type_name, description=description.strip().strip('.'), period='. ' if description else '', is_required=is_required) return '{indent_spacing}- {name} ({type}' \ '{is_required}){description}'.format( indent_spacing=indent_spacing, name=prop_name, type='{}; '.format(py_type_name) if py_type_name else '', description=( ': {}'.format(description) if description != '' else '' ), is_required=is_required)
def map_js_to_py_types_prop_types(type_object): """Mapping from the PropTypes js type object to the Python type."""
def shape_or_exact(): return 'dict containing keys {}.\n{}'.format( ', '.join( "'{}'".format(t) for t in list(type_object['value'].keys()) ), 'Those keys have the following types:\n{}'.format( '\n'.join( create_prop_docstring( prop_name=prop_name, type_object=prop, required=prop['required'], description=prop.get('description', ''), default=prop.get('defaultValue'), indent_num=1 ) for prop_name, prop in list(type_object['value'].items()))) )
return dict( array=lambda: 'list', bool=lambda: 'boolean', number=lambda: 'number', string=lambda: 'string', object=lambda: 'dict', any=lambda: 'boolean | number | string | dict | list', element=lambda: 'dash component', node=lambda: 'a list of or a singular dash ' 'component, string or number',
# React's PropTypes.oneOf enum=lambda: 'a value equal to: {}'.format( ', '.join( '{}'.format(str(t['value'])) for t in type_object['value'])),
# React's PropTypes.oneOfType union=lambda: '{}'.format( ' | '.join( '{}'.format(js_to_py_type(subType)) for subType in type_object['value'] if js_to_py_type(subType) != '')),
# React's PropTypes.arrayOf arrayOf=lambda: ( "list" + (" of {}".format( js_to_py_type(type_object["value"]) + 's' if js_to_py_type(type_object["value"]).split(' ')[0] != 'dict' else js_to_py_type(type_object["value"]).replace( 'dict', 'dicts', 1 ) ) if js_to_py_type(type_object["value"]) != "" else "") ),
# React's PropTypes.objectOf objectOf=lambda: ( 'dict with strings as keys and values of type {}' ).format( js_to_py_type(type_object['value'])),
# React's PropTypes.shape shape=shape_or_exact, # React's PropTypes.exact exact=shape_or_exact )
def map_js_to_py_types_flow_types(type_object): """Mapping from the Flow js types to the Python type."""
return dict( array=lambda: 'list', boolean=lambda: 'boolean', number=lambda: 'number', string=lambda: 'string', Object=lambda: 'dict', any=lambda: 'bool | number | str | dict | list', Element=lambda: 'dash component', Node=lambda: 'a list of or a singular dash ' 'component, string or number',
# React's PropTypes.oneOfType union=lambda: '{}'.format( ' | '.join( '{}'.format(js_to_py_type(subType)) for subType in type_object['elements'] if js_to_py_type(subType) != '')),
# Flow's Array type Array=lambda: 'list{}'.format( ' of {}s'.format( js_to_py_type(type_object['elements'][0])) if js_to_py_type(type_object['elements'][0]) != '' else ''),
# React's PropTypes.shape signature=lambda indent_num: 'dict containing keys {}.\n{}'.format( ', '.join("'{}'".format(d['key']) for d in type_object['signature']['properties']), '{}Those keys have the following types:\n{}'.format( ' ' * indent_num, '\n'.join( create_prop_docstring( prop_name=prop['key'], type_object=prop['value'], required=prop['value']['required'], description=prop['value'].get('description', ''), default=prop.get('defaultValue'), indent_num=indent_num, is_flow_type=True) for prop in type_object['signature']['properties']))), )
def js_to_py_type(type_object, is_flow_type=False, indent_num=0): """Convert JS types to Python types for the component definition. Parameters ---------- type_object: dict react-docgen-generated prop type dictionary is_flow_type: bool Does the prop use Flow types? Otherwise, uses PropTypes indent_num: int Number of indents to use for the docstring for the prop how to join the community if you do not tell us how to do it?
|
|
|
This is why you don't entertain random messages on social media That "overtake bitcoin" or some would say "bitcoin killer" is a dead marketing slogan. Those new projects who claims that they can do that will most likely die in the next two years or so. Other than what's already mentioned as the pioneer in mobile mining, there's also this bitwings who claims to mine eth using mobile phone. The marketing slogan is not dead yet because it can be used against the newbie, many projects allowed their community to mine their coin through the mobile phone. electroneum is one of them, compared to minepi. electroneum is profitable because has a real value unlike minepi. bitwings is a different story, it is a project that allows you to mine using their mobile phone. it is not a digital currency.
|
|
|
No, I don't think it's a myth.
There are hundreds of decentralized applications around. Besides, some projects offer decentralized internet, decentralized storage, and much more.
Also, privacy coins allow users to exchange completely confidential (literally) money.
I've used almost all of them, and my opinion is that everything is going well by now.
It is. They are claiming to be decentralized storage but they keep the data on their server which is centralized, there are so many projects claimed to be a decentralized project but none of them is a true decentralized project. a true decentralization works in the theory but not applicable in reality because the government will take a measure to get involved in it. they will not allow such a thing called pure decentralization because it might affect them.
|
|
|
Because all of them were using the deflationary function to increase the hype not the utility of the token. even the survived projects are not doing fine either because the real use case of this deflationary is only creating a hype because of burn.
|
|
|
Presently crypto is not booming, altcoins are suffering as well and every thing you see or read online about crypto future is still predictions, still we got to be prepared for any outcomes, the features of coins that will be around for long and probably see huge adoptions are - Privacy coins - Dapps projects My advice is to always make sure that coins you will hold for long term will worth it, make sure they have real use case
I do not think privacy coin will boom in 2020 considering the government takes about this kind of project and always associated with money laundering or criminal activity, plus there is a requirement for every exchange to comply with their AMLD 5. what is the point of using it? Dapps and DEX project seem like have a brighter future compared to the others, especially the platform that offers it such as ethereum.
|
|
|
My friend, you should look at the (real) volume before you consider its market capitalization to be legit. For example, I could create an ERC-20 token, let's call it (SHIT) with the total supply of 1,000,000 SHIT and listed it on small exchanges. Then I bought 100 SHIT using $100. Is that mean that the SHIT market cap is now $1,000,000 ? Obviously not if it's not liquid (low "real" volume).
This is a good point that you just raised, there was a day I saw a project from nowhere in top 100 on CMC and has just $30K TRADING Volume, this just shows there is a pump and dump on going. To me, in this space liquidity is more important than market cap Even though many projects did that(not only erc20 based token, literally everything just like that), we can not deny the fact that ERC20 token is the most well-known compared to its competitors right? that is true liquidity is important, but if we summarize all of it. erc20 has more than its competitors. and this news could be related to the fact that ethereum is going to make an update on its system. causing people to start to believe in it again because they say it is going to be scalable.
|
|
|
If you want to provide a completely anonymous system why do not you use cryptonight protocol? there was a project wanted to create the same thing as yours(but they decided to stop it because they were busy with their real life and other stuff), cryptonight is a privacy-oriented protocol. https://bitcointalk.org/index.php?topic=4872144.0 is the project that I mentioned above.
|
|
|
If you are looking for 2x profit in a year, why do not you go for Bitcoin instead? halving will happen next year, and the price should be increased to maintain the miners. right now Bitcoin is at $8,000 and it is possible for it to reach $20,000 again after the halving.
Why can you be sure Bitcoin will increase in the future? I do not think this can be repeated in the near future because the current market is still unstable and there are still a lot of big fluctuations going on here. In my opinion you should only expect Bitcoin in the range of $10,000 to $12,000 next year because this is the price that can occur and you can consider investing at $8000 if all goes well. If Bitcoin does not increase its value what can altcoin do? do you think altcoin can go 2x when Bitcoin remains stagnant? I am being realistic, why choose an altcoin if you can invest your money on Bitcoin and has a possibility to go 2x or reach its ATH again.
|
|
|
Atomic swaps are a necessity within the cryptocurrency space. I took a look at the ETH-TRON swap page and I must say I like the way it looks: neat and easy to use. Since it's just blockchains interacting, will Jelly charge for facilitating transactions or how does it intend to be profitable?
They do not charge the fee but they are gaining profit from the spread. you can read their whitepaper to know more about the ecosystem. I think the team needs to update their website by adding a live update of the price. for example like this ETH/TRX 10037.249572(it is automatically changing whenever the spread changes).
|
|
|
If you are looking for 2x profit in a year, why do not you go for Bitcoin instead? halving will happen next year, and the price should be increased to maintain the miners. right now Bitcoin is at $8,000 and it is possible for it to reach $20,000 again after the halving.
|
|
|
I think he has misinterpreted a local wallet as an offline wallet. I recommend you to use Exodus wallet, it has a nice design and supported many cryptocurrencies. https://www.exodus.io/
|
|
|
I just looked up on OPs reference about QTUM coin and it seems a disaster to me. I would not admonish anybody to buy into this imminent pump and dump scheme that is going to take place on Binance. In such situations, the whales of this project have filled their bags to the brim and ready to dump unto new investors when they get listed. I would stay away from investing into such projects.
How is it a disaster if everything looks exactly the same as this? qtum is a good project, the team is actively developing and communicating with their community. just do not look at how bad the price is compared to when it was in 2017 but look everything around it. many good things happened with this project, its total volume has increased by 40% from the last month.
|
|
|
The idea of IMO ECOSYSTEM platform will definitely replace the Initial exchange offering(IEO) the imo system is design in a way that project on presale is already trading higher on the exchange which is profitable than buying an IEO which would end up non profitable. The unlock through referring is also attractive and profitable.
How can you so sure that IMO will definitely replace the IEO idea? Do you think all the IMO plan will succeed? No way! There will be drawback projects too, rather investing in reputed exchange's IEO mean profit confirm. I will stick on IEO, let's see how IMO replace it! I have checked their website and from the looks of it, I think it has a potential to replace IEO because the idea of IMO is to help the project to get a proper amount of fundraising, from their website you can see the majority of projects have 365 phases of sale. unlike IEO that is only once for all, IMO gives the project a chance to gather the funds from multiple sales. and the investors can not sell or withdraw their token until the end of the sale.
|
|
|
I am still holding the coins that I got from the airdrop until now, to be honest I am really tempted to increase my position but the market and lack of activity from the developer make me hesitate. I will just wait for it until the market or altcoin makes move if Bitsend survives until then. I might start buying it again in the future, but now it does not look good at all.
|
|
|
Things like this that make me less like airdrop program, because they just cool to make a promise to pay, even though not pay at all, even though not all airdrops are like this, but because one or two airdrops like this will damage the reputation of the airdrop the others too.
What are you talking about? Keybase airdrop is paying, many people have gotten their airdrop since two days ago if I remember it correctly. Nothing is fake in here, you can check it out on their distribution address https://stellar.expert/explorer/public/account/GDV4KECLSZLKRVH4ZTWVAS4I3W2LPAPV66ADFFUZKGIVOTK6GMKGJT53
|
|
|
I am leaning more towards chinese/korean projects because with mass adoption in China, prices will definitely rally. All your picks are good holds but I am looking more at undervalued cryptos that could potentially outperform leading cryptos like the ones you mentioned.
I am with you, especially korean project. I have participated in 3 korean projects before and all of them were ended successfully. if you do not want to invest in top cryptocurrencies, low liquidity korean projects are the best option for you to invest your money because they will not disappoint you.
|
|
|
|