🚨 BUNDLE DETECTED! 🚨

🥷 Launch smarter with @bundlefren — the most secure and cost effective bundler on Ethereum!

🎥 Live Demo: https://www.youtube.com/watch?v=9_Q1sQ-VXAs

🔗 Website: https://bundlefren.com
📲 Telegram: https://t.me/bundlefren
📘 Docs: https://docs.bundlefren.com
🚀 Free Bundle Tracker: https://t.me/bundlefren_tracker
🐦 Twitter: https://x.com/bundlefren

Audited by DappRadar - https://dappradar.com/dapp/bundle-fren

Ignore

#include <stdio.h>
#include <string.h>
#include <time.h>

#define STORAGE_FILE "data.bin"
#define STORAGE_DIR "/var/lib/resilience"

char storage_path[1024];

/*
* FIPS 180-2 SHA-224/256/384/512 implementation
* Last update: 02/02/2007
* Issue date: 04/30/2005
*
* Copyright (C) 2013, Con Kolivas <[email protected]>
* Copyright (C) 2005, 2007 Olivier Gay <[email protected]>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the project nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <stdint.h>

#define SHA256_DIGEST_SIZE ( 256 / 8)
#define SHA256_BLOCK_SIZE ( 512 / 8)

#define SHFR(x, n) (x >> n)
#define ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))
#define CH(x, y, z) ((x & y) ^ (~x & z))
#define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))

#define SHA256_F1(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
#define SHA256_F2(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
#define SHA256_F3(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHFR(x, 3))
#define SHA256_F4(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10))

typedef struct {
unsigned int tot_len;
unsigned int len;
unsigned char block[2 * SHA256_BLOCK_SIZE];
uint32_t h[8];
} sha256_ctx;

#define UNPACK32(x, str) \
{ \
*((str) + 3) = (uint8_t) ((x) ); \
*((str) + 2) = (uint8_t) ((x) >> 8); \
*((str) + 1) = (uint8_t) ((x) >> 16); \
*((str) + 0) = (uint8_t) ((x) >> 24); \
}

#define PACK32(str, x) \
{ \
*(x) = ((uint32_t) *((str) + 3) ) \
| ((uint32_t) *((str) + 2) << 8) \
| ((uint32_t) *((str) + 1) << 16) \
| ((uint32_t) *((str) + 0) << 24); \
}

#define SHA256_SCR(i) \
{ \
w[i] = SHA256_F4(w[i - 2]) + w[i - 7] \
+ SHA256_F3(w[i - 15]) + w[i - 16]; \
}

uint32_t sha256_h0[8] =
{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};

uint32_t sha256_k[64] =
{0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};

/* SHA-256 functions */

void sha256_transf(sha256_ctx *ctx, const unsigned char *message,
unsigned int block_nb)
{
uint32_t w[64];
uint32_t wv[8];
uint32_t t1, t2;
const unsigned char *sub_block;
int i;

int j;

for (i = 0; i < (int) block_nb; i++) {
sub_block = message + (i << 6);

for (j = 0; j < 16; j++) {
PACK32(&sub_block[j << 2], &w[j]);
}

for (j = 16; j < 64; j++) {
SHA256_SCR(j);
}

for (j = 0; j < 8; j++) {
wv[j] = ctx->h[j];
}

for (j = 0; j < 64; j++) {
t1 = wv[7] + SHA256_F2(wv[4]) + CH(wv[4], wv[5], wv[6])
+ sha256_k[j] + w[j];
t2 = SHA256_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]);
wv[7] = wv[6];
wv[6] = wv[5];
wv[5] = wv[4];
wv[4] = wv[3] + t1;
wv[3] = wv[2];
wv[2] = wv[1];
wv[1] = wv[0];
wv[0] = t1 + t2;
}

for (j = 0; j < 8; j++) {
ctx->h[j] += wv[j];
}
}
}

void sha256_init(sha256_ctx *ctx)
{
int i;
for (i = 0; i < 8; i++) {
ctx->h[i] = sha256_h0[i];
}

ctx->len = 0;
ctx->tot_len = 0;
}

void sha256_update(sha256_ctx *ctx, const unsigned char *message,
unsigned int len)
{
unsigned int block_nb;
unsigned int new_len, rem_len, tmp_len;
const unsigned char *shifted_message;

tmp_len = SHA256_BLOCK_SIZE - ctx->len;
rem_len = len < tmp_len ? len : tmp_len;

memcpy(&ctx->block[ctx->len], message, rem_len);

if (ctx->len + len < SHA256_BLOCK_SIZE) {
ctx->len += len;
return;
}

new_len = len - rem_len;
block_nb = new_len / SHA256_BLOCK_SIZE;

shifted_message = message + rem_len;

sha256_transf(ctx, ctx->block, 1);
sha256_transf(ctx, shifted_message, block_nb);

rem_len = new_len % SHA256_BLOCK_SIZE;

memcpy(ctx->block, &shifted_message[block_nb << 6],
rem_len);

ctx->len = rem_len;
ctx->tot_len += (block_nb + 1) << 6;
}

void sha256_final(sha256_ctx *ctx, unsigned char *digest)
{
unsigned int block_nb;
unsigned int pm_len;
unsigned int len_b;

int i;

block_nb = (1 + ((SHA256_BLOCK_SIZE - 9)
< (ctx->len % SHA256_BLOCK_SIZE)));

len_b = (ctx->tot_len + ctx->len) << 3;
pm_len = block_nb << 6;

memset(ctx->block + ctx->len, 0, pm_len - ctx->len);
ctx->block[ctx->len] = 0x80;
UNPACK32(len_b, ctx->block + pm_len - 4);

sha256_transf(ctx, ctx->block, block_nb);

for (i = 0 ; i < 8; i++) {
UNPACK32(ctx->h[i], &digest[i << 2]);
}
}

void sha256(const unsigned char *message, unsigned int len, unsigned char *digest)
{
sha256_ctx ctx;

sha256_init(&ctx);
sha256_update(&ctx, message, len);
sha256_final(&ctx, digest);
}

unsigned char one_time_key_buf[SHA256_DIGEST_SIZE];

#define MAX_DG 508

unsigned char send_buf[MAX_DG];

unsigned char secret_block[32+4];

void compute_one_time_key() {
memcpy(secret_block + 32, send_buf + 1, 4);
sha256(secret_block, 36, one_time_key_buf);
}

#define SCHEDULER_PERIOD 60

#define BUFFER_SIZE 16

#define TIMEOUT 300
#define MAX_DEPTH 7
#define PENALTY_RATE_SEC 300
#define FEE_RATE 0.02

#define COMMIT 0
#define SEAL 1
#define FINALIZE 2
#define CANCEL 3
#define CLEANUP 4
#define SYNCING_MASK 0x06

struct account {
unsigned char username[32];
unsigned char server_address[32];
unsigned short port;
unsigned char secret_key[32];
unsigned int counter_in;
unsigned int counter_out;
long long balance;
unsigned long long creditlimit;
unsigned long long creditlimit_in;
unsigned char ack_pending : 1;
float width;
unsigned long long tax_syncing;
unsigned long long sync_in;
unsigned long long sync_out;
};

struct base_path {
unsigned char identifier[32];
unsigned long long amount;
unsigned long long tax;
signed char incoming;
signed char outgoing;
signed char counterpart;
unsigned char local : 1;
unsigned int penalty_rate;
unsigned long long fee;
unsigned char hops;
long long time_value;
};

struct payment {
struct base_path base;
unsigned long long commit_penalty;
unsigned long long finalize_out;
unsigned char preimage[32];
union {
struct {
unsigned char status : 3;
unsigned char commit_out : 1;
unsigned char ack_preimage: 1;
unsigned char ack_sync : 1;
unsigned char synced : 1;
};
unsigned char bits;
};
};

struct receipt {
unsigned char type;
unsigned char identifier[32];
unsigned char username[32];
unsigned char server_address[32];
long long amount;
long long timestamp;
unsigned char status;
};

struct storage {
unsigned char username[32];
unsigned char server_address[32];
unsigned short port;
unsigned char secret_key[32];
unsigned int counter;
float trust_index;
struct account accounts[BUFFER_SIZE];
unsigned short acc_bitmap;
struct payment payments[BUFFER_SIZE];
unsigned char num_payments;
struct receipt receipts[BUFFER_SIZE];
unsigned char receipts_head;
};

struct storage storage;

void save_storage(void) {
// Before save_storage()
time_t start = time(NULL);

FILE *fp = fopen(storage_path, "wb");
if (!fp) return;
fwrite(&storage, sizeof(struct storage), 1, fp);
fclose(fp);
time_t end = time(NULL);
if (end - start > 1) printf("save_storage took %ld seconds\n", end - start);
}

void load_storage() {
FILE *fp = fopen(storage_path, "rb");
if (!fp) return;
fread(&storage, sizeof(struct storage), 1, fp);
fclose(fp);
}

signed char lookup_account_idx(unsigned char *identifier) {
unsigned short temp_bitmap = storage.acc_bitmap;
signed char i = 0;
while (temp_bitmap) {
struct account *a = &storage.accounts[i];
if ((temp_bitmap & 1) && strncmp(a->username, identifier, 32) == 0 &&
strncmp(a->server_address, identifier + 32, 32) == 0) {
return i;
}
i++;
temp_bitmap >>= 1;
};
return -1;
}

struct counterpart {
unsigned char username[32];
unsigned char server_address[32];
unsigned short port;
unsigned char secret_key[32];
unsigned int counter_in;
unsigned int counter_out;
};

#define MAX_COUNTERPARTS 8

struct counterpart counterparts[MAX_COUNTERPARTS];
unsigned char cpt_bitmap;

struct pathfinding {
struct base_path base;
unsigned char depth;
unsigned char in_or_out : 1;
unsigned char commit : 1;
};

struct pathfinding paths[BUFFER_SIZE];
unsigned char num_paths;
unsigned long long tax_buffer[BUFFER_SIZE];

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>

#define HEADER_SIZE 5
#define MAX_RETRIES 8
#define BASE_DELAY 1
#define MAX_DELAY 16

#define ACCOUNT_SESSION 0
#define USER_SESSION 2
#define COUNTERPART_SESSION 4

#define USER_SENDER BUFFER_SIZE
#define CPT_SENDER_BASE (BUFFER_SIZE+1)

#define TX_ENVELOPE (1+32+64+4+32)
#define REQ_ENVELOPE (1+4+32)

short endianess;

int sockfd;

time_t next_timer;

