Topic: Incorrect Bitcore(BTX) Circulating Supply on CMC (Read 4170 times)
Thank you @ CMC that this finally is corrected. :thumbsup
They corrected the Supply this Night!
https://twitter.com/bitcore_btx/status/952687927007510528?ref_src=twcamp%5Eshare%7Ctwsrc%5Eios%7Ctwgr%5Eph.telegra.Telegraph.Share
https://twitter.com/bitcore_btx/status/952687927007510528?ref_src=twcamp%5Eshare%7Ctwsrc%5Eios%7Ctwgr%5Eph.telegra.Telegraph.Share
I think they have no idea about UTXO (unsent transaction outputs) imports. How they work and why to add them to circulating supply. The only compareable coin who did the same distibution is CLAMS (as far as i know) and if you look, the same issue with the circ. supply there.
I found something written by Jimmy Song the Editor of Bitcoin Tech Talk: https://medium.com/@jimmysong/bitcoin-diamond-super-bitcoin-bitcore-what-you-need-to-know-f49c35688a39
The compare of hardfork and airdrop towards UTXO import shows me that this amount really should be added to circulating supply.
https://en.wikipedia.org/wiki/List_of_Bitcoin_forks
I found something written by Jimmy Song the Editor of Bitcoin Tech Talk: https://medium.com/@jimmysong/bitcoin-diamond-super-bitcoin-bitcore-what-you-need-to-know-f49c35688a39
Quote
Bitcore is something that’s between a hard fork and an airdrop. BitCore (BTX) basically took the UTXO set from Bitcoin, compressed the outputs for each address and distributed on their chain. In layman’s terms, they cleaned up the ledger (blockchain) so that it’s a lot smaller.
This is the most clever of the hard forks in that it doesn’t require the Bitcoin blockchain like other hard forks do (120GB+!) and at least innovates by cleaning things up a little. Unfortunately, distribution on this coin is a bit stingier as you only get 0.5 BTX per 1 Bitcoin you had as of block 492820. They have a continuing airdrop going on, so there’s also that aspect which helps the coin.
This is the most clever of the hard forks in that it doesn’t require the Bitcoin blockchain like other hard forks do (120GB+!) and at least innovates by cleaning things up a little. Unfortunately, distribution on this coin is a bit stingier as you only get 0.5 BTX per 1 Bitcoin you had as of block 492820. They have a continuing airdrop going on, so there’s also that aspect which helps the coin.
The compare of hardfork and airdrop towards UTXO import shows me that this amount really should be added to circulating supply.
https://en.wikipedia.org/wiki/List_of_Bitcoin_forks
Maybe they are too busy, or maybe it's just one guys running it you don't really know
Any news about this problem? Why CMC doesn't answer at our request? I am sue that if and when Circulating supply will be correct, BTX will increase its value.
Not sure if this thread is still active/relevant, but in any case, I thought I would throw this here instead of the regular ANN.
Someone in a trader chatroom made me realize CMC might not show the accurate circulation for many coins because of they use the public float accounting method to calculate the market cap.
Indeed, on their site, they have the below explanation:
"Why is the Circulating Supply used in determining the market capitalization instead of Total Supply?
We've found that Circulating Supply is a much better metric for determining the market capitalization. Coins that are locked, reserved, or not able to be sold on the public market are coins that can't affect the price and thus should not be allowed to affect the market capitalization as well. The method of using the Circulating Supply is analogous to the method of using public float for determining the market capitalization of companies in traditional investing."
My guess is that they see the virtual fork free coins that were not redeemed as locked, and therefore can't affect the market price. I think it's a battle of interpretation between the dev team and CMC. Dev team probably just need to clarify this with CMC.
Someone in a trader chatroom made me realize CMC might not show the accurate circulation for many coins because of they use the public float accounting method to calculate the market cap.
Indeed, on their site, they have the below explanation:
"Why is the Circulating Supply used in determining the market capitalization instead of Total Supply?
We've found that Circulating Supply is a much better metric for determining the market capitalization. Coins that are locked, reserved, or not able to be sold on the public market are coins that can't affect the price and thus should not be allowed to affect the market capitalization as well. The method of using the Circulating Supply is analogous to the method of using public float for determining the market capitalization of companies in traditional investing."
My guess is that they see the virtual fork free coins that were not redeemed as locked, and therefore can't affect the market price. I think it's a battle of interpretation between the dev team and CMC. Dev team probably just need to clarify this with CMC.
Why https://chainz.cryptoid.info/btx/ can show the marketcap 307.96 million and you can't show the correct one ? how they can and you don\t ?
Yeah that should be about right 
Why https://chainz.cryptoid.info/btx/ can show the marketcap 307.96 million and you can't show the correct one ? how they can and you don\t ?
CMC lists an incorrect marketcap for quite a few coins.
Anyway.. to clear a few misconceptions, circulating supply means coins that have recently been sent or addresses known to be active (CMC gives no indication of the time cut-off however). A fairly stupid measuring metric to be honest.
Total marketcap are coins generated 'to date' or in existence at any given point.
If coins were sent to an address; and the owner lost the private key - this does not affect the marketcap total, as said coins still exist and are valid on the blockchain.
The Bitcoin holders 'forked' coins don't matter, if they were reimbursed with BTX due to the snapshot - the BTX they were sent already existed beforehand.
To find the to the minute (and correct) coinmarketcap:
Ensure your baking tray is lightly greased, along with a txindex'd copy of bitcored, mix with python 2.7 and gently stir python-bitcoinrpc library in (pip install python-bitcoinrpc). Don't forget to add your rpcuser/pass otherwise rpc comms will fail.
We can see as of block 95,338; a total of 16,678,946.0337BTX are in existence.
Anyway.. to clear a few misconceptions, circulating supply means coins that have recently been sent or addresses known to be active (CMC gives no indication of the time cut-off however). A fairly stupid measuring metric to be honest.
Total marketcap are coins generated 'to date' or in existence at any given point.
If coins were sent to an address; and the owner lost the private key - this does not affect the marketcap total, as said coins still exist and are valid on the blockchain.
The Bitcoin holders 'forked' coins don't matter, if they were reimbursed with BTX due to the snapshot - the BTX they were sent already existed beforehand.
To find the to the minute (and correct) coinmarketcap:
Ensure your baking tray is lightly greased, along with a txindex'd copy of bitcored, mix with python 2.7 and gently stir python-bitcoinrpc library in (pip install python-bitcoinrpc). Don't forget to add your rpcuser/pass otherwise rpc comms will fail.
Code:
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import time, os, sys
def find_between( s, first, last ):
try:
start = s.index( first ) + len( first )
end = s.index( last, start )
return s[start:end]
except ValueError:
return ""
def find_between_r( s, first, last ):
try:
start = s.rindex( first ) + len( first )
end = s.rindex( last, start )
return s[start:end]
except ValueError:
return ""
# user-config section
rpchost = '127.0.0.1'
rpcuser = ''
rpcpass = ''
rpcport = '8556'
rpcpipe = AuthServiceProxy('http://' + rpcuser + ':' + rpcpass + '@' + rpchost + ':' + rpcport)
currentblk = 0
totalcoincap = 0
while True:
currentblk=currentblk+1
#get total blocks
while True:
blocktotal = int(rpcpipe.getblockcount())
if currentblk == blocktotal:
print 'hit end of chain, waiting'
time.sleep(15)
else:
break
#request each block
blockhash = rpcpipe.getblockhash(currentblk)
blockdata = rpcpipe.getblock(blockhash)
blocktx = find_between(str(blockdata),'[',']').replace('u','').replace(' ','').replace('\'','')
blocktxlist = blocktx.split(',')
#parse all tx in block
for tx in blocktxlist:
rawtx = rpcpipe.getrawtransaction(tx)
# generated pow/pos coins have no prevout
if '0000000000000000000000000000000000000000000000000000000000000000' in rawtx:
break
#decode the 'generated/mined' tx data, extract the value
coinbasetx = rpcpipe.decoderawtransaction(rawtx)
valuemined = find_between(str(coinbasetx), 'Decimal(\'', '\'),')
#special case for nonstandard pool where coinbaseout isn't first vout
while float(valuemined)==0:
try:
valuemined = find_between_r(str(coinbasetx), 'Decimal(\'', '\'),')
except:
valuemined = 0
print '* could not find vout for block '+str(currentblk)+'!'
break
totalcoincap = totalcoincap + float(valuemined)
currentblk_fmt = str(currentblk)
while len(str(currentblk_fmt)) < 6:
currentblk_fmt=' '+currentblk_fmt
print 'block '+str(currentblk_fmt)+'|'+blockhash+'|mined '+str(round(float(valuemined),8))+'|coincap '+str(round(float(totalcoincap),8))
import time, os, sys
def find_between( s, first, last ):
try:
start = s.index( first ) + len( first )
end = s.index( last, start )
return s[start:end]
except ValueError:
return ""
def find_between_r( s, first, last ):
try:
start = s.rindex( first ) + len( first )
end = s.rindex( last, start )
return s[start:end]
except ValueError:
return ""
# user-config section
rpchost = '127.0.0.1'
rpcuser = ''
rpcpass = ''
rpcport = '8556'
rpcpipe = AuthServiceProxy('http://' + rpcuser + ':' + rpcpass + '@' + rpchost + ':' + rpcport)
currentblk = 0
totalcoincap = 0
while True:
currentblk=currentblk+1
#get total blocks
while True:
blocktotal = int(rpcpipe.getblockcount())
if currentblk == blocktotal:
print 'hit end of chain, waiting'
time.sleep(15)
else:
break
#request each block
blockhash = rpcpipe.getblockhash(currentblk)
blockdata = rpcpipe.getblock(blockhash)
blocktx = find_between(str(blockdata),'[',']').replace('u','').replace(' ','').replace('\'','')
blocktxlist = blocktx.split(',')
#parse all tx in block
for tx in blocktxlist:
rawtx = rpcpipe.getrawtransaction(tx)
# generated pow/pos coins have no prevout
if '0000000000000000000000000000000000000000000000000000000000000000' in rawtx:
break
#decode the 'generated/mined' tx data, extract the value
coinbasetx = rpcpipe.decoderawtransaction(rawtx)
valuemined = find_between(str(coinbasetx), 'Decimal(\'', '\'),')
#special case for nonstandard pool where coinbaseout isn't first vout
while float(valuemined)==0:
try:
valuemined = find_between_r(str(coinbasetx), 'Decimal(\'', '\'),')
except:
valuemined = 0
print '* could not find vout for block '+str(currentblk)+'!'
break
totalcoincap = totalcoincap + float(valuemined)
currentblk_fmt = str(currentblk)
while len(str(currentblk_fmt)) < 6:
currentblk_fmt=' '+currentblk_fmt
print 'block '+str(currentblk_fmt)+'|'+blockhash+'|mined '+str(round(float(valuemined),8))+'|coincap '+str(round(float(totalcoincap),8))
We can see as of block 95,338; a total of 16,678,946.0337BTX are in existence.
Nice one.
So the airdrop wallet is also a wallet that holds BTX and this should be counted as well right? So actually 16 million coins in circulation
Nobody really wants or needs the airdrop wallet to be counted, it is in existance of course but ideally we wouldn't count the airdrop wallet as being in circulation yet.
So the airdrop wallet is also a wallet that holds BTX and this should be counted as well right? So actually 16 million coins in circulation
CMC lists an incorrect marketcap for quite a few coins.
Anyway.. to clear a few misconceptions, circulating supply means coins that have recently been sent or addresses known to be active (CMC gives no indication of the time cut-off however). A fairly stupid measuring metric to be honest.
Total marketcap are coins generated 'to date' or in existence at any given point.
If coins were sent to an address; and the owner lost the private key - this does not affect the marketcap total, as said coins still exist and are valid on the blockchain.
The Bitcoin holders 'forked' coins don't matter, if they were reimbursed with BTX due to the snapshot - the BTX they were sent already existed beforehand.
To find the to the minute (and correct) coinmarketcap:
Ensure your baking tray is lightly greased, along with a txindex'd copy of bitcored, mix with python 2.7 and gently stir python-bitcoinrpc library in (pip install python-bitcoinrpc). Don't forget to add your rpcuser/pass otherwise rpc comms will fail.
We can see as of block 95,338; a total of 16,678,946.0337BTX are in existence.
Anyway.. to clear a few misconceptions, circulating supply means coins that have recently been sent or addresses known to be active (CMC gives no indication of the time cut-off however). A fairly stupid measuring metric to be honest.
Total marketcap are coins generated 'to date' or in existence at any given point.
If coins were sent to an address; and the owner lost the private key - this does not affect the marketcap total, as said coins still exist and are valid on the blockchain.
The Bitcoin holders 'forked' coins don't matter, if they were reimbursed with BTX due to the snapshot - the BTX they were sent already existed beforehand.
To find the to the minute (and correct) coinmarketcap:
Ensure your baking tray is lightly greased, along with a txindex'd copy of bitcored, mix with python 2.7 and gently stir python-bitcoinrpc library in (pip install python-bitcoinrpc). Don't forget to add your rpcuser/pass otherwise rpc comms will fail.
Code:
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import time, os, sys
def find_between( s, first, last ):
try:
start = s.index( first ) + len( first )
end = s.index( last, start )
return s[start:end]
except ValueError:
return ""
def find_between_r( s, first, last ):
try:
start = s.rindex( first ) + len( first )
end = s.rindex( last, start )
return s[start:end]
except ValueError:
return ""
# user-config section
rpchost = '127.0.0.1'
rpcuser = ''
rpcpass = ''
rpcport = '8556'
rpcpipe = AuthServiceProxy('http://' + rpcuser + ':' + rpcpass + '@' + rpchost + ':' + rpcport)
currentblk = 0
totalcoincap = 0
while True:
currentblk=currentblk+1
#get total blocks
while True:
blocktotal = int(rpcpipe.getblockcount())
if currentblk == blocktotal:
print 'hit end of chain, waiting'
time.sleep(15)
else:
break
#request each block
blockhash = rpcpipe.getblockhash(currentblk)
blockdata = rpcpipe.getblock(blockhash)
blocktx = find_between(str(blockdata),'[',']').replace('u','').replace(' ','').replace('\'','')
blocktxlist = blocktx.split(',')
#parse all tx in block
for tx in blocktxlist:
rawtx = rpcpipe.getrawtransaction(tx)
# generated pow/pos coins have no prevout
if '0000000000000000000000000000000000000000000000000000000000000000' in rawtx:
break
#decode the 'generated/mined' tx data, extract the value
coinbasetx = rpcpipe.decoderawtransaction(rawtx)
valuemined = find_between(str(coinbasetx), 'Decimal(\'', '\'),')
#special case for nonstandard pool where coinbaseout isn't first vout
while float(valuemined)==0:
try:
valuemined = find_between_r(str(coinbasetx), 'Decimal(\'', '\'),')
except:
valuemined = 0
print '* could not find vout for block '+str(currentblk)+'!'
break
totalcoincap = totalcoincap + float(valuemined)
currentblk_fmt = str(currentblk)
while len(str(currentblk_fmt)) < 6:
currentblk_fmt=' '+currentblk_fmt
print 'block '+str(currentblk_fmt)+'|'+blockhash+'|mined '+str(round(float(valuemined),8))+'|coincap '+str(round(float(totalcoincap),8))
import time, os, sys
def find_between( s, first, last ):
try:
start = s.index( first ) + len( first )
end = s.index( last, start )
return s[start:end]
except ValueError:
return ""
def find_between_r( s, first, last ):
try:
start = s.rindex( first ) + len( first )
end = s.rindex( last, start )
return s[start:end]
except ValueError:
return ""
# user-config section
rpchost = '127.0.0.1'
rpcuser = ''
rpcpass = ''
rpcport = '8556'
rpcpipe = AuthServiceProxy('http://' + rpcuser + ':' + rpcpass + '@' + rpchost + ':' + rpcport)
currentblk = 0
totalcoincap = 0
while True:
currentblk=currentblk+1
#get total blocks
while True:
blocktotal = int(rpcpipe.getblockcount())
if currentblk == blocktotal:
print 'hit end of chain, waiting'
time.sleep(15)
else:
break
#request each block
blockhash = rpcpipe.getblockhash(currentblk)
blockdata = rpcpipe.getblock(blockhash)
blocktx = find_between(str(blockdata),'[',']').replace('u','').replace(' ','').replace('\'','')
blocktxlist = blocktx.split(',')
#parse all tx in block
for tx in blocktxlist:
rawtx = rpcpipe.getrawtransaction(tx)
# generated pow/pos coins have no prevout
if '0000000000000000000000000000000000000000000000000000000000000000' in rawtx:
break
#decode the 'generated/mined' tx data, extract the value
coinbasetx = rpcpipe.decoderawtransaction(rawtx)
valuemined = find_between(str(coinbasetx), 'Decimal(\'', '\'),')
#special case for nonstandard pool where coinbaseout isn't first vout
while float(valuemined)==0:
try:
valuemined = find_between_r(str(coinbasetx), 'Decimal(\'', '\'),')
except:
valuemined = 0
print '* could not find vout for block '+str(currentblk)+'!'
break
totalcoincap = totalcoincap + float(valuemined)
currentblk_fmt = str(currentblk)
while len(str(currentblk_fmt)) < 6:
currentblk_fmt=' '+currentblk_fmt
print 'block '+str(currentblk_fmt)+'|'+blockhash+'|mined '+str(round(float(valuemined),8))+'|coincap '+str(round(float(totalcoincap),8))
We can see as of block 95,338; a total of 16,678,946.0337BTX are in existence.
aaand THIS is why learning is a must.
#crysx
CMC lists an incorrect marketcap for quite a few coins.
Anyway.. to clear a few misconceptions, circulating supply means coins that have recently been sent or addresses known to be active (CMC gives no indication of the time cut-off however). A fairly stupid measuring metric to be honest.
Total marketcap are coins generated 'to date' or in existence at any given point.
If coins were sent to an address; and the owner lost the private key - this does not affect the marketcap total, as said coins still exist and are valid on the blockchain.
The Bitcoin holders 'forked' coins don't matter, if they were reimbursed with BTX due to the snapshot - the BTX they were sent already existed beforehand.
To find the to the minute (and correct) coinmarketcap:
Ensure your baking tray is lightly greased, along with a txindex'd copy of bitcored, mix with python 2.7 and gently stir python-bitcoinrpc library in (pip install python-bitcoinrpc). Don't forget to add your rpcuser/pass otherwise rpc comms will fail.
We can see as of block 95,338; a total of 16,678,946.0337BTX are in existence.
Anyway.. to clear a few misconceptions, circulating supply means coins that have recently been sent or addresses known to be active (CMC gives no indication of the time cut-off however). A fairly stupid measuring metric to be honest.
Total marketcap are coins generated 'to date' or in existence at any given point.
If coins were sent to an address; and the owner lost the private key - this does not affect the marketcap total, as said coins still exist and are valid on the blockchain.
The Bitcoin holders 'forked' coins don't matter, if they were reimbursed with BTX due to the snapshot - the BTX they were sent already existed beforehand.
To find the to the minute (and correct) coinmarketcap:
Ensure your baking tray is lightly greased, along with a txindex'd copy of bitcored, mix with python 2.7 and gently stir python-bitcoinrpc library in (pip install python-bitcoinrpc). Don't forget to add your rpcuser/pass otherwise rpc comms will fail.
Code:
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import time, os, sys
def find_between( s, first, last ):
try:
start = s.index( first ) + len( first )
end = s.index( last, start )
return s[start:end]
except ValueError:
return ""
def find_between_r( s, first, last ):
try:
start = s.rindex( first ) + len( first )
end = s.rindex( last, start )
return s[start:end]
except ValueError:
return ""
# user-config section
rpchost = '127.0.0.1'
rpcuser = ''
rpcpass = ''
rpcport = '8556'
rpcpipe = AuthServiceProxy('http://' + rpcuser + ':' + rpcpass + '@' + rpchost + ':' + rpcport)
currentblk = 0
totalcoincap = 0
while True:
currentblk=currentblk+1
#get total blocks
while True:
blocktotal = int(rpcpipe.getblockcount())
if currentblk == blocktotal:
print 'hit end of chain, waiting'
time.sleep(15)
else:
break
#request each block
blockhash = rpcpipe.getblockhash(currentblk)
blockdata = rpcpipe.getblock(blockhash)
blocktx = find_between(str(blockdata),'[',']').replace('u','').replace(' ','').replace('\'','')
blocktxlist = blocktx.split(',')
#parse all tx in block
for tx in blocktxlist:
rawtx = rpcpipe.getrawtransaction(tx)
# generated pow/pos coins have no prevout
if '0000000000000000000000000000000000000000000000000000000000000000' in rawtx:
break
#decode the 'generated/mined' tx data, extract the value
coinbasetx = rpcpipe.decoderawtransaction(rawtx)
valuemined = find_between(str(coinbasetx), 'Decimal(\'', '\'),')
#special case for nonstandard pool where coinbaseout isn't first vout
while float(valuemined)==0:
try:
valuemined = find_between_r(str(coinbasetx), 'Decimal(\'', '\'),')
except:
valuemined = 0
print '* could not find vout for block '+str(currentblk)+'!'
break
totalcoincap = totalcoincap + float(valuemined)
currentblk_fmt = str(currentblk)
while len(str(currentblk_fmt)) < 6:
currentblk_fmt=' '+currentblk_fmt
print 'block '+str(currentblk_fmt)+'|'+blockhash+'|mined '+str(round(float(valuemined),8))+'|coincap '+str(round(float(totalcoincap),8))
import time, os, sys
def find_between( s, first, last ):
try:
start = s.index( first ) + len( first )
end = s.index( last, start )
return s[start:end]
except ValueError:
return ""
def find_between_r( s, first, last ):
try:
start = s.rindex( first ) + len( first )
end = s.rindex( last, start )
return s[start:end]
except ValueError:
return ""
# user-config section
rpchost = '127.0.0.1'
rpcuser = ''
rpcpass = ''
rpcport = '8556'
rpcpipe = AuthServiceProxy('http://' + rpcuser + ':' + rpcpass + '@' + rpchost + ':' + rpcport)
currentblk = 0
totalcoincap = 0
while True:
currentblk=currentblk+1
#get total blocks
while True:
blocktotal = int(rpcpipe.getblockcount())
if currentblk == blocktotal:
print 'hit end of chain, waiting'
time.sleep(15)
else:
break
#request each block
blockhash = rpcpipe.getblockhash(currentblk)
blockdata = rpcpipe.getblock(blockhash)
blocktx = find_between(str(blockdata),'[',']').replace('u','').replace(' ','').replace('\'','')
blocktxlist = blocktx.split(',')
#parse all tx in block
for tx in blocktxlist:
rawtx = rpcpipe.getrawtransaction(tx)
# generated pow/pos coins have no prevout
if '0000000000000000000000000000000000000000000000000000000000000000' in rawtx:
break
#decode the 'generated/mined' tx data, extract the value
coinbasetx = rpcpipe.decoderawtransaction(rawtx)
valuemined = find_between(str(coinbasetx), 'Decimal(\'', '\'),')
#special case for nonstandard pool where coinbaseout isn't first vout
while float(valuemined)==0:
try:
valuemined = find_between_r(str(coinbasetx), 'Decimal(\'', '\'),')
except:
valuemined = 0
print '* could not find vout for block '+str(currentblk)+'!'
break
totalcoincap = totalcoincap + float(valuemined)
currentblk_fmt = str(currentblk)
while len(str(currentblk_fmt)) < 6:
currentblk_fmt=' '+currentblk_fmt
print 'block '+str(currentblk_fmt)+'|'+blockhash+'|mined '+str(round(float(valuemined),8))+'|coincap '+str(round(float(totalcoincap),8))
We can see as of block 95,338; a total of 16,678,946.0337BTX are in existence.
Do you know how many projects have incorrect circulating supply on CMC?
cant even count... =/
cant even count... =/
I agree and this is a huge integrity issue on the part of CMC. Although there are many, we are probably the largest project that is currently not being displayed properly. We have provided them documentation multiple times and they refuse to do the right thing. It is pretty frustrating but hey worldcoinindex and cryptocompare have our full supply as circulating right now so I guess that is a breath of fresh air.
Do you know how many projects have incorrect circulating supply on CMC?
cant even count... =/
cant even count... =/
Option 1, of course. 
How do they could calculate circulation supply?
I assume that they use the api call for total supply (https://chainz.cryptoid.info/btx/api.dws?q=totalcoins)
and then:
totalcoins
- dev funds (
- airdrop account (https://chainz.cryptoid.info/btx/api.dws?q=getbalance&a=13hwgY4YUvrgnhjLP5ugFafL1cmbRRtr5e)
=circulating supply
I cant understand what's the problem @ coinmarketcap.com.
I will use and recommend cryptocompare.com.
I assume that they use the api call for total supply (https://chainz.cryptoid.info/btx/api.dws?q=totalcoins)
and then:
totalcoins
- dev funds (
- airdrop account (https://chainz.cryptoid.info/btx/api.dws?q=getbalance&a=13hwgY4YUvrgnhjLP5ugFafL1cmbRRtr5e)
=circulating supply
I cant understand what's the problem @ coinmarketcap.com.
I will use and recommend cryptocompare.com.
There is only 1 answer, option 1, else CMC will have to redo a lot of coins including bch/btg ...with this logic you would even have to change bitcoin's supply.
I didn't think corruption was part of cmc's vocabulaire but unfortunately it seems it is.
The owner of cmc might even get into legal trouble later on for heavily influencing million/billion dollar markets.
I didn't think corruption was part of cmc's vocabulaire but unfortunately it seems it is.
The owner of cmc might even get into legal trouble later on for heavily influencing million/billion dollar markets.
I fully agree with you on that one!
There is only 1 answer, option 1, else CMC will have to redo a lot of coins including bch/btg ...with this logic you would even have to change bitcoin's supply.
I didn't think corruption was part of cmc's vocabulaire but unfortunately it seems it is.
The owner of cmc might even get into legal trouble later on for heavily influencing million/billion dollar markets.
I didn't think corruption was part of cmc's vocabulaire but unfortunately it seems it is.
The owner of cmc might even get into legal trouble later on for heavily influencing million/billion dollar markets.
this poll is nonsense.
There is no other option than 1, as CMC do so with BTC, BCH, BTG and so on... why is BTX different?
my "virtually forked" coins are already circulating (in my wallet)
The coins are under user control, tied to their privkeys. They are not devs coins anymore. That define "circulating coins", right?
Is CMC waiting for every user to say.. "hey. my virtually forked coins are circulating? why are you not counting them?"
There is no other option than 1, as CMC do so with BTC, BCH, BTG and so on... why is BTX different?
my "virtually forked" coins are already circulating (in my wallet)
The coins are under user control, tied to their privkeys. They are not devs coins anymore. That define "circulating coins", right?
Is CMC waiting for every user to say.. "hey. my virtually forked coins are circulating? why are you not counting them?"
option 1. yes
Jump to: