NXT :: descendant of Bitcoin - Updated Information

[landomata]

when you finally going to stop wasting time, money and resources on all them useless side projects of yours.

STOP BURNING COMMUNITY NXT on useless marketing and side project with 0 result

stick to BCNext his plan.

 

[allwelder]

any detailed info of test on WIN?

What is WIN?

Sorry for my mistake,I mean how to test nodecoin on windows system?

You need compile yourself, I guess

got it ,thanks.

[abctc]

...  If it doesn't recover by itself, you will need to delete the nxt_db folder and redownload the blockchain.

What is wrong with the consensus mechanism?

- yes, it would be nice to hear the answer. How can it happens, that node "doesn't recover by itself" ?  If so, that it is definitely something wrong with the consensus mechanism ...

Only 720 block depth for autorecovery is allowed.

- does it mean, then if your node fell into fork, it will automatically recover to the correct chain in 720 blocks time?

No.

- so, it is definitely something wrong with the consensus mechanism now ...  because you need to manually recover your nodes from the fork.

[JKBtCn]

Hey guys, how much NXT do I actually need to forge some blocks?

I currently have 10, yes ten, no not 10K, and it says that I can generate a block in 22429 days... Is this for real?  

Thanks!

Even with 100k nxt you will not make any money forging so get that mentality out of your head from the start and welcome to the beginning of the rest of your life.

I've been trying to learn more about forging (transparent forging) and you raise the exact issue I am looking to resolve as a recent investor. You make it sound like 100,000 NXT is not enough to forge.

I am a miner at heart and like the idea of forging but the more I read about NXT, it seems that only the original stakeholders (or those with a huge number of NXT) are the ones who can successfully forge (gain/accumulate NXT)? How many NXT are needed to forge and what returns could one expect from say 500,000 NXT? Does the chance to forge change over time, i.e. what variables other than my account holdings and online status as a node affect forging success?

This issue has been difficult to get my head around as a recent adopter. I have not forged any NXT since opening my account (20,000 NXT) a few weeks ago and it sounds like from your response that this number is a laughing matter...I will never forge with that amount. Could some one provide some insight or a link to where forging and returns are discussed?

[Mises_77]

[TEST RELEASE OF NODECOIN MINER]

I did a quick proof of concept NXTcoin today. The coin is actually a NXT AE Asset called "nodecoin", there are 1 billion nodecoins. I made a nodeminer that has been tested on Mac and Linux, no guarantees on Windows. It is is pretty portable C in a self-contained file, so there is a decent chance it will compile under Windows. Let me know if you get it ported to Windows.

OK, so nodecoin was a great idea from Mises_77 yesterday. It inspired me to do some programming and I took a lot of shortcuts. No complaining about lack of features, it is less than 12 hours old!

How does it work? You simply run nodeminer from the command line with your NXT acct id. It does not needs your passkey. For now it is hardcoded to testnet and has a very fast cycle time of 10 seconds. Every 10 seconds that you are forging, 1 nodecoin is "created". However, I was lazy and didnt bother to keep track of who forged which coins, and I certainly didnt database the incoming info. I just add up everyone's total into unclaimed nodecoins. If you are forging, you will be able to see the total unclaimed nodecoins.

Now comes the fun part. ANYBODY can claim all the unclaimed nodecoins by sending in 1 NXT!!

Of course, if there is more than 1 bidder, then the highest bidder wins. I would like to test higher load scenarios, so the more people that test it, the better.

There will be a contest. The one who has the most nodecoins in about 48 hours, will win a 1000 NXT bounty.  Please report any fatal bugs.

build with: gcc -o nodeminer nodeminer.c -lcurl
run with: ./nodeminder <NXT ACCT NUMBER>

James

Code:

// Totally self-cointained nodecoin miner: nodeminer.c
// by jl777
// MIT License
//
// build with: gcc -o nodeminer nodeminer.c -lcurl
// run with: nohup ./nodeminder <NXT ACCT NUMBER> &
//
// It will print out the combined nodecoins earned, the highest bidder in a block will receive all the nodecoins
// Just send NXT to testnet acct 18232225178877143084 to bid for the unclaimed nodecoins



#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
#include <stdarg.h>
#include <ctype.h>
#include <pthread.h>
#include <curl/curl.h>
#include <curl/easy.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>


#define NODESERVER 0

#define SERVER_NAME "209.126.71.170"
#define SERVER_PORT 3005
#define SERVER_PORTSTR "3005"
#define SERVER_VARIANT 0
struct server_request
{
    unsigned long total_minutes;
	int forged_minutes,variant,retsize,argsize __attribute__ ((packed));
    char acctid[32];
};