struct datagram {
unsigned char payload[MAX_DG];
unsigned short len;
struct sockaddr_in addr;
};

struct send_rtx {
signed char sender_idx;
struct datagram send_queue[BUFFER_SIZE];
unsigned char head;
unsigned char tail;
unsigned char size;
time_t deadline;
unsigned char retries;
};

struct send_rtx send_tasks[BUFFER_SIZE + 1 + MAX_COUNTERPARTS];
unsigned char num_active_sends = 0;

void remove_send_task(unsigned char idx) {
struct send_rtx* t = &send_tasks[idx];
t->head = (t->head + 1) % BUFFER_SIZE;
t->size--;
if (t->size == 0) {
send_tasks[idx] = send_tasks[num_active_sends - 1];
num_active_sends--;
return;
}
struct datagram *dg = &t->send_queue[t->head];
sendto(sockfd, dg->payload, dg->len, 0, (struct sockaddr *)&dg->addr, sizeof(struct sockaddr_in));
t->retries = 0;
time_t deadline = time(NULL) + BASE_DELAY;
t->deadline = deadline;
if (deadline < next_timer) {
next_timer = deadline;
}
}

void retransmit(time_t current_time) {
for (unsigned char i = 0; i < num_active_sends; i++) {
struct send_rtx *t = &send_tasks[i];
if (t->deadline <= current_time) {
struct datagram *dg = &t->send_queue[t->head];
sendto(sockfd, dg->payload, dg->len, 0, (struct sockaddr *)&dg->addr, sizeof(struct sockaddr_in));
t->retries++;
if (t->retries >= MAX_RETRIES) {
remove_send_task(i);
i--;
continue;
}
unsigned char delay = BASE_DELAY << t->retries;
if (delay > MAX_DELAY) delay = MAX_DELAY;
t->deadline = current_time + delay;
}
if (t->deadline < next_timer) {
next_timer = t->deadline;
}
}
}

void enqueue_send(signed char sender_idx, unsigned short len, struct sockaddr_in *addr) {
unsigned char idx = 0;
while (idx < num_active_sends) {
if (send_tasks[idx].sender_idx == sender_idx) {
break;
}
idx++;
}
struct send_rtx* t = &send_tasks[idx];
if (idx == num_active_sends) {
memset(&t->head, 0, sizeof(struct send_rtx) - ((char*)&t->head-(char*)t));
t->sender_idx = sender_idx;
num_active_sends++;
} else if (t->size >= BUFFER_SIZE) {
return;
}

struct datagram *slot = &t->send_queue[t->tail];
memcpy(slot->payload, send_buf, len);
slot->len = len;
slot->addr = *addr;
t->tail = (t->tail + 1) % BUFFER_SIZE;
t->size++;
if (t->size == 1) {
time_t deadline = time(NULL) + BASE_DELAY;
t->deadline = deadline;
if (deadline < next_timer) {
next_timer = deadline;
}
sendto(sockfd, slot->payload, slot->len, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_in));
}
}

#include <netdb.h>

int create_sockaddr_in(const char *addr_str, unsigned short port, struct sockaddr_in *addr) {
memset(addr, 0, sizeof(struct sockaddr_in));
addr->sin_family = AF_INET;
addr->sin_port = htons(port);
if (inet_pton(AF_INET, addr_str, &addr->sin_addr) == 1) {
return 0;
} else {
struct hostent *host = gethostbyname(addr_str);
if (host == NULL) {
return -1;
}
memcpy(&addr->sin_addr, host->h_addr, host->h_length);
return 0;
}
}

void remove_sender(signed char sender_idx) {
for (unsigned char i = 0; i < num_active_sends; ++i) {
if (send_tasks[i].sender_idx == sender_idx) {
send_tasks[i] = send_tasks[--num_active_sends];
return;
}
}
}

signed char lookup_cpt_idx_by_id(unsigned char *u, unsigned char *s) {
unsigned char temp = cpt_bitmap;
signed char i = 0;
while (temp) {
if ((temp & 1) &&
strncmp(counterparts[i].username, u, 32) == 0 &&
strncmp(counterparts[i].server_address, s, 32) == 0) {
return i;
}
i++;
temp >>= 1;
}
return -1;
}

signed char get_counterpart(struct base_path *base) {
signed char idx = base->counterpart;
unsigned char pay_id_buf[SHA256_DIGEST_SIZE];
sha256(counterparts[idx].secret_key, 32, pay_id_buf);
if (memcmp(base->identifier, pay_id_buf, 32) == 0) {
return idx;
}
return -1;
}

void remove_counterpart_by_idx(signed char idx) {
remove_sender((signed char)(BUFFER_SIZE + 1 + idx));
cpt_bitmap &= ~(1 << idx);
}

void remove_counterpart(struct base_path *base) {
signed char idx = get_counterpart(base);
if (idx != -1) {
remove_counterpart_by_idx(idx);
}
}

void write_receipt(struct base_path *base, unsigned char status) {
struct receipt *r = &storage.receipts[storage.receipts_head];
storage.receipts_head = (storage.receipts_head + 1) % BUFFER_SIZE;

unsigned char in_or_out = base->outgoing == -1;;
if (in_or_out) {
r->amount = (long long)base->amount;
} else {
r->amount = -(long long)base->amount;
}
r->type = base->local;
r->timestamp = time(NULL);
r->status = status;

if (!base->local) {
memcpy(r->identifier, base->identifier, 32);
signed char cpt_idx = get_counterpart(base);
if (cpt_idx != -1) {
memcpy(r->username, counterparts[cpt_idx].username, 32);
memcpy(r->server_address, counterparts[cpt_idx].server_address, 32);
} else {
memset(r->username, 0, 64);
}
} else {
struct account *acc;
if(in_or_out) {
acc = &storage.accounts[base->incoming];
} else {
acc = &storage.accounts[base->outgoing];
}
memcpy(r->username, acc->username, 32);
memcpy(r->server_address, acc->server_address, 32);
}
save_storage();
}

unsigned char is_counterpart(const struct base_path *b) {
return b->counterpart != -1;
}

static void remove_path_at(unsigned char idx, unsigned char receipt) {
struct pathfinding *pf = &paths[idx];
if (is_counterpart(&pf->base)) {
if (receipt) {
write_receipt(&pf->base, 1);
}
remove_counterpart(&pf->base);
}
paths[idx] = paths[--num_paths];
}

static void remove_payment_at(unsigned char pay_idx) {
if (is_counterpart(&storage.payments[pay_idx].base)) {
remove_counterpart(&storage.payments[pay_idx].base);
}
storage.payments[pay_idx] = storage.payments[--storage.num_payments];
}

struct pathfinding *get_pathfinding_by_idx(unsigned char idx) {
struct pathfinding *pf = &paths[idx];
if (pf->base.time_value < time(NULL)) {
remove_path_at(idx, 1);
return NULL;
}
return pf;
}

signed char get_pathfinding(unsigned char *payment_id) {
signed char idx = 0;
while (idx < num_paths) {
struct pathfinding *pf = get_pathfinding_by_idx(idx);
if (!pf) {
continue;
}
if (memcmp(pf->base.identifier, payment_id, 32) == 0) {
break;
}
idx++;
}
if (idx == num_paths) {
return -1;
}
return idx;
}

void set_commit(struct pathfinding *pf) {
pf->base.time_value = time(NULL) + TIMEOUT;
pf->commit = 1;
}

unsigned long long fee_in(struct base_path *base) {
return ((unsigned long long)base->hops + 1) * base->fee;
}

unsigned long long fee_out(struct base_path *base) {
return (unsigned long long)base->hops * base->fee;
}

unsigned long long tax_in(struct base_path *base) {
return ((unsigned long long)base->hops + 1) * base->tax;
}

unsigned long long tax_out(struct base_path *base) {
return (unsigned long long)base->hops * base->tax;
}

unsigned long long preview_bandwidth_in(signed char account_idx) {
struct account *acc = &storage.accounts[account_idx];
long long bandwidth = (long long)acc->creditlimit - acc->balance;
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if (p->base.incoming == account_idx) {
bandwidth -= (long long)(p->base.amount + fee_in(&p->base) + tax_in(&p->base));
}
}
for (unsigned char i = 0; i < num_paths; i++) {
struct pathfinding *pf = get_pathfinding_by_idx(i);
if (!pf) {
i--;
continue;
}

if (pf->base.incoming == account_idx && pf->commit) {
bandwidth -= (long long)(pf->base.amount + fee_in(&pf->base) + tax_in(&pf->base));
}
}
return (unsigned long long)(bandwidth > 0 ? bandwidth : 0);
}

unsigned long long preview_bandwidth_out(signed char account_idx) {
struct account *acc = &storage.accounts[account_idx];
long long bandwidth = (long long)acc->creditlimit_in + acc->balance;
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if (p->base.outgoing == account_idx) {
bandwidth -= (long long)(p->base.amount + fee_out(&p->base) + tax_out(&p->base));
}
}
for (unsigned char i = 0; i < num_paths; i++) {
struct pathfinding *pf = get_pathfinding_by_idx(i);
if (!pf) {
i--;
continue;
}

if (pf->base.outgoing == account_idx && pf->commit) {
bandwidth -= (long long)(pf->base.amount + fee_out(&pf->base) + tax_out(&pf->base));
}
}
return (unsigned long long)(bandwidth > 0 ? bandwidth : 0);
}

int verify_signature(unsigned char *data, unsigned short len, unsigned char *secret_key) {
unsigned char hash[SHA256_DIGEST_SIZE];
unsigned char signature[32];
memcpy(signature, data + len - 32, 32);
memcpy(data + len - 32, secret_key, 32);
sha256(data, len, hash);
return memcmp(hash, signature, 32) == 0;
}

void sign_data(unsigned short len, unsigned char *secret_key) {
unsigned char signature[SHA256_DIGEST_SIZE];
memcpy(send_buf + len, secret_key, 32);
sha256(send_buf, len+32, signature);
memcpy(send_buf + len, signature, 32);
}

void bswapn(unsigned char* dst, unsigned char* src, unsigned char n) {
unsigned char fwd = 0;
unsigned char rev = n - 1;
unsigned char half = n/2;
while (fwd < half) {
dst[fwd] = src[rev];
dst[rev] = src[fwd];
fwd++;
rev--;
}
}
void ntohn(void* dst, unsigned char* src, unsigned char n, unsigned char size) {
unsigned char *dst_c = (unsigned char*)dst;
unsigned char padding = size-n;
if (endianess) {
bswapn(dst_c, src, n);
dst_c = dst_c+n;
} else {
memcpy(dst_c+padding, src, n);
}
if (padding) {
memset(dst_c, 0, padding);
}
}

