You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
294 lines
11 KiB
294 lines
11 KiB
/******************************************************************************
|
|
* Copyright © 2014-2015 The SuperNET Developers. *
|
|
* *
|
|
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at *
|
|
* the top-level directory of this distribution for the individual copyright *
|
|
* holder information and the developer policies on copyright and licensing. *
|
|
* *
|
|
* Unless otherwise agreed in a custom licensing agreement, no part of the *
|
|
* SuperNET software, including this file may be copied, modified, propagated *
|
|
* or distributed except according to the terms contained in the LICENSE file *
|
|
* *
|
|
* Removal or modification of this copyright notice is prohibited. *
|
|
* *
|
|
******************************************************************************/
|
|
#ifdef later
|
|
|
|
#ifdef DEFINES_ONLY
|
|
#ifndef accts777_h
|
|
#define accts777_h
|
|
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <memory.h>
|
|
#include "../iguana777.h"
|
|
|
|
#define ACCTS777_MAXRAMKVS 8
|
|
#define BTCDADDRSIZE 36
|
|
|
|
struct accts777_info
|
|
{
|
|
queue_t PaymentsQ;
|
|
struct peggy_unit *units;
|
|
int32_t numunits; uint8_t numkvs;
|
|
struct ramkv777 *bets,*pricefeeds,*hashaddrs,*coinaddrs,*SaMaddrs,*nxtaddrs,*addrkvs[16];
|
|
bits256 peggyhash;
|
|
struct txinds777_info *txinds;
|
|
};
|
|
|
|
struct accts777_info *accts777_init(char *dirname,struct txinds777_info *txinds);
|
|
|
|
#endif
|
|
#else
|
|
#ifndef accts777_c
|
|
#define accts777_c
|
|
|
|
#ifndef accts777_h
|
|
#define DEFINES_ONLY
|
|
#include "accts777.c"
|
|
//#include "../KV/ramkv777.c"
|
|
#undef DEFINES_ONLY
|
|
#endif
|
|
|
|
#define accts777_getaddrkv(accts,type) ((accts != 0) ? (accts)->addrkvs[type] : 0)
|
|
|
|
struct accts777_info *accts777_init(char *dirname,struct txinds777_info *txinds)
|
|
{
|
|
struct accts777_info *accts = calloc(1,sizeof(*accts));
|
|
accts->hashaddrs = ramkv777_init(accts->numkvs++,"hashaddrs",sizeof(bits256),1);
|
|
accts->coinaddrs = ramkv777_init(accts->numkvs++,"coinaddrs",BTCDADDRSIZE,1);
|
|
accts->nxtaddrs = ramkv777_init(accts->numkvs++,"nxtaddrs",sizeof(uint64_t),1);
|
|
accts->SaMaddrs = ramkv777_init(accts->numkvs++,"SaMaddrs",sizeof(bits384),1);
|
|
accts->bets = ramkv777_init(accts->numkvs++,"bets",BTCDADDRSIZE,1);
|
|
accts->pricefeeds = ramkv777_init(accts->numkvs++,"pricefeeds",sizeof(uint32_t) * 2,1);//, accts->pricefeeds->dispflag = 0;
|
|
if ( accts->numkvs > ACCTS777_MAXRAMKVS )
|
|
{
|
|
printf("too many ramkvs for accts %d vs %d\n",accts->numkvs,ACCTS777_MAXRAMKVS);
|
|
exit(-1);
|
|
}
|
|
accts->addrkvs[PEGGY_ADDRFUNDING] = accts->addrkvs[PEGGY_ADDRBTCD] = accts->coinaddrs;
|
|
accts->addrkvs[PEGGY_ADDR777] = accts->SaMaddrs;
|
|
accts->addrkvs[PEGGY_ADDRNXT] = accts->nxtaddrs;
|
|
accts->addrkvs[PEGGY_ADDRCREATE] = accts->addrkvs[PEGGY_ADDRUNIT] = accts->addrkvs[PEGGY_ADDRPUBKEY] = accts->hashaddrs;
|
|
if ( (accts->txinds= txinds) == 0 )
|
|
accts->txinds = txinds777_init(dirname,"txinds");
|
|
return(accts);
|
|
}
|
|
|
|
void accts777_free(struct accts777_info *accts)
|
|
{
|
|
int32_t i;
|
|
queue_free(&accts->PaymentsQ);
|
|
for (i=0; i<sizeof(accts->addrkvs)/sizeof(*accts->addrkvs); i++)
|
|
if ( accts->addrkvs[i] != 0 )
|
|
ramkv777_free(accts->addrkvs[i]);
|
|
free(accts);
|
|
}
|
|
|
|
struct accts777_info *accts777_clone(char *path,struct accts777_info *accts)
|
|
{
|
|
struct accts777_info *clone;
|
|
clone = accts777_init(path,accts->txinds);
|
|
queue_clone(&clone->PaymentsQ,&accts->PaymentsQ,sizeof(struct opreturn_payment));
|
|
if ( accts->numunits > 0 && accts->units != 0 )
|
|
{
|
|
clone->units = calloc(accts->numunits,sizeof(*accts->units));
|
|
memcpy(clone->units,accts->units,accts->numunits * sizeof(*accts->units));
|
|
}
|
|
clone->peggyhash = accts->peggyhash;
|
|
ramkv777_clone(clone->bets,accts->bets);
|
|
ramkv777_clone(clone->pricefeeds,accts->pricefeeds);
|
|
ramkv777_clone(clone->hashaddrs,accts->hashaddrs);
|
|
ramkv777_clone(clone->coinaddrs,accts->coinaddrs);
|
|
ramkv777_clone(clone->SaMaddrs,accts->SaMaddrs);
|
|
ramkv777_clone(clone->nxtaddrs,accts->nxtaddrs);
|
|
return(clone);
|
|
}
|
|
|
|
void *accts777_key(union peggy_addr *addr,int32_t type)
|
|
{
|
|
void *key;
|
|
switch ( type )
|
|
{
|
|
case PEGGY_ADDRFUNDING: case PEGGY_ADDRBTCD: key = &addr->coinaddr; break;
|
|
case PEGGY_ADDRNXT: key = &addr->nxt64bits; break;
|
|
case PEGGY_ADDR777: key = &addr->SaMbits; break;
|
|
case PEGGY_ADDRCREATE: key = &addr->newunit.sha256; break;
|
|
case PEGGY_ADDRUNIT: key = &addr->sha256; break;
|
|
case PEGGY_ADDRPUBKEY: key = &addr->sha256; break;
|
|
default: key = 0; break;
|
|
}
|
|
return(key);
|
|
}
|
|
|
|
struct acct777 *accts777_find(int32_t *valuesizep,struct accts777_info *accts,union peggy_addr *addr,int32_t type)
|
|
{
|
|
void *key;
|
|
if ( (key= accts777_key(addr,type)) != 0 )
|
|
return(ramkv777_read(valuesizep,accts->addrkvs[type],key));
|
|
else
|
|
{
|
|
if ( valuesizep != 0 )
|
|
*valuesizep = 0;
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
struct acct777 *accts777_create(struct accts777_info *accts,union peggy_addr *addr,int32_t type,uint32_t blocknum,uint32_t blocktimestamp)
|
|
{
|
|
struct acct777 *acct,A;
|
|
if ( (acct= accts777_find(0,accts,addr,type)) == 0 )
|
|
{
|
|
memset(&A,0,sizeof(A));
|
|
A.firstblocknum = blocknum, A.firsttimestamp = blocktimestamp;
|
|
acct = ramkv777_write(accts->addrkvs[type],accts777_key(addr,type),&A,sizeof(A));
|
|
}
|
|
else if ( blocknum < acct->firstblocknum || blocktimestamp < acct->firsttimestamp )
|
|
{
|
|
printf("accts777_create: already exists but with an earlier block/timestamp? %u:%u vs %u:%u\n",blocknum,acct->firstblocknum,blocktimestamp,acct->firsttimestamp);
|
|
return(0);
|
|
}
|
|
return(acct);
|
|
}
|
|
|
|
void peggy_delete(struct accts777_info *accts,struct peggy_unit *U,int32_t reason)
|
|
{
|
|
memcpy(U,&accts->units[--accts->numunits],sizeof(struct peggy_unit));
|
|
//U->redeemed = (uint32_t)time(NULL);
|
|
//if ( PEGS->lockhashes != 0 )
|
|
// kv777_delete(PEGS->lockhashes,U->lockPeriodHash,HASH_SIZE);
|
|
}
|
|
|
|
int32_t peggy_addunit(struct accts777_info *accts,struct peggy_unit *U,bits256 lockhash)
|
|
{
|
|
U->lockhash = lockhash;
|
|
accts->units = realloc(accts->units,sizeof(*accts->units) * (accts->numunits + 1));
|
|
accts->units[accts->numunits] = *U;
|
|
//if ( PEGS->lockhashes != 0 )
|
|
// kv777_write(PEGS->lockhashes,lockPeriodHash,HASH_SIZE,U,sizeof(*U));
|
|
return(accts->numunits++);
|
|
}
|
|
|
|
struct peggy_unit *peggy_match(struct accts777_info *accts,int32_t peg,uint64_t nxt64bits,bits256 lockhash,uint16_t lockdays)
|
|
{
|
|
int32_t i,size; struct peggy_unit *U;
|
|
if ( accts->hashaddrs == 0 )
|
|
{
|
|
for (i=0,U=&accts->units[0]; i<accts->numunits; i++,U++)
|
|
{
|
|
//if ( U->nxt64bits == 0 || U->nxt64bits == nxt64bits )
|
|
{
|
|
if ( U->lock.peg == peg && lockdays >= U->lock.minlockdays && lockdays <= U->lock.maxlockdays )
|
|
{
|
|
if ( memcmp(lockhash.bytes,U->lockhash.bytes,sizeof(lockhash)) == 0 )
|
|
return(U);
|
|
return(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
size = sizeof(*U);
|
|
if ( (U= ramkv777_read(&size,accts->hashaddrs,lockhash.bytes)) != 0 && size == sizeof(U) )
|
|
{
|
|
//if ( U->nxt64bits == 0 || U->nxt64bits == nxt64bits )
|
|
{
|
|
if ( U->lock.peg == peg && lockdays >= U->lock.minlockdays && lockdays <= U->lock.maxlockdays )
|
|
return(U);
|
|
}
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
int32_t peggy_swap(struct accts777_info *accts,uint64_t signerA,uint64_t signerB,bits256 hashA,bits256 hashB)
|
|
{
|
|
struct peggy_unit *U,*U2; int32_t size; uint64_t nxtA,nxtB;
|
|
size = sizeof(*U);
|
|
if ( (U= ramkv777_read(&size,accts->hashaddrs,hashA.bytes)) != 0 && size == sizeof(U) )
|
|
{
|
|
if ( (U2= ramkv777_read(&size,accts->hashaddrs,hashB.bytes)) != 0 && size == sizeof(U2) )
|
|
{
|
|
nxtA = acct777_nxt64bits(hashA), nxtB = acct777_nxt64bits(hashB);
|
|
if ( (nxtA == signerA && nxtB == signerB) || (nxtA == signerB && nxtB == signerA) )
|
|
{
|
|
// need to verify ownership
|
|
U2->lockhash = hashA, U->lockhash = hashB;
|
|
return(0);
|
|
}
|
|
}
|
|
}
|
|
return(-1);
|
|
}
|
|
|
|
int32_t acct777_pay(struct accts777_info *accts,struct acct777 *srcacct,struct acct777 *acct,int64_t value,uint32_t blocknum,uint32_t blocktimestamp)
|
|
{
|
|
if ( srcacct != 0 )
|
|
{
|
|
if ( srcacct->balance < value )
|
|
return(-1);
|
|
srcacct->balance -= value;
|
|
}
|
|
acct->balance += value;
|
|
return(0);
|
|
}
|
|
|
|
int64_t acct777_balance(struct accts777_info *accts,uint32_t blocknum,uint32_t blocktimestamp,union peggy_addr *addr,int32_t type)
|
|
{
|
|
int64_t balance = 0;
|
|
struct acct777 *acct;
|
|
if ( (acct= accts777_find(0,accts,addr,type)) != 0 )
|
|
balance = acct->balance;
|
|
return(balance);
|
|
}
|
|
|
|
int32_t peggy_flush(void *_PEGS,uint32_t currentblocknum,uint32_t blocknum,uint32_t blocktimestamp)
|
|
{
|
|
struct peggy_info *PEGS = _PEGS;
|
|
if ( PEGS != 0 && PEGS->accts != 0 )
|
|
return(txinds777_flush(PEGS->accts->txinds,blocknum,blocktimestamp));
|
|
else return(-1);
|
|
}
|
|
|
|
int32_t peggy_payments(queue_t *PaymentsQ,struct opreturn_payment *payments,int32_t max,uint32_t currentblocknum,uint32_t blocknum,uint32_t blocktimestamp)
|
|
{
|
|
struct opreturn_payment *payment; int32_t n = 0;
|
|
while ( max > 0 && (payment= queue_dequeue(PaymentsQ,0)) != 0 )
|
|
{
|
|
if ( payment->value != 0 && payment->coinaddr[0] != 0 )
|
|
*payments++ = *payment;
|
|
free(payment);
|
|
n++;
|
|
}
|
|
return(n);
|
|
}
|
|
|
|
int32_t peggy_emit(void *_PEGS,uint8_t opreturndata[MAX_OPRETURNSIZE],struct opreturn_payment *payments,int32_t max,uint32_t currentblocknum,uint32_t blocknum,uint32_t blocktimestamp)
|
|
{
|
|
char *opreturnstr; int32_t nonz,len = 0; struct peggy_info *PEGS = _PEGS;
|
|
if ( payments != 0 && max > 1 && PEGS->accts != 0 && peggy_payments(&PEGS->accts->PaymentsQ,payments,max,currentblocknum,blocknum,blocktimestamp) < 0 )
|
|
return(-1);
|
|
if ( opreturndata != 0 && (opreturnstr= peggy_emitprices(&nonz,PEGS,blocktimestamp,0)) != 0 )
|
|
{
|
|
memset(opreturndata,0,MAX_OPRETURNSIZE);
|
|
len = (int32_t)strlen(opreturnstr) / 2;
|
|
decode_hex(opreturndata,len,opreturnstr);
|
|
free(opreturnstr);
|
|
}
|
|
return(len);
|
|
}
|
|
|
|
uint32_t peggy_clone(char *path,void *dest,void *src)
|
|
{
|
|
struct peggy_info *destPEGS,*srcPEGS;
|
|
printf("inside peggy_clone sizeof peggy_info %d %d %d\n",(int32_t)sizeof(*destPEGS),(int32_t)sizeof(destPEGS->pricedpegs),(int32_t)sizeof(destPEGS->pairedpegs));//, getchar();
|
|
destPEGS = dest, srcPEGS = src;
|
|
*destPEGS = *srcPEGS;
|
|
destPEGS->accts = accts777_clone(path,srcPEGS->accts);
|
|
return(0);
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#endif
|
|
|