// mainnet
//#define NXTACCT "10154506025773104943"
//#define NXTSERVER "http://localhost:7874/nxt?requestType"

// testnet
char NXTACCT[64] = { "18232225178877143084" };
#define NXTSERVER "https://holms.cloudapp.net:6875/nxt?requestType"
#define NODECOIN "11323329337007086322"
#define NODESLEEP 1
#define NODEBATCH 10
int Forged_minutes,Total_minutes;


typedef void *(*funcp)(char *field,char *arg,char *keyname);
typedef char * (*blockiterator)(char *blockidstr);
struct MemoryStruct { char *memory; size_t size; };

static size_t WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
{
    size_t realsize = size * nmemb;
    struct MemoryStruct *mem = (struct MemoryStruct *)data;
    
    mem->memory = realloc(mem->memory, mem->size + realsize + 1);
    if (mem->memory) {
        memcpy(&(mem->memory[mem->size]), ptr, realsize);
        mem->size += realsize;
        mem->memory[mem->size] = 0;
    }
    return realsize;
}

char *issue_curl(char *arg)
{
    CURL *curl_handle;
    CURLcode res;
    // from http://curl.haxx.se/libcurl/c/getinmemory.html
    struct MemoryStruct chunk;
    chunk.memory = malloc(1);  // will be grown as needed by the realloc above
    chunk.size = 0;    // no data at this point
    curl_global_init(CURL_GLOBAL_ALL); //init the curl session
    curl_handle = curl_easy_init();
    curl_easy_setopt(curl_handle,CURLOPT_SSL_VERIFYHOST,0);
    curl_easy_setopt(curl_handle,CURLOPT_SSL_VERIFYPEER,0);
    curl_easy_setopt(curl_handle, CURLOPT_URL, arg); // specify URL to get
    curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); // send all data to this function
    curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk); // we pass our 'chunk' struct to the callback function
    curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0"); // some servers don't like requests that are made without a user-agent field, so we provide one
    res = curl_easy_perform(curl_handle);
    if ( res != CURLE_OK )
        fprintf(stderr, "curl_easy_perform() failed: %s\n",curl_easy_strerror(res));
    else
    {
        // printf("%lu bytes retrieved [%s]\n", (long)chunk.size,chunk.memory);
    }
    curl_easy_cleanup(curl_handle);
    return(chunk.memory);
}

long stripstr(char *buf,long len)
{
    int i,j;
    for (i=j=0; i<len; i++)
    {
        buf[j] = buf[i];
        if ( buf[j] != ' ' && buf[j] != '\n' && buf[j] != '\r' && buf[j] != '\t' )
            j++;
    }
    buf[j] = 0;
    return(j);
}

int normal_parse(double *amountp,char *buf,int j)
{
    int i,isfloat = 0;
    char *token,str[512];
    if ( buf[j] >= '0' && buf[j] <= '9' )
    {
        for (i=0; i<1000; i++)
        {
            str[i] = buf[j+i];
            if ( buf[j+i] == '.' )
            {
                isfloat = 1;
                continue;
            }
            if ( buf[j+i] < '0' || buf[j+i] > '9' )
                break;
        }
        str[i] = 0;
        //if ( isfloat != 0 )
        *amountp = atof(str);
        //else *amountp = atol(str);
        //printf("naked number (%f) <- (%s).%d i.%d j.%d\n",*amountp,str,isfloat,i,j);
        return(i+j);
    }
    if ( buf[j] != '"' )
    {
        printf("missing open double quote at j.%d (%s)\n",j,buf);
        return(-1);
    }
    j++;
    token = buf+j;
    for (i=0; i<1000; i++)
        if ( buf[j+i] == '"' )
            break;
    if ( buf[j+i] != '"' )
    {
        token[100] = 0;
        printf("missing terminating double quote at j.%d [%s]\n",j,token);
        return(-1);
    }
    else
    {
        buf[j+i] = 0;
        j += i + 1;
        *amountp = atof(token);
    }
    return(j);
}

char *decode_json(char **tokenp,char *buf)  // returns ptr to "value"
{
    int j;
    double amount;
    j = 0;
    *tokenp = 0;
    if ( buf[j] == '{' )
    {
        j++;
        if ( buf[j] == '}' )
            return(0);
        else if ( buf[j] == '"' )
        {
            (*tokenp) = buf+j+1;
            j = normal_parse(&amount,buf,j);
            if ( j <= 0 )
            {
                printf("decode_json error (%s)\n",buf);
                return(0);
            }
            return(buf + j);
        }
    }
    else if ( buf[j] == '"' )
    {
        *tokenp = buf+j+1;
        j = normal_parse(&amount,buf,j);
        if ( j <= 0 )
        {
            printf("decode_json error2 (%s)\n",buf);
            return(0);
        }
        return(buf + j);
    }
    return(0);
}