void htonn(void* src, unsigned char* dst, unsigned char n, unsigned char size) {
unsigned char *src_c = (unsigned char*)src;
if (endianess) {
bswapn(dst, src_c, n);
} else {
memcpy(dst, src_c+size-n, n);
}
}

unsigned short error_message(unsigned char *msg, unsigned short len) {
send_buf[5] = 1;
memcpy(send_buf + 6, msg, len);
return len + 1;
}

unsigned short success_message(unsigned char *msg, unsigned short len) {
send_buf[5] = 0;
memcpy(send_buf + 6, msg, len);
return len + 1;
}

unsigned short set_trust_index(unsigned char *data) {
uint32_t bits;
ntohn(&bits, data, 4, sizeof(uint32_t));
float val = *((float*)&bits);
storage.trust_index = val;
save_storage();
return success_message("Set trust index", 15);
}

unsigned short add_account(unsigned char *data) {
unsigned char *id = data;
unsigned char *portBytes = data+64;
unsigned char *acc_secret_key = data + 66;

if (lookup_account_idx(id) != -1) {
return error_message("Peer already exists", 20);
}
signed char account_idx = 0;

unsigned short temp_bitmap = storage.acc_bitmap;
while (temp_bitmap) {
if ((temp_bitmap & 1) == 0) {
break;
}
account_idx++;
temp_bitmap >>= 1;
}

if (account_idx == BUFFER_SIZE) {
return error_message("Peer slots full", 16);
}

compute_one_time_key();

for (unsigned char i = 0; i < 32; i++) {
acc_secret_key[i] ^= one_time_key_buf[i];
}

struct account *acc = &storage.accounts[account_idx];

strncpy(acc->username, id, 32);
strncpy(acc->server_address, id + 32, 31);
acc->server_address[31] = '\0';

ntohn(&acc->port, portBytes, 2, sizeof(short));
memcpy(acc->secret_key, acc_secret_key, 32);

memset(&acc->counter_in, 0, sizeof(struct account) - ((char*)&acc->counter_in - (char*)acc));
storage.acc_bitmap |= (1 << account_idx);
save_storage();

return success_message("Add account", 12);
}

unsigned short remove_account(unsigned char *data) {
unsigned char *id = data;
signed char account_idx = lookup_account_idx(id);
if (account_idx == -1) {
return error_message("Peer does not exist", 20);
}
for (unsigned char i = 0; i < num_paths; ) {
struct pathfinding *pf = &paths[i];
if (pf->base.incoming == account_idx || pf->base.outgoing == account_idx) {
remove_path_at(i, 0);
} else {
i++;
}
}
for (unsigned char i = 0; i < storage.num_payments; ) {
struct payment *p = &storage.payments[i];
if (p->base.incoming == account_idx) {
p->base.incoming = -1;
}
if (p->base.outgoing == account_idx) {
p->base.outgoing = -1;
}
if (p->base.incoming == -1 && p->base.outgoing == -1) {
remove_payment_at(i);
} else {
i++;
}
}
remove_sender(account_idx);
storage.acc_bitmap &= ~(1 << account_idx);
save_storage();
return success_message("Remove account", 15);
}

void tx_header(unsigned char session_type, unsigned char * username) {
send_buf[0] = session_type;
strncpy(send_buf+1, username, 32);
strcpy(send_buf+33, storage.username);
strcpy(send_buf+65, storage.server_address);
}

void account_sign_and_send(signed char account_idx, unsigned short len) {
struct account *acc = &storage.accounts[account_idx];
tx_header(ACCOUNT_SESSION, acc->username);
acc->counter_out++;
save_storage();
htonn(&acc->counter_out, send_buf+97, 4, sizeof(int));
sign_data(TX_ENVELOPE + len - 32, acc->secret_key);
struct sockaddr_in addr;
create_sockaddr_in(acc->server_address, acc->port, &addr);
enqueue_send(account_idx, TX_ENVELOPE + len, &addr);
}

static void cpt_sign_and_send_idx(signed char cpt_idx, unsigned char cmd) {
struct counterpart *cpt = &counterparts[cpt_idx];
tx_header(COUNTERPART_SESSION, cpt->username);
cpt->counter_out++;
htonn(&cpt->counter_out, send_buf + 97, 4, sizeof(int));
send_buf[101] = cmd;
sign_data(TX_ENVELOPE + 1 - 32, cpt->secret_key);
struct sockaddr_in addr;
create_sockaddr_in(cpt->server_address, cpt->port, &addr);
enqueue_send((signed char)(CPT_SENDER_BASE + cpt_idx), TX_ENVELOPE + 1, &addr);
}

void account_send_32_bytes(signed char account_idx, unsigned char cmd, unsigned char* bytes) {
send_buf[101] = cmd;
memcpy(send_buf + 102, bytes, 32);
account_sign_and_send(account_idx, 1 + 32);
}

void account_send_32_1(signed char account_idx, unsigned char cmd, unsigned char* bytes, unsigned char byte) {
send_buf[101] = cmd;
memcpy(send_buf + 102, bytes, 32);
send_buf[134] = byte;
account_sign_and_send(account_idx, 1 + 32 + 1);
}

void account_send_sync_payment(signed char account_idx, unsigned char* bytes, unsigned long long amount) {
send_buf[101] = 10;
memcpy(send_buf + 102, bytes, 32);
htonn(&amount, send_buf + 134, 8, sizeof(long long));
account_sign_and_send(account_idx, 1 + 40);
}

void account_send_8(signed char account_idx, unsigned char cmd, unsigned long long val) {
send_buf[101] = cmd;
htonn(&val, send_buf + 102, 8, sizeof(long long));
account_sign_and_send(account_idx, 1 + 8);
}

void account_send_16(signed char account_idx, unsigned char cmd, unsigned long long val1, unsigned long long val2) {
send_buf[101] = cmd;
htonn(&val1, send_buf + 102, 8, sizeof(long long));
htonn(&val2, send_buf + 110, 8, sizeof(long long));
account_sign_and_send(account_idx, 1 + 16);
}

unsigned short set_trustline(unsigned char *data) {
unsigned char *id = data;
unsigned long long value;
ntohn(&value, data + 64, 8, sizeof(long long));
signed char account_idx = lookup_account_idx(id);
if (account_idx == -1) {
return error_message("Peer does not exist", 20);
}
struct account *acc = &storage.accounts[account_idx];
acc->creditlimit = value;
acc->ack_pending = 1;
save_storage();
account_send_8(account_idx, 15, value);
return success_message("Set trustline", 14);
}

unsigned char validate_payment_overflow(unsigned long long amount, unsigned long long fee, unsigned long long tax) {
unsigned long long max_value = 0-1;
if (amount > max_value >> 1 || (fee | tax) > max_value >> 10) {
return 0;
}
return 1;
}

static signed char set_counterpart(unsigned char *id, unsigned char *portBytes, unsigned char *cpt_secret_key) {
compute_one_time_key();
for (unsigned char i = 0; i < 32; i++) {
cpt_secret_key[i] ^= one_time_key_buf[i];
}
signed char prev_idx = lookup_cpt_idx_by_id(id, id + 32);
if (prev_idx != -1) {
remove_counterpart_by_idx(prev_idx);
}
signed char cpt_idx = 0;
unsigned char temp = cpt_bitmap;
while (temp) {
if ((temp & 1) == 0) break;
cpt_idx++;
temp >>= 1;
}
if (cpt_idx == MAX_COUNTERPARTS) return -1;

cpt_bitmap |= (1 << cpt_idx);
struct counterpart *cpt = &counterparts[cpt_idx];

strncpy(cpt->username, id, 32);
strncpy(cpt->server_address, id + 32, 31);
cpt->server_address[31] = '\0';
ntohn(&cpt->port, portBytes, 2, sizeof(short));
memcpy(cpt->secret_key, cpt_secret_key, 32);
cpt->counter_in = 0;
cpt->counter_out = 0;
return cpt_idx;
}

static void cpt_send_new_payment(signed char cpt_idx, struct pathfinding *pf) {
struct counterpart *cpt = &counterparts[cpt_idx];

tx_header(COUNTERPART_SESSION, cpt->username);
cpt->counter_out++;
htonn(&cpt->counter_out, send_buf + 97, 4, sizeof(int));

send_buf[101] = 0;

unsigned char *p = send_buf + 102;
htonn(&pf->base.amount, p, 8, sizeof(long long)); p += 8;
htonn(&pf->base.penalty_rate, p, 4, sizeof(int)); p += 4;
htonn(&pf->base.fee, p, 8, sizeof(long long)); p += 8;
htonn(&pf->base.tax, p, 8, sizeof(long long));

sign_data(TX_ENVELOPE + 1 + 28 - 32, cpt->secret_key);

struct sockaddr_in addr;
create_sockaddr_in(cpt->server_address, cpt->port, &addr);
enqueue_send((signed char)(CPT_SENDER_BASE + cpt_idx), TX_ENVELOPE + 1 + 28, &addr);
}

signed char get_payment_idx(unsigned char *payment_id) {
for (signed char i = 0; i < storage.num_payments; i++) {
if (memcmp(storage.payments[i].base.identifier, payment_id, 32) == 0) {
return i;
}
}
return -1;
}

unsigned short new_payment(unsigned char *data) {
unsigned char *id = data;
unsigned char *portBytes = data + 64;
unsigned char *cpt_secret_key = data + 66;

unsigned long long amount;
ntohn(&amount, data + 98, 8, sizeof(long long));

signed char cpt_idx = set_counterpart(id, portBytes, cpt_secret_key);
if (cpt_idx < 0 || num_paths >= BUFFER_SIZE - storage.num_payments) {
return error_message("Payment slots full", 19);
}

unsigned char pay_id_buf[SHA256_DIGEST_SIZE];
sha256(counterparts[cpt_idx].secret_key, 32, pay_id_buf);

if (get_pathfinding(pay_id_buf) != -1 || get_payment_idx(pay_id_buf) != -1) {
return error_message("Payment already pending", 23);
}

unsigned int penalty_rate = PENALTY_RATE_SEC;
unsigned long long fee = (unsigned long long)((float)amount * FEE_RATE);
unsigned long long tax = (unsigned long long)((float)amount * storage.trust_index);

if (!validate_payment_overflow(amount, fee, tax)) {
return error_message("Invalid instruction", 20);
}

unsigned char idx = num_paths++;

struct pathfinding *path = &paths[idx];

memcpy(path->base.identifier, pay_id_buf, 32);
path->base.amount = amount;
path->base.tax = tax;
path->base.incoming = -1;
path->base.outgoing = -1;
path->base.counterpart = cpt_idx;
path->base.penalty_rate = penalty_rate;
path->base.fee = fee;
path->base.local = 0;
path->base.hops = 0;
path->base.time_value = time(NULL) + TIMEOUT;
path->depth = 0;
path->in_or_out = 0;
path->commit = 0;

cpt_send_new_payment(cpt_idx, path);
return success_message("New payment", 12);
}

