cpacia

package main

import (
	"fmt"
	"github.com/btcsuite/btcd/btcec"
	"encoding/hex"
	"crypto/sha256"
	"github.com/btcsuite/btcd/txscript"
	"github.com/cpacia/bchutil"
	"github.com/btcsuite/btcd/chaincfg"

bellbind

// - required node.js >= 10.0.0
// $ npm i elliptic
// $ node --harmony-bigint --experimental-modules check-secp256k1.mjs

import crypto from "crypto";
import elliptic from "elliptic";

import {EC, ECC, secp256k1, a2bi, bi2a, randint} from "./ecc.mjs";

// With real standard curve: secp256k1

gavinandresen

Half-baked thoughts exploring a different way of implementing a fully-validating BCH node.

The idea is to shift the storage of full transaction data to wallets, and explore how little data a fully validating node could store. This isn't a problem today (the UTXO set easily fits in the RAM of an inexpensive server-class machine), but might eventually be at very large transaction volumes.

Initial block download is a problem today (it is annoying to have to wait several hours or days to sync up a new node), and this scheme could make it orders of magnitude faster by shifting the time when full transaction data is broadcast from initial block download to new transaction announcement.

gavinandresen

A "Cuckoo Filter" is a nifty data structure invented a few years ago; read the paper for details.

Like a Bloom filter, you insert items and then can later ask "does this item exist in the filter?" You'll get either a definite "no" or "yes, probably" with some false-positive error rate. Cuckoo filters have two advantages over Bloom filters:

1. They are more space efficient at false positive rates less than about 0.03.
2. You can delete items from them without affecting the false positive rate at all.

It seems to me that an in-memory cuckoo filter could work really well to keep track of Bitcoin's "unspent transaction output set" (UTXO set), to make transaction (or block) validation as fast as possible using minimal memory or disk.

Recall that Bitcoin transactions (other than coinbase transactions that create new coins) have inputs that refer to unspent outputs. An input refers to a previous output by giving the transaction id (a 32-byte hash) co

maaku

*~

maaku

*~

maaku

*~

jFransham

Achieving warp speed with Rust

Contents:

• Number one optimization tip: don't
• Never optimize blindly
• Don't bother optimizing one-time costs
• Improve your algorithms
• CPU architecture primer
• Keep as much as possible in cache
• Keep as much as possible in registers

nacardin

use std::io::{self, Read};

fn line_to_vec<T: std::str::FromStr>(line: &str) -> Vec<T> {
    line.split_whitespace().map(|x| x.parse::<T>().ok().expect("parse error")).collect::<Vec<T>>()
}
        
fn main() {
    
    let mut buffer = String::new();
    io::stdin().read_to_string(&mut buffer).unwrap();

nathansgreen

# First install database

brew install postgres

# Clone and build the PL/pgSQL server-side debugger

srcdir=/usr/local/src
[ -e "$scrdir" ] || \
    sudo sh -c "mkdir $srcdir && chgrp admin $srcdir && chmod g+w $srcdir"
cd "$srcdir"