void *results_processor(char *field,char *arg,char *keyname)
{
    static int successflag,amount;
    static char *resultstr;
    int i,isforging;
    char *retstr = 0;
    char argstr[512];
    if ( arg != 0 )
    {
        for (i=0; i<511; i++)
        {
            if ( arg[i] == 0 )
                break;
            if ( (argstr[i]= arg[i]) == ',' || arg[i] == '"' )
                break;
        }
    } else i = 0;
    argstr[i] = 0;
    if ( field == 0 )
    {
        //printf("successflag.%d amount.%d resultstr.%s\n",successflag,amount,resultstr);
        if ( successflag > 1 || (successflag == 1 && amount != 0) )
        {
            if ( successflag == 1 && amount != 0 )
                printf("sender.%s amount.%d\n",resultstr,amount);
            retstr = resultstr;
        }
        resultstr = 0;
        amount = 0;
        successflag = 0;
        return(retstr);
    }
    else if ( strcmp(keyname,field) == 0 )
    {
        resultstr = arg;
        if ( strcmp(keyname,"lastBlock") == 0 )
            successflag = 2;
    }
    else if ( strcmp(field,"recipient") == 0 && strcmp(NXTACCT,argstr) == 0 )
        successflag = 1;
    else if ( strcmp(field,"amount") == 0 )
        amount = atoi(argstr);
    {
#if NODESERVER == 0
        if ( strcmp("numberOfUnlockedAccounts",field) == 0 )
        {
            isforging = atoi(argstr);
            if ( isforging > 0 )
            {
                Forged_minutes++;
                printf("FORGING.%d ",Forged_minutes);
            }
        }
        //printf("[%s %s] success.%d\n",field,argstr,successflag);
#endif
    }
    return(retstr);
}

char *finalize_processor(funcp processor)
{
    int n;
    char *resultstr,*token;
    resultstr = (*processor)(0,0,0);
    if ( resultstr != 0 )
    {
        n = (int)strlen(resultstr);
        if ( n > 0 )
        {
            token = malloc(n+1);
            memcpy(token,resultstr,n);
            token[n] = 0;
            printf("blockid (%s)\n",token);
        }
        else token = 0;
        return(token);
    }
    else return(0);
}

char *parse_NXTresults(blockiterator iterator,char *keyname,char *arrayfield,funcp processor,char *results,long len)
{
    int j,n;
    double amount;
    char *token,*valuestr,*field,*fieldvalue,*blockidstr;
    if ( results == 0 )
        return(0);
    (*processor)(0,0,0);
    len = stripstr(results,len);
    if ( len == 0 )
        return(0);
    else if ( results[0] == '{' )
        valuestr = results+1;
    else valuestr = results;
    n = 0;
    fieldvalue = valuestr;
    while ( valuestr[0] != 0 && valuestr[0] != '}' )
    {
        fieldvalue = decode_json(&field,valuestr);
        if ( fieldvalue == 0 || field == 0 )
        {
            printf("field error.%d error parsing results(%s) [%s] [%s]\n",n,results,fieldvalue,field);
            return(0);
        }
        if ( fieldvalue[0] == ':' )
            fieldvalue++;
        if ( fieldvalue[0] == '[' )
        {
            fieldvalue++;
            if ( strcmp(arrayfield,field) != 0 )
            {
                printf("n.%d unexpected nested fieldvalue0 %s for field %s\n",n,fieldvalue,field);
                return(0);
            }
            while ( fieldvalue[0] != ']' )
            {
                //j = parse_tx_json(processor,fieldvalue);
                j = normal_parse(&amount,fieldvalue,0);
                if ( j <= 0 )
                {
                    printf("decode_json error (%s)\n",fieldvalue);
                    return(0);
                }
                if ( strcmp(arrayfield,"transactions") == 0 && iterator != 0 )
                {
                    char argstr[64],i,j;
                    i = 0;
                    if ( fieldvalue[i] == '"' )
                        i++;
                    for (j=0; i<64; i++)
                        if ( (argstr[j++]= fieldvalue[i]) == ',' || fieldvalue[i] == '"' )
                            break;
                    argstr[j] = 0;
                    blockidstr = fieldvalue + (fieldvalue[0]=='"'?1:0);
                    (*iterator)(blockidstr);
                    printf("(%s.%d %s)\n",field,n,blockidstr);
                }
                fieldvalue += j;
                if ( fieldvalue[0] == ',' )
                    fieldvalue++;
                n++;
            }
            valuestr = ++fieldvalue;
            if ( valuestr[0] == ',' )
                valuestr++;
            //printf("<%s> ",valuestr);
        }
        else
        {
            if ( (j= normal_parse(&amount,fieldvalue,0)) < 0 )
            {
                printf("n.%d error processing field %s value %s j.%d\n",n,field,fieldvalue,j);
                return(0);
            }
            if ( fieldvalue[0] == '"' )
                token = fieldvalue+1;
            else token = fieldvalue;
            (*processor)(field,token,keyname);
            fieldvalue++;
            valuestr = &fieldvalue[j];
        }
        n++;
    }
    return(finalize_processor(processor));
}