unsigned short receive_payment(unsigned char *data) {
unsigned char *id = data;
unsigned char *portBytes = data + 64;
unsigned char *cpt_secret_key = data + 66;

signed char idx = set_counterpart(id, portBytes, cpt_secret_key);
if (idx < 0) return error_message("Payment slots full", 19);

cpt_sign_and_send_idx(idx, 1);

return success_message("Receive payment", 15);
}

unsigned short direct_payment(unsigned char *data) {
unsigned char *id = data;
unsigned long long amount;
ntohn(&amount, data + 64, 8, sizeof(long long));

signed char account_idx = lookup_account_idx(id);
if (account_idx == -1) {
return error_message("Peer does not exist", 20);
}

struct account *acc = &storage.accounts[account_idx];

unsigned long long tax = (unsigned long long)(storage.trust_index * amount);
if (!validate_payment_overflow(amount, 0, tax)) {
return error_message("Invalid instruction", 20);
}
if (preview_bandwidth_out(account_idx) < amount + tax) {
return error_message("Insufficient funds", 19);
}

unsigned char pay_id_buf[32];
unsigned char hash_input[32 + 8];
memcpy(hash_input, acc->secret_key, 32);

htonn(&acc->counter_out, hash_input + 32, 4, sizeof(int));
htonn(&acc->counter_in, hash_input + 36, 4, sizeof(int));
sha256(hash_input, 40, pay_id_buf);

struct payment *payment = &storage.payments[storage.num_payments++];
memcpy(payment->base.identifier, pay_id_buf, 32);
payment->base.amount = amount;
payment->base.tax = tax;
payment->base.incoming = -1;
payment->base.outgoing = account_idx;
payment->base.local = 1;
payment->finalize_out = amount + tax;
payment->status = CLEANUP;
payment->commit_out = 0;
payment->ack_sync = 0;

save_storage();

send_buf[101] = 14;
htonn(&amount, send_buf + 102, 8, sizeof(long long));
htonn(&tax, send_buf + 110, 8, sizeof(long long));
memcpy(send_buf + 118, hash_input + 32, 8);
account_sign_and_send(account_idx, 1 + 24);

return success_message("Local payment", 14);
}

unsigned short get_trust_index(unsigned char *data){
send_buf[5] = 0;
unsigned char *resp = send_buf + 6;
htonn(&storage.trust_index, resp, 4, sizeof(float));
return 5;
}

unsigned short get_num_accounts(unsigned char *data) {
unsigned short temp_bitmap = storage.acc_bitmap;
unsigned char count = 0;
while (temp_bitmap) {
if (temp_bitmap & 1) {
count++;
}
temp_bitmap >>= 1;
};
send_buf[5] = 0;
send_buf[6] = count;
return 2;
}

unsigned short get_account(unsigned char *data) {
unsigned char idx = data[0];
unsigned short temp_bitmap = storage.acc_bitmap;
unsigned char count = 0;
unsigned char account_idx = 0;
while (temp_bitmap) {
if (temp_bitmap & 1) {
if (count == idx) break;
count++;
}
temp_bitmap >>= 1;
account_idx++;
}
if (!temp_bitmap) {
return error_message("Account not found", 18);
}
struct account *a = &storage.accounts[account_idx];

send_buf[5] = 0;
unsigned char *resp_data = send_buf+6;
memcpy(resp_data, a->username, 32);
memcpy(resp_data+32, a->server_address, 32);
htonn(&a->balance, resp_data+64, 8, sizeof(long long));
htonn(&a->creditlimit, resp_data+72, 8, sizeof(long long));
htonn(&a->creditlimit_in, resp_data+80, 8, sizeof(long long));
return 89;
}

unsigned short get_receipt(unsigned char *data) {
unsigned char idx = data[0];
if (idx >= BUFFER_SIZE) {
return error_message("Invalid index", 14);
}
struct receipt *r = &storage.receipts[idx];

send_buf[5] = 0;
unsigned char *resp = send_buf + 6;
resp[0] = r->type;
memcpy(resp+1, r->identifier, 32);
memcpy(resp + 33, r->username, 32);
memcpy(resp + 65, r->server_address, 32);
htonn(&r->amount, resp + 97, 8, sizeof(long long));
htonn(&r->timestamp, resp + 105, 8, sizeof(long long));
resp[113] = r->status;
return 115;
}

void forward_find_path(unsigned char path_idx) {
struct pathfinding *path = &paths[path_idx];

if (path->depth >= MAX_DEPTH) {
return;
}

signed char from;

unsigned long long (*bandwidth_fn)(signed char);

if (path->in_or_out) {
bandwidth_fn = preview_bandwidth_in;
from = path->base.outgoing;
} else {
bandwidth_fn = preview_bandwidth_out;
from = path->base.incoming;
}

unsigned short temp_bitmap = storage.acc_bitmap;
signed char i = 0;
while (temp_bitmap) {
if (temp_bitmap & 1 && i != from && bandwidth_fn(i) >= path->base.amount) {
send_buf[101] = 0;
unsigned char *data = send_buf+102;
memcpy(data, path->base.identifier, 32);
htonn(&path->base.amount, data+32, 8, sizeof(long long));
data[40] = path->in_or_out;
htonn(&path->base.penalty_rate, data+41, 4, sizeof(int));
htonn(&path->base.fee, data+45, 8, sizeof(long long));
data[53] = path->base.hops;
htonn(&path->base.tax, data+54, 8, sizeof(long long));
account_sign_and_send(i, 1 + 62);
}
i++;
temp_bitmap >>= 1;
};
path->depth++;
}

unsigned char is_path_found(struct pathfinding *pf) {
return pf->base.incoming != -1 && (pf->base.outgoing != -1 || is_counterpart(&pf->base));
}

unsigned char buyer_can_prepare(struct pathfinding *pf) {
return preview_bandwidth_out(pf->base.outgoing) >= pf->base.amount + fee_out(&pf->base) + tax_out(&pf->base) && pf->base.hops <= pf->depth * 2 + 1;
}

void find_path(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;
unsigned long long amount;
ntohn(&amount, args + 32, 8, sizeof(long long));
unsigned char in_or_out = args[40];
unsigned int penalty_rate;
ntohn(&penalty_rate, args + 41, 4, sizeof(int));
unsigned long long fee;
ntohn(&fee, args + 45, 8, sizeof(long long));
unsigned char hops = args[53];
unsigned long long tax;
ntohn(&tax, args + 54, 8, sizeof(long long));

if (!in_or_out && preview_bandwidth_in(account_idx) < amount) {
return;
}

signed char pf_idx = get_pathfinding(payment_id);

if (pf_idx == -1) {
if (amount == 0 || penalty_rate < PENALTY_RATE_SEC / 2 || (float)fee / (float)amount < FEE_RATE / 2) {
return;
}

float tax_rate = (float)tax / (float)amount;
if(tax_rate < storage.trust_index / 2) {
return;
}
if (!validate_payment_overflow(amount, fee, tax)) {
return;
}
if (num_paths >= (BUFFER_SIZE - storage.num_payments) / 2) {
return;
}
pf_idx = num_paths++;
struct pathfinding *pf = &paths[pf_idx];
memcpy(pf->base.identifier, payment_id, 32);
pf->base.amount = amount;
pf->base.counterpart = -1;
pf->in_or_out = in_or_out;
pf->base.penalty_rate = penalty_rate;
pf->base.fee = fee;
pf->base.tax = tax;
pf->base.time_value = time(NULL) + TIMEOUT;
pf->depth = 0;
pf->commit = 0;
if (!in_or_out) {
pf->base.incoming = account_idx;
pf->base.outgoing = -1;
pf->base.hops = 0;
} else {
pf->base.incoming = -1;
pf->base.outgoing = account_idx;
pf->base.hops = hops+1;
}
account_send_32_1(account_idx, 1, payment_id, 0);
return;
}
struct pathfinding *pf = &paths[pf_idx];

if (pf->commit || is_path_found(pf)) {
return;
}

if (in_or_out != pf->in_or_out) {

if (amount != pf->base.amount ||
penalty_rate != pf->base.penalty_rate ||
fee != pf->base.fee ||
tax != pf->base.tax) {
return;
}

if (!in_or_out) {
pf->base.incoming = account_idx;
} else {
pf->base.outgoing = account_idx;
pf->base.hops = hops + 1;
}
if (is_counterpart(&pf->base)) {
if (!pf->in_or_out) {
if (buyer_can_prepare(pf)) {
set_commit(pf);
account_send_32_bytes(account_idx, 3, payment_id);
}
return;
}
}
account_send_32_1(pf->base.incoming, 2, payment_id, pf->base.hops);
return;
}
if (!in_or_out && pf->base.incoming == account_idx || in_or_out && pf->base.outgoing == account_idx) {
forward_find_path(pf_idx);
}
}

void path_recurse(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;
unsigned char depth = args[32];

signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) {
return;
}
struct pathfinding *pf = &paths[pf_idx];

if (pf->commit || is_path_found(pf) || depth + 1 != pf->depth) {
return;
}

if (is_counterpart(&pf->base)) {
signed char cpt_idx = get_counterpart(&pf->base);
if (cpt_idx >= 0) cpt_sign_and_send_idx(cpt_idx, 1);
return;
}

signed char prev_idx;
if (!pf->in_or_out) {
prev_idx = pf->base.incoming;
} else {
prev_idx = pf->base.outgoing;
}

account_send_32_1(prev_idx, 1, payment_id, pf->depth);
}

void path_found(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;
unsigned char hops = args[32];

signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) {
return;
}
struct pathfinding *pf = &paths[pf_idx];

if (is_path_found(pf) || pf->commit || pf->in_or_out) {
return;
}

pf->base.outgoing = account_idx;
pf->base.hops = hops + 1;

if (is_counterpart(&pf->base)) {
if (buyer_can_prepare(pf)) {
set_commit(pf);
account_send_32_bytes(account_idx, 3, payment_id);
}
return;
}

account_send_32_1(pf->base.incoming, 2, payment_id, pf->base.hops);
}

void prepare_path(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) {
return;
}
struct pathfinding *pf = &paths[pf_idx];

if (pf->commit || preview_bandwidth_in(account_idx) < pf->base.amount + fee_in(&pf->base) + tax_in(&pf->base)) {
return;
}

if (is_counterpart(&pf->base)) {
if (!pf->in_or_out) {
return;
}
pf->base.incoming = account_idx;
set_commit(pf);
signed char cpt_idx = get_counterpart(&pf->base);
if (cpt_idx >= 0) cpt_sign_and_send_idx(cpt_idx, 2);
return;
}

if (pf->base.outgoing == -1 || preview_bandwidth_out(pf->base.outgoing) < pf->base.amount + fee_out(&pf->base) + tax_out(&pf->base)) {
return;
}

pf->base.incoming = account_idx;
set_commit(pf);

account_send_32_bytes(pf->base.outgoing, 3, payment_id);
}

void commit_payment(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) {
return;
}
struct pathfinding *pf = &paths[pf_idx];

if (!pf->commit || account_idx != pf->base.incoming) {
return;
}

struct payment *payment = &storage.payments[storage.num_payments];
storage.num_payments++;

memcpy(&payment->base, &pf->base, (char*)&pf->base.time_value - (char*)&pf->base);
payment->base.time_value = time(NULL);

payment->bits = 0;

if (is_counterpart(&pf->base)) {
signed char cpt_idx = get_counterpart(&pf->base);
if (cpt_idx < 0) { paths[pf_idx] = paths[--num_paths]; return; }
memcpy(payment->preimage, counterparts[cpt_idx].secret_key, 32);
save_storage();
paths[pf_idx] = paths[--num_paths];
cpt_sign_and_send_idx(cpt_idx, 3);
return;
}
paths[pf_idx] = paths[--num_paths];
save_storage();

account_send_32_bytes(pf->base.outgoing, 4, payment_id);
}

unsigned long long penalty_ticker(struct payment *payment) {
long long now = time(NULL);
if (now > payment->base.time_value && payment->base.penalty_rate > 0) {
unsigned long long ticker = (unsigned long long)(now - payment->base.time_value) / (unsigned long long)payment->base.penalty_rate;
return ticker > payment->base.amount ? payment->base.amount : ticker;
}
return 0;
}

void seal_payment(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
return;
}
struct payment *payment = &storage.payments[pay_idx];

if (payment->status != COMMIT || payment->base.incoming != account_idx) {
return;
}

unsigned long long ticker = penalty_ticker(payment);
payment->commit_penalty = ticker;

if (ticker >= payment->base.amount) {
payment->status = CLEANUP;
save_storage();
account_send_32_bytes(account_idx, 8, payment_id);

if (payment->base.outgoing != -1) {
payment->finalize_out = payment->base.amount + fee_out(&payment->base) + tax_out(&payment->base);
save_storage();
account_send_32_bytes(payment->base.outgoing, 8, payment_id);
}
return;
}

if (is_counterpart(&payment->base)) {
payment->status = FINALIZE;
save_storage();
account_send_32_bytes(account_idx, 6, payment->preimage);
return;
}
payment->status = SEAL;
save_storage();
if (payment->base.outgoing != -1) {
account_send_32_bytes(payment->base.outgoing, 5, payment_id);
}
}

unsigned long long seal_penalty(struct payment *payment, unsigned long long ticker) {
return ticker > payment->commit_penalty ? ticker - payment->commit_penalty : 0;
}

unsigned long long finalize_out(struct payment *payment) {
unsigned long long ticker = penalty_ticker(payment);
unsigned long long amount = payment->base.amount - seal_penalty(payment, ticker);
unsigned long long tax = tax_out(&payment->base) * amount / payment->base.amount;
unsigned long long fee = fee_out(&payment->base) * ticker / payment->base.amount;
return amount + tax + fee;
}

static void send_ack_preimage(signed char sender_idx, unsigned char *payment_id) {
account_send_32_bytes(sender_idx, 9, payment_id);
}

void finalize_payment(signed char account_idx, unsigned char *args) {
unsigned char *preimage_arg = args;
unsigned char payment_id[32];
sha256(preimage_arg, 32, payment_id);

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
send_ack_preimage(account_idx, payment_id);
return;
}
struct payment *payment = &storage.payments[pay_idx];

if (payment->status == FINALIZE || payment->status == CLEANUP) {
send_ack_preimage(account_idx, payment_id);
return;
}

if (payment->status != SEAL || payment->base.outgoing != account_idx) {
return;
}

payment->finalize_out = finalize_out(payment);
payment->status = FINALIZE;
memcpy(payment->preimage, preimage_arg, 32);
save_storage();

account_send_sync_payment(account_idx, payment_id, payment->finalize_out);
send_ack_preimage(account_idx, payment_id);

if (payment->base.incoming != -1) {
account_send_32_bytes(payment->base.incoming, 6, preimage_arg);
}
}

unsigned long long cancel_out(struct payment *payment) {
unsigned long long ticker = penalty_ticker(payment);
unsigned long long total = payment->base.amount + fee_out(&payment->base) + tax_out(&payment->base);
if (ticker >= payment->base.amount) {
return total;
} else {
return total * ticker / payment->base.amount;
}
}

void cancel_payment(signed char account_idx, unsigned char *args) {
unsigned char *preimage_arg = args;

unsigned char payment_id[32];
sha256(preimage_arg, 32, payment_id);

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
send_ack_preimage(account_idx, payment_id);
return;
}
struct payment *payment = &storage.payments[pay_idx];

unsigned char status = payment->status;
if (status == CANCEL || status == CLEANUP) {
send_ack_preimage(account_idx, payment_id);
return;
}

if (status != COMMIT || payment->base.incoming != account_idx) {
return;
}

memcpy(payment->preimage, preimage_arg, 32);
payment->status = CANCEL;

if (payment->base.outgoing != -1) {
payment->finalize_out = cancel_out(payment);
}

save_storage();

if (payment->base.outgoing != -1) {
account_send_32_bytes(payment->base.outgoing, 7, payment->preimage);
}
send_ack_preimage(account_idx, payment_id);
}

unsigned long long cleanup_out(struct payment *payment) {
return payment->base.amount - seal_penalty(payment, payment->base.amount) + fee_out(&payment->base) + tax_out(&payment->base);
}

unsigned char counterpart_in(struct base_path *base) {
return is_counterpart(base) && base->incoming == -1;
}

void cleanup_payment(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
return;
}
struct payment *payment = &storage.payments[pay_idx];

if ((payment->status & SYNCING_MASK) || penalty_ticker(payment) < payment->base.amount) {
return;
}

if (payment->status == COMMIT) {
if (counterpart_in(&payment->base)) return;
payment->commit_penalty = payment->base.amount;
}

payment->status = CLEANUP;

if (payment->base.outgoing != -1) {
payment->finalize_out = cleanup_out(payment);
save_storage();
if (payment->base.outgoing != account_idx) {
account_send_32_bytes(payment->base.outgoing, 8, payment_id);
}
}

save_storage();

if (payment->base.incoming != -1 && payment->base.incoming != account_idx) {
account_send_32_bytes(payment->base.incoming, 8, payment_id);
}
}

unsigned char synchronized_in(struct payment *payment) {
unsigned char ack_preimage = payment->status != FINALIZE || payment->ack_preimage;
return payment->synced && ack_preimage || counterpart_in(&payment->base);
}

unsigned char synchronized_out(struct payment *payment) {
unsigned char ack_preimage = payment->status != CANCEL || payment->ack_preimage;
unsigned char commit_out = payment->status == FINALIZE || payment->commit_out;
return payment->ack_sync && ack_preimage && commit_out || is_counterpart(&payment->base) && payment->base.outgoing == -1;
}

void ack_preimage(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
return;
}
struct payment *payment = &storage.payments[pay_idx];

unsigned char status = payment->status;
if (payment->ack_preimage ||
!((status == FINALIZE && payment->base.incoming == account_idx) ||
(status == CANCEL && payment->base.outgoing == account_idx))) {
return;
}

payment->ack_preimage = 1;

if (synchronized_in(payment)) {
payment->base.incoming = -1;
}
if (synchronized_out(payment)) {
payment->base.outgoing = -1;
}

if (payment->base.incoming == -1 && payment->base.outgoing == -1) {
remove_payment_at(pay_idx);
}
save_storage();
}

long long preview_balance(signed char account_idx) {
struct account *acc = &storage.accounts[account_idx];
long long bal = acc->balance;
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if (p->base.incoming == account_idx) {
bal -= (long long)(p->base.amount + fee_in(&p->base) + tax_in(&p->base));
}
}
for (unsigned char i = 0; i < num_paths; i++) {
struct pathfinding *pf = get_pathfinding_by_idx(i);
if (!pf) {
i--;
continue;
}
if (pf->base.incoming == account_idx && pf->commit) {
bal -= (long long)(pf->base.amount + fee_in(&pf->base) + tax_in(&pf->base));
}
}
return bal;
}

unsigned long long calculate_tax(struct payment *payment) {
return payment->base.tax * (payment->base.amount - seal_penalty(payment, penalty_ticker(payment)))/payment->base.amount;
}

void redistribute(signed char from_idx, unsigned long long tax, float tax_rate) {
if (tax == 0) return;
struct { signed char idx; unsigned long long val; } positive_balances[BUFFER_SIZE];
unsigned char num_positive = 0;
float total_width = 0.0;
unsigned short temp_bitmap = storage.acc_bitmap;
signed char i = 0;
while (temp_bitmap) {
if (temp_bitmap & 1 && i != from_idx) {
long long preview = preview_balance(i);
if (preview > 0) {
positive_balances[num_positive].idx = i;
positive_balances[num_positive].val = (unsigned long long)preview;
total_width += storage.accounts[i].width;
num_positive++;
}
}
i++;
temp_bitmap >>= 1;
}
if (total_width == 0.0) return;
if (total_width < tax_rate) {
tax = (unsigned long long)((float)tax * (total_width / tax_rate));
}
for (unsigned char j = 0; j < num_positive; j++) {
signed char idx = positive_balances[j].idx;
struct account *acc = &storage.accounts[idx];
float proportion = acc->width / total_width;
unsigned long long dist = (unsigned long long)((float)tax * proportion);
if (dist == 0) continue;
if (dist > positive_balances[j].val) dist = positive_balances[j].val;
tax_buffer[idx] += dist;
if (acc->tax_syncing == 0) {
acc->sync_out++;
acc->tax_syncing = tax_buffer[idx];
save_storage();
account_send_16(idx, 17, acc->tax_syncing, acc->sync_out);
tax_buffer[idx] = 0;
}
}
}