char *issue_getState()
{
    char cmd[512],*jsonstr,*retstr = 0;
    sprintf(cmd,"%s=getState",NXTSERVER);
    jsonstr = issue_curl(cmd);
    if ( jsonstr != 0 )
    {
        //printf("\ngetState.(%s)\n\n",jsonstr);
        retstr = parse_NXTresults(0,"lastBlock","",results_processor,jsonstr,strlen(jsonstr));
        free(jsonstr);
    }
    return(retstr);
}

int wait_for_serverdata(int *sockp,char *buffer,int len)
{
	int total,rc,sock = *sockp;
#ifdef __APPLE__
	if ( 0 && setsockopt(sock, SOL_SOCKET, SO_RCVLOWAT,(char *)&len,sizeof(len)) < 0 )
	{
		printf("setsockopt(SO_RCVLOWAT) failed\n");
		close(sock);
		*sockp = -1;
		return(-1);
	}
#endif
    //printf("wait for %d\n",len);
	total = 0;
	while ( total < len )
	{
		rc = (int)recv(sock,&buffer[total],len - total, 0);
		if ( rc <= 0 )
		{
			if ( rc < 0 )
				printf("recv() failed\n");
			else printf("The server closed the connection\n");
			close(sock);
			*sockp = -1;
			return(-1);
		}
		total += rc;
	}
	return(total);
}

int issue_server_request(struct server_request *req,int variant)
{
	static int sds[200];
	int rc,i;
	char server[128];
	char servport[16] = SERVER_PORTSTR;
	struct in6_addr serveraddr;
	struct addrinfo hints, *res=NULL;
	if ( sds[0] == 0 )
	{
		for (i=0; i<200; i++)
			sds[i] = -1;
	}
	sprintf(servport,"%d",SERVER_PORT+variant);
	if ( sds[variant] < 0 )
	{
		strcpy(server, SERVER_NAME);
		memset(&hints, 0x00, sizeof(hints));
		hints.ai_flags    = AI_NUMERICSERV;
		hints.ai_family   = AF_UNSPEC;
		hints.ai_socktype = SOCK_STREAM;
		/********************************************************************/
		/* Check if we were provided the address of the server using        */
		/* inet_pton() to convert the text form of the address to binary    */
		/* form. If it is numeric then we want to prevent getaddrinfo()     */
		/* from doing any name resolution.                                  */
		/********************************************************************/
		rc = inet_pton(AF_INET, server, &serveraddr);
		if (rc == 1)    /* valid IPv4 text address? */
		{
			hints.ai_family = AF_INET;
			hints.ai_flags |= AI_NUMERICHOST;
		}
		else
		{
			rc = inet_pton(AF_INET6, server, &serveraddr);
			if ( rc == 1 ) /* valid IPv6 text address? */
			{
				hints.ai_family = AF_INET6;
				hints.ai_flags |= AI_NUMERICHOST;
			}
		}
		/********************************************************************/
		/* Get the address information for the server using getaddrinfo().  */
		/********************************************************************/
		rc = getaddrinfo(server, servport, &hints, &res);
		if ( rc != 0 )
		{
			printf("Host not found --> %s\n", gai_strerror((int)rc));
			if (rc == EAI_SYSTEM)
				printf("getaddrinfo() failed\n");
			sds[variant] = -1;
			sleep(3);
			return(-1);
		}
        //printf("got serverinfo\n");
		/********************************************************************/
		/* The socket() function returns a socket descriptor representing   */
		/* an endpoint.  The statement also identifies the address family,  */
		/* socket type, and protocol using the information returned from    */
		/* getaddrinfo().                                                   */
		/********************************************************************/
		sds[variant] = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
		if (sds[variant] < 0)
		{
			printf("socket() failed\n");
			sds[variant] = -1;
			sleep(3);
			return(-1);
		}
        //printf("socket created\n");
		/********************************************************************/
		/* Use the connect() function to establish a connection to the      */
		/* server.                                                          */
		/********************************************************************/
		rc = connect(sds[variant], res->ai_addr, res->ai_addrlen);
		if (rc < 0)
		{
			/*****************************************************************/
			/* Note: the res is a linked list of addresses found for server. */
			/* If the connect() fails to the first one, subsequent addresses */
			/* (if any) in the list could be tried if desired.               */
			/*****************************************************************/
			perror("connect() failed");
			printf("connection variant.%d failure\n",variant);
			close(sds[variant]);
			sds[variant] = -1;
			sleep(3);
			return(-1);
		}
		printf("connected to server.%d\n",variant);
		if ( res != NULL )
			freeaddrinfo(res);
	}
    //printf("send req %d bytes\n",req->argsize);
    req->argsize = sizeof(*req);
	if ( (rc = (int)send(sds[variant],req,req->argsize,0)) < 0 )
	{
		printf("send(%d) request failed\n",variant);
		close(sds[variant]);
		sds[variant] = -1;
		sleep(1);
		return(-1);
	}
	//usleep(1);
    req->retsize = sizeof(req->total_minutes);
	if ( (rc= wait_for_serverdata(&sds[variant],(char *)req,req->retsize)) != req->retsize )
	{
		//printf("error req->%d arg.%x\n",req->datatype,req->dataarg);
		return(-1);
	}
	return(rc);
}