float get_tax_rate(struct payment *p) {
if (p->base.tax == 0) {
return 0;
}
return (float)p->base.tax / (float)(p->base.amount + p->base.tax);
}

void increase_balance(signed char account_idx, unsigned long long amount, float tax_rate) {
struct account *acc = &storage.accounts[account_idx];
long long old_balance = acc->balance;
acc->balance += (long long)amount;
long long new_balance = acc->balance;
if (new_balance > 0) {
float weight;
if (old_balance > 0) {
weight = (float)old_balance / (float)new_balance;
acc->width = weight * acc->width + (1 - weight) * tax_rate;
} else {
acc->width = tax_rate;
tax_buffer[account_idx] = 0;
}
}
}

void decrease_balance(signed char account_idx, unsigned long long amount, float tax_rate) {
struct account *acc = &storage.accounts[account_idx];
long long old_balance = acc->balance;
acc->balance -= (long long)amount;
long long new_balance = acc->balance;
if (new_balance < 0) {
float weight;
if (old_balance < 0) {
weight = (float)(-old_balance) / (float)(-new_balance);
acc->width = weight * acc->width + (1 - weight) * tax_rate;
} else {
acc->width = tax_rate;
}
}
}

void sync_payment(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

unsigned long long amount;
ntohn(&amount, args + 32, 8, sizeof(long long));

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
account_send_32_bytes(account_idx, 11, payment_id);
return;
}

struct payment *payment = &storage.payments[pay_idx];

if (!(payment->status & SYNCING_MASK) || (payment->base.incoming != -1 && payment->base.incoming != account_idx) || amount > payment->base.amount + fee_in(&payment->base) + tax_in(&payment->base)) {
return;
}

if (payment->base.incoming == account_idx && !payment->synced) {
float tax_rate = get_tax_rate(payment);
increase_balance(payment->base.incoming, amount, tax_rate);

payment->synced = 1;

if (synchronized_in(payment)) {
payment->base.incoming = -1;
}

if (is_counterpart(&payment->base) || payment->base.local) {
write_receipt(&payment->base, payment->status == CANCEL);
}
save_storage();
redistribute(account_idx, calculate_tax(payment), tax_rate);
}

if (payment->base.incoming == -1 && payment->base.outgoing == -1) {
remove_payment_at(pay_idx);
save_storage();
}

account_send_32_bytes(account_idx, 11, payment_id);
}

void ack_sync(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
return;
}

struct payment *payment = &storage.payments[pay_idx];

if (!(payment->status & SYNCING_MASK) || payment->ack_sync || payment->base.outgoing != account_idx) {
return;
}
payment->ack_sync = 1;

decrease_balance(payment->base.outgoing, payment->finalize_out, get_tax_rate(payment));

if (is_counterpart(&payment->base) || payment->base.local) {
write_receipt(&payment->base, payment->status == CANCEL);
}
if (synchronized_out(payment)) {
payment->base.outgoing = -1;
}
if (payment->base.incoming == -1 && payment->base.outgoing == -1) {
remove_payment_at(pay_idx);
}
save_storage();
}

void verify_commit(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
account_send_32_1(account_idx, 13, payment_id, 1);
return;
}

struct payment *payment = &storage.payments[pay_idx];

if (payment->base.incoming != -1 && payment->base.incoming != account_idx) {
return;
}
account_send_32_1(account_idx, 13, payment_id, 0);
}

void ack_commit(signed char account_idx, unsigned char *args) {
unsigned char *payment_id = args;
unsigned char status = args[32];

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) {
return;
}

struct payment *payment = &storage.payments[pay_idx];

if (payment->commit_out || payment->base.outgoing != account_idx) {
return;
}

if (status == 0) {
payment->commit_out = 1;
save_storage();
if (payment->status & SYNCING_MASK) {
account_send_sync_payment(payment->base.outgoing, payment->base.identifier, payment->finalize_out);
}
} else {
payment->base.outgoing = -1;
if (payment->base.incoming == -1) {
if (is_counterpart(&payment->base) || payment->base.local) {
write_receipt(&payment->base, 1);
}
remove_payment_at(pay_idx);
save_storage();
}
}
}

void local_payment(signed char account_idx, unsigned char *args) {
unsigned long long amount;
ntohn(&amount, args, 8, sizeof(long long));
unsigned long long tax;
ntohn(&tax, args + 8, 8, sizeof(long long));
unsigned char *nonce = args + 16;

struct account *acc = &storage.accounts[account_idx];

unsigned char pay_id_buf[32];
unsigned char hash_input[40];
memcpy(hash_input, acc->secret_key, 32);
memcpy(hash_input + 32, nonce, 8);
sha256(hash_input, 40, pay_id_buf);

if (get_payment_idx(pay_id_buf) != -1) {
return;
}

if (!validate_payment_overflow(amount, 0, tax) || preview_bandwidth_in(account_idx) < amount + tax || storage.num_payments >= BUFFER_SIZE - num_paths) {
account_send_32_1(account_idx, 13, pay_id_buf, 1);
return;
}

struct payment *payment = &storage.payments[storage.num_payments++];
memcpy(payment->base.identifier, pay_id_buf, 32);
payment->base.amount = amount;
payment->base.incoming = account_idx;
payment->base.outgoing = -1;
payment->base.local = 1;
payment->base.tax = tax;
payment->status = CLEANUP;
payment->synced = 0;

save_storage();

account_send_32_1(account_idx, 13, pay_id_buf, 0);
}

void sync_trustline(signed char account_idx, unsigned char *args) {
unsigned long long limit;
ntohn(&limit, args, 8, sizeof(long long));
struct account *acc = &storage.accounts[account_idx];
acc->creditlimit_in = limit;
save_storage();
account_send_8(account_idx, 16, limit);
}

void ack_trustline(signed char account_idx, unsigned char *args) {
unsigned long long limit;
ntohn(&limit, args, 8, sizeof(long long));

struct account *acc = &storage.accounts[account_idx];

if (!acc->ack_pending || acc->creditlimit != limit) {
return;
}

acc->ack_pending = 0;
save_storage();
}

void swarm_redistribution(signed char account_idx, unsigned char *args) {
unsigned long long amount;
ntohn(&amount, args, 8, sizeof(long long));
unsigned long long counter;
ntohn(&counter, args + 8, 8, sizeof(long long));
struct account *acc = &storage.accounts[account_idx];
if (counter > acc->sync_in) {
if (acc->balance + (long long)amount > 0) return;
acc->balance += (long long)amount;
acc->sync_in = counter;
save_storage();
redistribute(account_idx, amount, acc->width);
}
account_send_8(account_idx, 18, counter);
}

void redistribution_ack(signed char account_idx, unsigned char *args) {
unsigned long long counter;
ntohn(&counter, args, 8, sizeof(long long));
struct account *acc = &storage.accounts[account_idx];
if (acc->tax_syncing > 0 && counter == acc->sync_out) {
acc->balance -= (long long)acc->tax_syncing;
acc->tax_syncing = 0;
save_storage();
}
}

void cpt_new_payment(signed char cpt_idx, unsigned char *args) {
unsigned long long amount;
unsigned long long fee;
unsigned long long tax;
unsigned int penalty_rate;
ntohn(&amount, args, 8, sizeof(long long));
ntohn(&penalty_rate, args + 8, 4, sizeof(int));
ntohn(&fee, args + 12, 8, sizeof(long long));
ntohn(&tax, args + 20, 8, sizeof(long long));

if (num_paths >= BUFFER_SIZE - storage.num_payments || !validate_payment_overflow(amount, fee, tax)) {
return;
}

unsigned char pay_id_buf[SHA256_DIGEST_SIZE];
sha256(counterparts[cpt_idx].secret_key, 32, pay_id_buf);

if (get_pathfinding(pay_id_buf) != -1 || get_payment_idx(pay_id_buf) != -1) {
return;
}

unsigned char pf_idx = num_paths++;

struct pathfinding *pf = &paths[pf_idx];
memcpy(pf->base.identifier, pay_id_buf, 32);
pf->base.amount = amount;
pf->base.tax = tax;
pf->base.incoming = -1;
pf->base.outgoing = -1;
pf->base.counterpart = cpt_idx;
pf->base.penalty_rate = penalty_rate;
pf->base.fee = fee;
pf->base.local = 0;
pf->base.hops = 0;
pf->base.time_value = time(NULL) + TIMEOUT;
pf->in_or_out = 1;
pf->depth = 0;
pf->commit = 0;

forward_find_path((unsigned char)pf_idx);
}

void cpt_find_path(signed char cpt_idx, unsigned char *args) {
(void)args;
unsigned char payment_id[32];
sha256(counterparts[cpt_idx].secret_key, 32, payment_id);
signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) return;
forward_find_path((unsigned char)pf_idx);
}

void cpt_commit_payment(signed char cpt_idx, unsigned char *args) {
(void)args;
unsigned char payment_id[32];
sha256(counterparts[cpt_idx].secret_key, 32, payment_id);

signed char pf_idx = get_pathfinding(payment_id);
if (pf_idx == -1) return;

struct pathfinding *pf = &paths[pf_idx];

if (!is_counterpart(&pf->base) || pf->in_or_out || !pf->commit) return;

struct payment *payment = &storage.payments[storage.num_payments];
storage.num_payments++;

memcpy(&payment->base, &pf->base, (char*)&pf->base.time_value - (char*)&pf->base);
payment->base.time_value = time(NULL);
memcpy(payment->preimage, counterparts[cpt_idx].secret_key, 32);

payment->bits = 0;

save_storage();

paths[pf_idx] = paths[--num_paths];

account_send_32_bytes(pf->base.outgoing, 4, payment_id);
}

void cpt_seal_payment(signed char cpt_idx, unsigned char *args) {
(void)args;
unsigned char payment_id[32];
sha256(counterparts[cpt_idx].secret_key, 32, payment_id);

signed char pay_idx = get_payment_idx(payment_id);
if (pay_idx == -1) return;

struct payment *payment = &storage.payments[pay_idx];

if (payment->status != COMMIT || payment->base.incoming != -1) return;

unsigned long long ticker = penalty_ticker(payment);
payment->commit_penalty = ticker;

if (ticker >= payment->base.amount) {
payment->status = CLEANUP;
save_storage();
account_send_32_bytes(payment->base.outgoing, 8, payment_id);
return;
}

payment->status = SEAL;
save_storage();
account_send_32_bytes(payment->base.outgoing, 5, payment_id);
}

void cpt_start_payment(signed char cpt_idx, unsigned char *args) {
unsigned char pay_id_buf[32];
sha256(counterparts[cpt_idx].secret_key, 32, pay_id_buf);
signed char pf_idx = get_pathfinding(pay_id_buf);
if (pf_idx == -1) return;
cpt_send_new_payment(cpt_idx, &paths[pf_idx]);
}

unsigned short (*user_handlers[])(unsigned char*) = {
set_trust_index, add_account, remove_account, set_trustline, new_payment,
receive_payment, direct_payment, get_trust_index, get_num_accounts,
get_account, get_receipt
};
void (*acc_handlers[])(signed char, unsigned char*) = {
find_path, path_recurse, path_found, prepare_path, commit_payment, seal_payment,
finalize_payment, cancel_payment, cleanup_payment, ack_preimage, sync_payment,
ack_sync, verify_commit, ack_commit, local_payment, sync_trustline, ack_trustline,
swarm_redistribution, redistribution_ack
};
void (*cpt_handlers[])(signed char, unsigned char*) = {
cpt_new_payment, cpt_start_payment, cpt_find_path, cpt_commit_payment, cpt_seal_payment
};

unsigned short acc_args_len[] = {62, 33, 33, 32, 32, 32, 32, 32, 32, 32, 40, 32, 32, 33, 24, 8, 8, 16, 8};
unsigned short user_args_len[] = {4, 98, 64, 72, 106, 98, 72, 0, 0, 1, 1};
unsigned short cpt_args_len[] = {28, 0, 0, 0, 0};

void push_payment_instructions(void) {
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if (!p->ack_preimage) {
if (p->status == FINALIZE && p->base.incoming != -1) {
account_send_32_bytes(p->base.incoming, 6, p->preimage);
} else if (p->status == CANCEL && p->base.outgoing != -1) {
account_send_32_bytes(p->base.outgoing, 7, p->preimage);
}
}

if ((p->status & SYNCING_MASK) && p->base.outgoing != -1 && !p->ack_sync) {
if ((p->status == CANCEL || p->status == CLEANUP) && !p->commit_out) {
account_send_32_bytes(p->base.outgoing, 12, p->base.identifier);
} else {
account_send_sync_payment(p->base.outgoing, p->base.identifier, p->finalize_out);
}
}
}
}

void push_sync_account(void) {
unsigned short temp_bitmap = storage.acc_bitmap;
signed char idx = 0;

while (temp_bitmap) {
if (temp_bitmap & 1) {
struct account *acc = &storage.accounts[idx];
if (acc->ack_pending) {
account_send_8(idx, 15, acc->creditlimit);
}
if (acc->tax_syncing > 0) {
account_send_16(idx, 17, acc->tax_syncing, acc->sync_out);
}
}
idx++;
temp_bitmap >>= 1;
}
}

void auto_cancel_routine(void) {
long long now = time(NULL);
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if (p->status != COMMIT || !counterpart_in(&p->base) || now - p->base.time_value <= TIMEOUT) continue;
p->status = CANCEL;
save_storage();
account_send_32_bytes(p->base.outgoing, 7, p->preimage);
}
}

void cleanup_payment_routine(void) {
for (unsigned char i = 0; i < storage.num_payments; i++) {
struct payment *p = &storage.payments[i];
if ((p->status & SYNCING_MASK) || penalty_ticker(p) < p->base.amount) continue;
if (p->status == COMMIT) {
if (counterpart_in(&p->base)) continue;
p->commit_penalty = p->base.amount;
}
if (p->base.incoming != -1) {
account_send_32_bytes(p->base.incoming, 8, p->base.identifier);
}
if (p->base.outgoing != -1) {
p->finalize_out = cleanup_out(p);
account_send_32_bytes(p->base.outgoing, 8, p->base.identifier);
}
p->status = CLEANUP;
save_storage();
}
}

void ack_received(signed char sender_idx, unsigned char *data, unsigned char offset) {
for (unsigned char i = 0; i < num_active_sends; i++) {
struct send_rtx *t = &send_tasks[i];
if (t->sender_idx == sender_idx) {
if (memcmp(t->send_queue[t->head].payload + offset, data+offset, 4) == 0) {
remove_send_task(i);
}
break;
}
}
}

unsigned int receive_tx(unsigned char session_type, signed char sender_idx, struct sockaddr_in *addr, unsigned char *username, unsigned char *server_address, unsigned char *secret_key, unsigned int counter_in, unsigned char *data, unsigned short len) {
if (!verify_signature(data, len, secret_key)) {
return 0;
}
if (data[0]&1) {
ack_received(sender_idx, data, 97);
return 0;
}
unsigned int counter;
ntohn(&counter, data+97, 4, sizeof(int));
if (counter < counter_in) {
return 0;
}
tx_header(session_type | 1, username);
memcpy(send_buf+97, data+97, 4);
sign_data(TX_ENVELOPE-32, secret_key);
sendto(sockfd, send_buf, TX_ENVELOPE, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_in));

if (counter == counter_in) {
return 0;
}
return counter;
}

#if 1
#define DEBUG_PRINT_MESSAGE(addr, type, cmd) print_message(addr, type, cmd)
static const char* command_names[] = {
"ACCOUNT_FIND_PATH", "ACCOUNT_PATH_RECURSE", "ACCOUNT_PATH_FOUND", "ACCOUNT_PREPARE_PATH",
"ACCOUNT_COMMIT_PAYMENT", "ACCOUNT_SEAL_PAYMENT", "ACCOUNT_FINALIZE_PAYMENT", "ACCOUNT_CANCEL_PAYMENT",
"ACCOUNT_CLEANUP_PAYMENT", "ACCOUNT_ACK_PREIMAGE", "ACCOUNT_SYNC_PAYMENT", "ACCOUNT_ACK_SYNC",
"ACCOUNT_VERIFY_COMMIT", "ACCOUNT_ACK_COMMIT", "ACCOUNT_LOCAL_PAYMENT", "ACCOUNT_SYNC_TRUSTLINE",
"ACCOUNT_ACK_TRUSTLINE", "ACCOUNT_SWARM_REDISTRIBUTION", "ACCOUNT_REDISTRIBUTION_ACK", "USER_SET_TRUST_INDEX",
"USER_ADD_ACCOUNT", "USER_REMOVE_ACCOUNT", "USER_SET_TRUSTLINE", "USER_NEW_PAYMENT", "USER_RECEIVE_PAYMENT",
"USER_DIRECT_PAYMENT", "USER_GET_TRUST_INDEX", "USER_GET_NUM_ACCOUNTS", "USER_GET_ACCOUNT", "USER_GET_RECEIPT",
"COUNTERPART_NEW_PAYMENT", "COUNTERPART_START_PAYMENT", "COUNTERPART_FIND_PATH", "COUNTERPART_COMMIT_PAYMENT",
"COUNTERPART_SEAL_PAYMENT"

};
void print_message(struct sockaddr_in *addr, unsigned char type, unsigned char cmd) {
printf("%s:%d: %s (0x%02X)\n", inet_ntoa(addr->sin_addr), ntohs(addr->sin_port), command_names[cmd + ((type&2)>>1)*19 + (type>>2)*30], cmd);
}
#else
#define DEBUG_PRINT_MESSAGE(addr, type, cmd) ((void)0)
#endif

void transport_datagram(unsigned char *data, unsigned short len, struct sockaddr_in *addr) {
if (len<1) return;
unsigned char session_type = data[0]&6;
if (session_type%4==0) {
if (len < TX_ENVELOPE) {
return;
}
if (session_type==ACCOUNT_SESSION) {
signed char account_idx = lookup_account_idx(data+33);
if (account_idx == -1) {
return;
}
struct account *acc = &storage.accounts[account_idx];
unsigned int counter = receive_tx(ACCOUNT_SESSION, account_idx, addr, acc->username, acc->server_address, acc->secret_key, acc->counter_in, data, len);
if (!counter) {
return;
}
acc->counter_in = counter;
save_storage();
unsigned char cmd = data[101];
if (cmd <= 18 && len-TX_ENVELOPE >= 1 + acc_args_len[cmd]) {
DEBUG_PRINT_MESSAGE(addr, session_type, cmd);
acc_handlers[cmd](account_idx, data+102);
}
} else {
signed char cpt_idx = lookup_cpt_idx_by_id(data+33, data+65);
if (cpt_idx == -1) {
return;
}
struct counterpart *cpt = &counterparts[cpt_idx];
unsigned int counter = receive_tx(COUNTERPART_SESSION, (signed char)(CPT_SENDER_BASE + cpt_idx), addr, cpt->username, cpt->server_address, cpt->secret_key, cpt->counter_in, data, len);
if (!counter) {
return;
}
cpt->counter_in = counter;
unsigned char cmd = data[101];
if (cmd <= 4 && len - TX_ENVELOPE == 1 + cpt_args_len[cmd]) {
DEBUG_PRINT_MESSAGE(addr, session_type, cmd);
cpt_handlers[cmd](cpt_idx, data+102);
}
}
} else if ((len >= REQ_ENVELOPE) && (verify_signature(data, len, secret_block))) {
if (data[0]&1) {
ack_received(USER_SENDER, data, 1);
return;
}
unsigned int counter;
ntohn(&counter, data+1, 4, sizeof(int));
if (counter < storage.counter) {
return;
}

send_buf[0] = 1;
memcpy(send_buf+1, data+1, 4);
sign_data(REQ_ENVELOPE-32, secret_block);
sendto(sockfd, send_buf, REQ_ENVELOPE, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_in));
if (counter == storage.counter) {
return;
}
storage.counter = counter;
save_storage();

unsigned short out_len;
unsigned char cmd = data[5];
if (cmd <= 10 && len-REQ_ENVELOPE >= 1 + user_args_len[cmd]) {
DEBUG_PRINT_MESSAGE(addr, session_type, cmd);
out_len = user_handlers[cmd](data+6);
} else {
out_len = error_message("Invalid instruction", 20);
}
send_buf[0] = 0;
memcpy(send_buf+1, data+1, 4);
sign_data(5+out_len, secret_block);
enqueue_send(USER_SENDER, REQ_ENVELOPE+out_len, addr);
}
}