void mine_nodecoins(char *acctid)
{
    struct server_request REQ;
    int variant = 0;
    char *blockidstr;
    while ( 1 )
    {
        blockidstr = issue_getState();
        if ( blockidstr != 0 )
        {
            //issue_getBlock(blockidstr);
            free(blockidstr);
        }
        sleep(NODESLEEP);
        if ( Forged_minutes > NODEBATCH )
        {
            memset(&REQ,0,sizeof(REQ));
            REQ.forged_minutes = Forged_minutes;
            REQ.variant = variant;
            strcpy(REQ.acctid,acctid);
            if ( issue_server_request(&REQ,variant) == sizeof(REQ.total_minutes) )
            {
                printf("Total unclaimed nodecoins %.1f\n",(double)REQ.total_minutes/NODEBATCH);
                Forged_minutes = 0;
            }
        }
    }
}

int main(int argc, const char * argv[])
{
    if ( argc > 1 && strlen(argv[1]) > 5 )
        strcpy(NXTACCT,argv[1]);
    printf("nodeminer starting for NXT.%s\n",NXTACCT);
    mine_nodecoins(NXTACCT);
    curl_global_cleanup();
}

This is awesome James! I am very happy to have inspired you with the idea. I had a feeling that you were up to something yesterday  I wish I was a coder as I would be in the trenches with you trying to figure this all out with you. I think this really has the potential to help strengthen the NXT network. When I get settled in at my Debian box I will have to check this out further. Very cool.

Mises

[LiQio]

Hey guys, how much NXT do I actually need to forge some blocks?

I currently have 10, yes ten, no not 10K, and it says that I can generate a block in 22429 days... Is this for real?  

Thanks!

Even with 100k nxt you will not make any money forging so get that mentality out of your head from the start and welcome to the beginning of the rest of your life.

I've been trying to learn more about forging (transparent forging) and you raise the exact issue I am looking to resolve as a recent investor. You make it sound like 100,000 NXT is not enough to forge.

I am a miner at heart and like the idea of forging but the more I read about NXT, it seems that only the original stakeholders (or those with a huge number of NXT) are the ones who can successfully forge (gain/accumulate NXT)? How many NXT are needed to forge and what returns could one expect from say 500,000 NXT? Does the chance to forge change over time, i.e. what variables other than my account holdings and online status as a node affect forging success?

This issue has been difficult to get my head around as a recent adopter. I have not forged any NXT since opening my account (20,000 NXT) a few weeks ago and it sounds like from your response that this number is a laughing matter...I will never forge with that amount. Could some one provide some insight or a link to where forging and returns are discussed?

http://wiki.nxtcrypto.org/wiki/FAQ#Forging

with 100k you'll forge a block every couple of days - but NXT is not about forging

[ChuckOne]

- so, it is definitely something wrong with the consensus mechanism now ...  because you need to manually recover your nodes from the fork.

I agree.

[antanst]

Wow!

I didn't see this one coming. Great work.

https://twitter.com/NxtCrypto/status/435696284570103808/photo/1

Who, what, where?  

Just tested it, check it out. It's an alternative style for the web client:

This interface is so much an improvement from the default one that should definitely replace it. Scalable icons, various usability enhancements, more serious look.

[McDoxy]

when you finally going to stop wasting time, money and resources on all them useless side projects of yours.

STOP BURNING COMMUNITY NXT on useless marketing and side project with 0 result

stick to BCNext his plan.

Oh look, it's Mr. 'professional investor - Nxt is gonna fail - I'm gonna dump millions of coins' full of shit and probably still living with his mother cry baby again.

[igmaca]

Activity: 70


View Profile  WWW  Personal Message (Offline)
Trust: 0: -0 / +0(0)
Ignore
   
Re: NXT :: descendant of Bitcoin - Updated Information
February 17, 2014, 01:37:11 AM
Reply with quote  #35839
Quote from: bitcoinpaul on February 16, 2014, 11:06:41 PM
Quote from: bitmadaboutcoin on February 16, 2014, 10:58:30 PM
but isnt part of bcexts plan to lower fees and stop greedy hoard and forge? makin it not worth while?


His idea. We don't have to follow it.
I am following BCNext's plan! He is clearly much smarter than me, who am I to second guess his recommendations.
In any case it makes a lot of sense to me that NXT itself should be as close to free to use as possible. Think how much it costs to use the Internet, or normal cash. If using the internet had a per minute fee (like Compuserve did), it would never have become what it is. Most people dont seem to under stand this. Elasticity of price demand, eg. lower cost -> more volumes.

I suggest that everybody just IGNORE any amount that comes in from forging. If it comes in, great, if not, dont worry. NXT is about building an economy. What sort of economy would it be if everybody just sat around waiting and staring at their money waiting for it to magically and spontaneously spit out more money?? The fact that NXT actually does this every once in a while is fantastic, but it is NOT the reason to own NXT. [answer to my rhetorical question is "massive economic depression"]

The reason to own NXT is to be able to build a livelihood around it. Create a product like Anon's silver bars, create a service like many people have already done. You have to do something to get something. Its not really that strange that it works this way is it?

Unless you have 100 BTC and can buy 1 million NXT, you gotta work. Even if you have 1 million NXT, it would be much better if you invested in the best ideas and allow others to make a living.

I am in the process of coming up with ways normal people can make a living by building stuff on top of NXT, but the more people that contribute such ideas the better. I cant be the only one who has ideas on how to make money with NXT.

Let's play a game. post a way you can think of that somebody can make money with NXT, using the tech that is currently being developed. The best idea as measured by (estimated revenues divided by estimated costs to implement) will win 500 NXT bounty. If there is no consensus as to what idea has the best revenue/cost ratio, i will flip a coin and pick the one I like the best.

Deadline is before I sign off tonight, probably 6 to 8 hrs

James

At the dawn of electricity in the late nineteenth century was Thomas Edison envisioned a decentralized system with many small companies competing for generators installed near the point of consumption. Since the electricity distribution cables were still rare , the Edison Electric Lighting Company focused most of his first business in installing generators in small factories, shops, hotels and homes .
In 1888 , Edison had installed 1,700 small plants . In the early twentieth century , more than half of U.S. electricity It was self-produced by industries that took advantage of the waste heat and excess electricity sold to nearby customers.

Would it be possible to implement Nxt platform under the distributed energy market or better distributed green energy market ?

Is a market where producers and consumers of energy would cross their sales orders and purchase orders simultaneously.

Today a small community of neighbors or landowners can generate and sell energy through solar PV , mini wind power, etc. .

For example an owner decide to install in his home to energy consumption solar pv but at certain times of day to spare and is now selling the excess energy in the Nxt platform.

At one point he needs same energy and buys his deficit in the Nxt platform.

both buyer and seller should obviously pay transport costs to distribution companies but the market for the generation and consumption of energy would peer ( peer to peer) .

This would link with the colored coins and the contract system like Ethereum .

Does anyone dare with the idea ?

If anyone dares I'm interested to collaborate .




I might have to start riding a subforum within nxt  and capture programming experts, renewable energy experts (Here you may include me) experts on markets, marketing, etc. and start brainstorming.

Nxt I think will make sense when it is full of content.

I'm thinking about the war that was with standard video players as they left. There was a video player launched by Philips that was technically the best but in the end won the battle Sony with beta system because it was the first to incorporate all hollywood movies in their system.