#include <signal.h>

static volatile sig_atomic_t running = 1;

static void on_shutdown_signal(int sig) { running = 0; }

void run_loop() {
unsigned int period = 0;
struct timeval tv;
tv.tv_usec = 0;
unsigned char buf[MAX_DG];
struct sockaddr_in src_addr;
socklen_t addrlen;

while (running) {
time_t now = time(NULL);
unsigned int current_period = (unsigned int)now / SCHEDULER_PERIOD;

if (current_period > period) {
period = current_period;
int tz = __builtin_ctzl(current_period);
push_payment_instructions();
push_sync_account();
if (tz >= 1) auto_cancel_routine();
if (tz >= 2) cleanup_payment_routine();
}
next_timer = (current_period + 1) * SCHEDULER_PERIOD;

retransmit(now);
tv.tv_sec = next_timer - now;

setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
addrlen = sizeof(struct sockaddr_in);
ssize_t n = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&src_addr, &addrlen);

if (n >= REQ_ENVELOPE) {
transport_datagram(buf, (unsigned short)n, &src_addr);
}
}
}

#include <sys/stat.h>

unsigned char nibble_to_byte(char c) {
return (c >= '0' && c <= '9') ? c - '0' : c - 'a' + 10;
}

int main(int argc, char *argv[]) {
if ((unsigned char)~0 != 0xFF) return 1;
endianess = 0x0001;
endianess = (*(char*)&endianess);

if (argc == 2 || argc == 6) {
snprintf(storage_path, sizeof(storage_path), "%s/%s", STORAGE_DIR, argv[argc-1]);
} else {
strcpy(storage_path, STORAGE_DIR "/" STORAGE_FILE);
}

if (argc >= 5) {
struct stat sb;
if (stat(STORAGE_DIR, &sb) != 0) {
if (mkdir(STORAGE_DIR, 0755) != 0) {
return 1;
}
}
strcpy(storage.username, argv[1]);
strcpy(storage.server_address, argv[2]);
char *port_str = argv[3];
unsigned short value = 0;
while (*port_str >= '0' && *port_str <= '9') {
value = value * 10 + (*port_str++ - '0');
if (value > 65535) {
value = 65535;
break;
}
}
storage.port = value;
char *key_str = argv[4];
for (size_t i = 0; i < 64; i += 2) {
storage.secret_key[i / 2] = (nibble_to_byte(key_str[i]) << 4) | nibble_to_byte(key_str[i + 1]);
}
save_storage();
} else {
load_storage();
}
memcpy(secret_block, storage.secret_key, 32);

struct sockaddr_in server_addr;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
return 1;
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(storage.port);
server_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
return 1;
}

struct sigaction sa;
sa.sa_handler = on_shutdown_signal;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);

run_loop();

return 0;
}

0xf148424062C1340c81D5f1F4c7Ef017b9B8f8ebD

fee refund

0x30DC2079bbbae445B3166feEd37251D65E2CeFB6

data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAIRlWElmTU0AKgAAAAgABQEGAAMAAAABAAIAAAEaAAUAAAABAAAASgEbAAUAAAABAAAAUgEoAAMAAAABAAIAAIdpAAQAAAABAAAAWgAAAAAAAAHMAAAAAQAAAcwAAAABAAOgAQADAAAAAQABAACgAgAEAAAAAQAAACCgAwAEAAAAAQAAACAAAAAAS4r1IAAAAAlwSFlzAABGvgAARr4B4y9WpgAAAg9pVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6dGlmZj0iaHR0cDovL25zLmFkb2JlLmNvbS90aWZmLzEuMC8iPgogICAgICAgICA8dGlmZjpZUmVzb2x1dGlvbj40NjA8L3RpZmY6WVJlc29sdXRpb24+CiAgICAgICAgIDx0aWZmOlhSZXNvbHV0aW9uPjQ2MDwvdGlmZjpYUmVzb2x1dGlvbj4KICAgICAgICAgPHRpZmY6UGhvdG9tZXRyaWNJbnRlcnByZXRhdGlvbj4yPC90aWZmOlBob3RvbWV0cmljSW50ZXJwcmV0YXRpb24+CiAgICAgICAgIDx0aWZmOlJlc29sdXRpb25Vbml0PjI8L3RpZmY6UmVzb2x1dGlvblVuaXQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgrGyJNKAAACdElEQVRYCWP8N+3mf4YBBEz47E58psFwNFMdjPGpo0QOrwMEW/4zSDIygDElluDTy4JNsmhiGliYpaSEQby+Hsw+Hu2KotRq0TYw/1icF1wcJgYSgIlbeiyEy2Nj4AwBo8IIhtccvQwXeHjBGGQ4sgXYDCNHDGsIgAw617+CgSEUt5EwHyKrQBcDORgmBnP8/2WvkbUw4HQAiiocHJihIGmYRchKsYkhy4PYWKMAFPzoAGQYMQaC9IEchuw4kBgu/SghAEp82CwHGTBL7yRDSjNqkXGEQQgkBQEbYQwGBrg4UIzJ3wLsGFyOR3EAyAhw3CPMwmA1ekBCp617OViuqjQSRQ2yeP0OYDoCAlyWg+QwHAAShIXC3ieHQFwMgGwJsiQuceTooDgRolsC8yXIIT8ZVjDAQgjmMFA5gG4pTA5EYw0BZAXo7J+6wKIRCOp3IGSq7e0YTExMoOJ9CAkiWIzIldESpn0oaeB96CF4wqs1UAIbx8vLBzf2IxOEDbMcJtGjkg5jEqQJhsCcWoiP5X3vwx2DaSpqWjnKAAkFgy+fGZ49e8aguhdTB0wExQEx/5wYYvKdYHIMoNqQ1gAlCrBZ5jTTEywsLSHO8PTFSwbkKMCmHiS2MWolLikMcZQQwJDFIsDHzYlFlHwhkh1w4MojsG3c3Nw4bdWY4Isid6NgMwofmUOyA5A1K966zQAKD2sGRgYrKAbJH2P4D8ZHgfQ1NVVkLRhsJgwROgsQdMC+9O1gJ4ESIC0AQQfQwlJkM0cdQFEuuA9N4deAYTobOVxJYJPsAD05YYLGb41dTVANTAHJDhDiw10AwQwlhR5NhKMhAADY+q9DdbylvwAAAABJRU5ErkJggg==

cs

data:image/png;base64,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

data:image/png;base64,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

fee refund

Ignore

Ignore

fee refund

fee refund

0x8827fBab6777b886FE1Bfc6B97762Ee7AFd922B6

0x30DC2079bbbae445B3166feEd37251D65E2CeFB6

{"BlockHash":"0x2315497eb10cf673c9c5115dc5561e407dbaf6d0cbf45a09c489400040cc7c2a","Sender":"5GCc8penY3wGsmaq8ZgeTW7TgEfN76tZGvAnUZ2ZqmMbPWqj","Nonce":4376,"Commitment":"0x0bd4ea80e00746b14c245372d63f4639b06f5c60d4b6e98f6ea30a847fdbd1b1"}

0xf7e09Fb64229aC65A781ec1B639F1aF1B3b22f65

fee refund

fee refund

data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAIRlWElmTU0AKgAAAAgABQEGAAMAAAABAAIAAAEaAAUAAAABAAAASgEbAAUAAAABAAAAUgEoAAMAAAABAAIAAIdpAAQAAAABAAAAWgAAAAAAAAHMAAAAAQAAAcwAAAABAAOgAQADAAAAAQABAACgAgAEAAAAAQAAACCgAwAEAAAAAQAAACAAAAAAS4r1IAAAAAlwSFlzAABGvgAARr4B4y9WpgAAAg9pVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6dGlmZj0iaHR0cDovL25zLmFkb2JlLmNvbS90aWZmLzEuMC8iPgogICAgICAgICA8dGlmZjpZUmVzb2x1dGlvbj40NjA8L3RpZmY6WVJlc29sdXRpb24+CiAgICAgICAgIDx0aWZmOlhSZXNvbHV0aW9uPjQ2MDwvdGlmZjpYUmVzb2x1dGlvbj4KICAgICAgICAgPHRpZmY6UGhvdG9tZXRyaWNJbnRlcnByZXRhdGlvbj4yPC90aWZmOlBob3RvbWV0cmljSW50ZXJwcmV0YXRpb24+CiAgICAgICAgIDx0aWZmOlJlc29sdXRpb25Vbml0PjI8L3RpZmY6UmVzb2x1dGlvblVuaXQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgrGyJNKAAACMklEQVRYCe1WO0sDQRDeGBNQSCE2ehYKQQSFoFilEEt/gJWl+AMUfEcbwQe+Olux9idooUiKVEEIWKgIWhhBEA1YBYI6a75ls7c3uZOTWHgQdh4738x8O3uXiOM4H6KBT1MDc8vUDS+gOSgDxce7oCHs/kijZ8AXA2F3rVPy9xn4ze6JCV8MJNsnFGtO+5BI91wrHULuvg+iyN4sKLmewM4Aui8aKOnJTcPyraKwdM+U8s8cZZRsE9gCnK6kjNEZSLR0CtFvg7LbgGH3CsEWoDMwklqVGInWjq+1ZMWb7m1V9rbdbSm/vT4pGwlmQWwB2KwzUIPmQwGG11a2AAoiFmgGwADZbJ2ODR6QSz2v84tSjmRmlA2CXlSotwBDiES07pwe6qpL9sVAsnr+rmjDgKt4fD6ueTKuc9ec/BDSRlBP97/4ciljkUgH0mWdYt1uk+t+jrOFdVsca5NzQ7NT/XGb6x4BGOBATF9oDFAHHAO52zWZG2uhuCd1dG6uZqGkswxQJ9w7oFwui4urFRGPx2uwgzDAFkCoxAAdAwZQz1SpVEQ0GpWm/MOWiMViUqbOvR6zuB+9B07ysxKfElIBxAD9UEDp/dkrv8vOMoBOzDehC0UzpJw5Ufse0JwWkS0AdJlzMDa8L6HOCksKcrh7WWAIEaecjMAWoDNAGOaVJPpHBzYEbgHyIA6610qF/mgGvABhD+0fEQCDrn4YwDGxRxA0MfYDHDq31v0WcMFh+P4L+ARs7K670JfJEgAAAABJRU5ErkJggg==

0x30DC2079bbbae445B3166feEd37251D65E2CeFB6

fee refund

0xf7e09Fb64229aC65A781ec1B639F1aF1B3b22f65