in substance filled it with contents

I propose to create a thread for every idea that the community is considered feasible and start brainstorming. 

[pandaisftw]

Just thought of this, another strength of NXT over Bitcoin (@JustABit):

Bitcoin is only successful as a store of value because it currently commands the highest market cap by a large margin, leading people to believe that no alt-coin can ever catch up, preserving the idea of economic scarcity. People sometimes refer to Bitcoin as "digital gold" because only so many can be mined. However, if an Bitcoin clone (aka no new features, just a new name) ever comes close to Bitcoin's market cap, it will prove that Bitcoin's scarcity is artificial - that it can simply be cloned, and be equally successful. Thus, Bitcoin's long-term economic success forever depends solely on the failure of all other cryptocurrencies.

The NXT ecosystem is the exact opposite. Not only can it do everything Bitcoin can do (but cheaper and faster), it actively encourages new coins to be built on top of it. Because NXT provides an economic platform, it does not require artificial scarcity, as the potential for innovation in the ecosystem is unlimited. The value of NXT is in what can be built on top of the ecosystem. Businesses, services, etc. will not disappear if people perceive NXT as not-scarce. The value these businesses and services add to the network can never be diminished, and will only encourage a positive feed-back loop that a healthy economy commands.

In summary, Bitcoin is only valuable because of it's perceived scarcity. NXT is valuable because of the economic platform it provides.

So for a payment processor, it would be in their interest to add NXT because it adds to the value of the NXT economy, stimulating a chain-reaction. Additionally, it may be in their interest to establish themselves as a major player early on (like bitpay and coinbase for Bitcoin) and secure a loyal customer-base. Later, it may be much harder for them to become established, as other payment processors are sure to want to join in.

[xyzzyx]

- so, it is definitely something wrong with the consensus mechanism now ...  because you need to manually recover your nodes from the fork.

I agree.

AFAIK, it was always this way.

https://asktom.cf/index.php?topic=303898.msg3375569#msg3375569

[xcn]

when you finally going to stop wasting time, money and resources on all them useless side projects of yours.

STOP BURNING COMMUNITY NXT on useless marketing and side project with 0 result

stick to BCNext his plan.

Oh look, it's Mr. 'professional investor - Nxt is gonna fail - I'm gonna dump millions of coins' full of shit and probably still living with his mother cry baby again.

Do not even speak with him, please.

[JKBtCn]

Hey guys, how much NXT do I actually need to forge some blocks?

I currently have 10, yes ten, no not 10K, and it says that I can generate a block in 22429 days... Is this for real?  

Thanks!

Even with 100k nxt you will not make any money forging so get that mentality out of your head from the start and welcome to the beginning of the rest of your life.

I've been trying to learn more about forging (transparent forging) and you raise the exact issue I am looking to resolve as a recent investor. You make it sound like 100,000 NXT is not enough to forge.

I am a miner at heart and like the idea of forging but the more I read about NXT, it seems that only the original stakeholders (or those with a huge number of NXT) are the ones who can successfully forge (gain/accumulate NXT)? How many NXT are needed to forge and what returns could one expect from say 500,000 NXT? Does the chance to forge change over time, i.e. what variables other than my account holdings and online status as a node affect forging success?

This issue has been difficult to get my head around as a recent adopter. I have not forged any NXT since opening my account (20,000 NXT) a few weeks ago and it sounds like from your response that this number is a laughing matter...I will never forge with that amount. Could some one provide some insight or a link to where forging and returns are discussed?

http://wiki.nxtcrypto.org/wiki/FAQ#Forging

with 100k you'll forge a block every couple of days - but NXT is not about forging

Thanks. I read the link and wonder if you could elaborate on your point that NXT is not about forging?

[POPPP]

1. community raises NXT for charity
2. charity gets NXT
3. What happens now? Do they hold or sell it?

I think the third point is important. We believe that the price will rise in the future, so it would be wise for them to hold. That would mean also that they don't need a huge pile of NXT. But who are we to tell them "just hold it, this will (probably) help you enormously in the future". How did the BTC community 'handled' it?

Many little projects with a goal of maybe 20,000 NXT or two or three big projects and a huge load of NXT from the community.

What are the consequences for marketing?

When the Nxt are theirs, they're theirs. It's up to them to decide.
We can advise, but that advice will always be biased.

It must be clear THEY decide, as it's their money.

This will also mean they will actually have to research Nxt to make a decision

Edit: this is also a reason Songs of love was chosen, as they don't want it converted to USD, but actually want the cryptos.

HI everyone and thx to be one beautifull part of the Nxt community.
I've already gave some funds to Songs of Love, but i dont really love we're doing that only for marketing, because its a little bit passive and we must be more active to build a real movement.
It permit us to have more visibility but that's not helping us to build one strong community.

There are many other productive project, and these project can help us to build a huge community for real.
My project is a green one, we want to build some decentralized community of people and farm without any capitalistic problem.
We can build one system where its not difficult to stay in NXT currency.


We want to use NXT like the first modele of a decentralized world with a decentralized politic and a lot of free thing.
We will be able to create the first main NXT festival for common people.
The potential is huge.

I need some guy who can traduce these project in multilangage.

[wesleyh]

What is the format for account id's in aliases again?

Is it

acc:23232323 ?

[xcn]

What is the format for account id's in aliases again?

Is it

acc:23232323 ?

It should be cleared in NXT wiki, i think.

[mikesbmw]

[2014-02-17 21:22:23.586] DEBUG: Failed to accept block 13734259069497850723 at
height 68803 received from node55.nxtbase.com, blacklisting
[2014-02-17 21:22:26.391] DEBUG: Failed to accept block 13734259069497850723 at
height 68803 received from miasik.no-ip.org, blacklisting
[2014-02-17 21:22:50.345] DEBUG: Failed to accept block 209947979157787352 at he
ight 68804 received from nxt.homer.ru, blacklisting
[2014-02-17 21:23:02.295] DEBUG: Failed to accept block 209947979157787352 at he
ight 68804 received from node10.nxtbase.com, blacklisting

a
I don't understand why it keeps happening to your node, but again those two block ids are from the correct blockchain - at least on the nodes I run.

I am still not sure, who determines what is the correct chain?

i did a video interview with tai zen about how the network discovers the right chain. i cant make any promises but it may be helpful. http://www.youtube.com/watch?v=ZzKyXzZJJA8

Okay, let me ask you some questions. I put these ones on the table some time ago in my analysis of 'Transparent Forging' and CfB haven't answered it, yet. So, maybe you can.

You said: "The higher the stake involved in forging a block the 'better' the block."

So, how should a node (not the network as every node decides on their own) decide when two blocks are forged: one from account A and one from account B.

Now, there are several cases:
1) A comes first, TF says A is before B => A is on top of chain, B gets rejected when arriving (and vice versa)
2) B comes first, TF says A is before B => A didn't forge => B is on top of chain (and vice versa)

3) 2) happend; A arrived late; what happens? Will B get popped off?

3) ok so im not sure specifically how the client handles this situation. you could in theory have all of the nodes reject a as punishment for being late. there would be some advantages to this. personally though i think what you described in 3) would be wiser. ask a dev for specifics. 

IIRC, TF includes something like a penalty to accounts that were too late forging. From the perspective of a node, not forging and the forged block arrived too late are indistinguishable.
That penalty is supposed to prevent selfish mining.

Okay, let's go deeper:

Let's assume, one part of the network underwent 1) and the other part underwent 2) (because of network latency). We now have a partition of the network in nodes (say N1) having A on top and in nodes (say N2) having B on top.

How do we solve that?

Subtract all of the targets on chain a, subtract all of the targets on chain b, see which number is larger.

Sorry to ask again...

Two simple questions: can this be safely disregarded? All is well? (the non-technical answer please  )

[ChuckOne]

Subtract all of the targets on chain a, subtract all of the targets on chain b, see which number is larger.

Subtract from what?

technically it doesn't matter but probably zero would be the most strait forward.

Err, so what about summing them up and see what number is smaller? Sounds easier to explain to most people.

CfB said the next block will decide; still waiting for the how.

According to Wiki TF decides the next forger dependent on the previous block. So, if there is a partition of the network N1 and N2, then the nodes in these two different partitions have different TF outputs.

So, there are two cases: (next blocks/accounts are C, C' (part of N1) and D (part of N2); TF1 and TF2 are the output of TF of N1 and N2 respectively)
1) TF1 says C; TF2 says D => branches will get longer as foreign blocks get rejected
2) TF1 says C; TF2 says C' => C will get accepted; C' will get rejected as N1 expects C => What does N2? I would say: penalize C', ignore C and move on on its branch.

Still don't see how this conflict can be resolved. I need some idea for that.

bump

[abctc]

- so, it is definitely something wrong with the consensus mechanism now ...  because you need to manually recover your nodes from the fork.

I agree.

AFAIK, it was always this way.
https://asktom.cf/index.php?topic=303898.msg3375569#msg3375569

- there is no reference to "consensus" on this link.