brianyang + crypto   2464

A glimpse into the dark underbelly of cryptocurrency markets
In this post I’ll investigate the key drivers of the unrelenting cryptocurrency/cryptoasset markets, and explain why they aren’t likely to go away soon. In particular, I will focus on the incentives…
crypto 
6 weeks ago by brianyang
In the World of Cryptocurrency, Even Good Projects Can Go Bad - The New York Times
Envion, a Swiss project, claimed its initial coin offering had raised $100 million for a plan to link clean energy to Bitcoin. Now investors are counting their losses.
economics  crypto 
june 2018 by brianyang
The Security Token Thesis – Hacker Noon
Last summer I wrote Traditional Asset Tokenization, in which I hypothesized that a broad array of assets will move to blockchain records of ownership (represented by tokens), thereby changing the way…
blockchain  crypto  token 
june 2018 by brianyang
A beginner’s guide to Decred – Linda Xie – Medium
According to the Decred website, “Decred is an open and progressive cryptocurrency with a system of community-based governance integrated into its blockchain.” Bitcoin paved the way for…
crypto  decred  blockchain 
june 2018 by brianyang
Dagger [XDAG] whitepaper
Dagger [XDAG]: Is a new mineable cryptocurrency. XDAG is both CPU and GPU mineable. Utilising directed acyclic graph (DAG), XDAG aims to incorporate privacy & smart contract features - creating a truly unique currency for the future.
crypto  ico  dag  no-ico  whitepaper 
march 2018 by brianyang
Messari’s Seed Funding: Global Investors to Promote Transparency in Crypto
I’m thrilled to announce that Messari has closed a seed round of funding from a global syndicate of leading crypto investors, including Anthemis, Blockchain Capital, CoinFund, Digital Asset Investment Company, Danhua Capital, Galaxy Digital, Kindred Ventures, Rising Tide, Semantic Ventures, SparkLabs, and Underscore VC.

Individuals in the round include Garry Tan, Pamir Gelenbe, Matt Roszak, Meltem Demirors, Brian Kelly, Andrew Keys, and nearly a dozen other strategic angels.

Back in December, we set out to raise money from the world’s top crypto seed investors. The goal was not to collect logos, but to ensure we had a broad group of allies who would help us aggregate and standardize crypto data and engage with regulators around the world.

The results exceeded our already-high expectations, and speak to the eagerness many industry leaders have to work towards “self-regulation via transparency.”

This is an *exceptional* extended team we have assembled, and it’s my pleasure to introduce our partnership with them for the first time.

Our mission at Messari is to promote transparency and smarter decision-making in the crypto community. These partners bring us one step closer to fulfilling our goals.

Now the real work begins.

***

I’ll be sharing more details about the round, as well as expanding upon our vision for the company tomorrow during the closing keynote at the DC Blockchain Summit. If you’re there, please say hello to me during the day!
crypto  ico  funding  via:zhumink 
march 2018 by brianyang
Top Token Exchange | The Leading Global Cryptocurrency Exchange SgCoinEx.com
NKD$ (@NKDTechnology) is now listed on these are the NKD wallets my investors have with the…
exchange  crypto  via:toddc 
march 2018 by brianyang
Harbor
Harbor is building a decentralized compliance protocol, a global standard for issuing and trading crypto-securities on blockchains.
portfolio  crypto  ico  via:zhumink 
march 2018 by brianyang
Otppay – Medium
Read writing from Otppay on Medium. Buy, Sell, Exchange & Pay via Crypto-Currencies. Every day, Otppay and thousands of other voices read, write, and share important stories on Medium.
ico  crypto 
march 2018 by brianyang
blockchain: Read a user's Keybase sigchain out of the Bitcoin Blockchain
Github repo
Name: blockchain
Tagline: Read a user's Keybase sigchain out of the Bitcoin Blockchain
Languages:
JavaScript = 692701 bytes
CoffeeScript = 10235 bytes
HTML = 1407 bytes
Makefile = 584 bytes

blockchain
==========

Read a user's Keybase sigchain out of the Bitcoin Blockchain
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
frontend: blinktrade exchange - frontend
Github repo
Name: frontend
Tagline: blinktrade exchange - frontend
Languages:
JavaScript = 23086824 bytes
HTML = 3628309 bytes
CSS = 1089732 bytes
Python = 75763 bytes
Shell = 9796 bytes
Emacs Lisp = 2410 bytes
Ruby = 1809 bytes

## Blinktrade Bitcoin Exchange

## Technologies we are using
- [jekyll](http://jekyllrb.com/), a static generator in Ruby, to create the static html pages
- [google closure library](https://developers.google.com/closure/library/) for the javascript application
- [google closure templates](https://developers.google.com/closure/templates/) for some of the javascript ui views
- [nodejs](https://nodejs.org), for deployment
- [npm](https://www.npmjs.com/), for deployment

## Install the pre-requesites
1 - Install [Git](http://git-scm.com/downloads), [Ruby](https://www.ruby-lang.org/pt/downloads/) anda [Java](https://java.com/download/index.jsp), in case you don't have them yet.

2 - Once installed these dependecies, open up the terminal and install [Jekyll](http://jekyllrb.com) with the following commands.

```sh
$ gem install jekyll:2.5.3
```

2 - Install jekyll multiple languages plugin
```sh
$ gem install jekyll-multiple-languages-plugin:1.2.9
```

## How to run the exchange locally
1 - Fork the repo

2 - Rename it to `exchange` or any name you wish. Let's use exchange for this example

3 - clone your new repo
```sh
$ git clone https://github.com/yourgithubusername/exchange
$ cd exchange
```
4 - Create a symbolic link to some `_config.foxbit.yml` files
```sh
$ ln -s _config.demo.yml _config.yml
```
5 - And finally run:
```sh
$ jekyll server --watch
```

You'll have access to the website at `localhost:4000`

## How to run the exchange on [github pages](https://pages.github.com/)

1 - Make sure that you have `node` and `npm` installed.

2 - Install the node dependencies to deploy.
```sh
npm install
```
3 - Deploy with gulp `$ gulp deploy` and follows the prompt instructions.

4 - Open your browser and point it to [http://yourgithubusername.github.io/exchange/](http://yourgithubusername.github.io/exchange)

## How build the javascript application

Only needed in case you changed the `./jsdev` application.

#### Compile all Javascript

It will compile for all themes and languages.

```sh
./build_javascript.sh
```

#### Compile a specific theme or language
The defaults are US english (en_US) and the default theme ('default'), but can be overriden.
To build the british english version with a custom theme:

```sh
$ cd ./jsdev
$ LANG=en_GB THEME=custom sh build_release.sh
```

## Browser Support

![IE](https://cloud.githubusercontent.com/assets/398893/3528325/20373e76-078e-11e4-8e3a-1cb86cf506f0.png "Internet Explorer") | ![Chrome](https://cloud.githubusercontent.com/assets/398893/3528328/23bc7bc4-078e-11e4-8752-ba2809bf5cce.png "Google Chrome") | ![Firefox](https://cloud.githubusercontent.com/assets/398893/3528329/26283ab0-078e-11e4-84d4-db2cf1009953.png "Firefox") | ![Opera](https://cloud.githubusercontent.com/assets/398893/3528330/27ec9fa8-078e-11e4-95cb-709fd11dac16.png...
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
b2x-node: b2x-node
Github repo
Name: b2x-node
Tagline: b2x-node
Languages:
JavaScript = 424284 bytes
Shell = 151 bytes

Segwit2x Node
============

A Segwit2x full node for building applications and services with Node.js. A node is extensible and can be configured to run additional services.

## Install

```bash
npm install -g b2x-node
b2x-node start
```

## Prerequisites

- GNU/Linux x86_32/x86_64, or OSX 64bit *(for bitcoin2xd distributed binaries)*
- Node.js v0.10, v0.12 or v4
- ZeroMQ *(libzmq3-dev for Ubuntu/Debian or zeromq on OSX)*
- ~200GB of disk storage
- ~8GB of RAM

## Configuration

b2x-node includes a Command Line Interface (CLI) for managing, configuring and interfacing with your b2x-node Node.

```bash
b2x-node create -d <bitcoin-data-dir> mynode
cd mynode
b2x-node install <service>
b2x-node install https://github.com/yourname/helloworld
```

This will create a directory with configuration files for your node and install the necessary dependencies. For more information about (and developing) services, please see the [Service Documentation](docs/services.md).

## Add-on Services

There are several add-on services available to extend the functionality of b2x-node:

- [Insight API](https://github.com/SegwitB2X/b2x-insight-api)
- [Insight UI](https://github.com/SegwitB2X/b2x-insight-ui)

## Documentation

- [Upgrade Notes](docs/upgrade.md)
- [Services](docs/services.md)
- [Bitcoind](docs/services/bitcoind.md) - Interface to Segwit2x Core
- [Web](docs/services/web.md) - Creates an express application over which services can expose their web/API content
- [Development Environment](docs/development.md) - Guide for setting up a development environment
- [Node](docs/node.md) - Details on the node constructor
- [Bus](docs/bus.md) - Overview of the event bus constructor
- [Release Process](docs/release.md) - Information about verifying a release and the release process.
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
gekko: A bitcoin trading bot written in node - https://gekko.wizb.it/
Github repo
Name: gekko
Tagline: A bitcoin trading bot written in node - https://gekko.wizb.it/
Languages:
JavaScript = 693681 bytes
Vue = 70223 bytes
HTML = 548 bytes
Shell = 213 bytes

# Gekko [![npm](https://img.shields.io/npm/dm/gekko.svg)]() [![Build Status](https://travis-ci.org/askmike/gekko.png)](https://travis-ci.org/askmike/gekko) [![Build status](https://ci.appveyor.com/api/projects/status/github/askmike/gekko?branch=stable&svg=true)](https://ci.appveyor.com/project/askmike/gekko)

![Gordon Gekko](http://mikevanrossum.nl/static/gekko.jpg)

*The most valuable commodity I know of is information.*

-Gordon Gekko

Gekko is a Bitcoin TA trading and backtesting platform that connects to popular Bitcoin exchanges. It is written in JavaScript and runs on [Node.js](http://nodejs.org).

*Use Gekko at your own risk.*

## Documentation

See [the documentation website](https://gekko.wizb.it/docs/introduction/about_gekko.html).

## Installation & Usage

See [the installing Gekko doc](https://gekko.wizb.it/docs/installation/installing_gekko.html).

## Community & Support

Gekko has [a forum](https://forum.gekko.wizb.it/) that is the place for discussions on using Gekko, autometed trading and exchanges. In case you rather want to chat in realtime about Gekko feel free to join the [Gekko Support Discord](https://discord.gg/26wMygt).

## Final

If Gekko helped you in any way, you can always leave me a tip at (BTC) 13r1jyivitShUiv9FJvjLH7Nh1ZZptumwW
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
bcoin: Javascript bitcoin library for node.js and browsers
Github repo
Name: bcoin
Tagline: Javascript bitcoin library for node.js and browsers
Homepage: http://bcoin.io
Languages:
JavaScript = 2908066 bytes
Shell = 3286 bytes
HTML = 2593 bytes
Makefile = 263 bytes

# Bcoin

__NOTE__: The latest release of bcoin contains a non-backward compatible change
to the rest API. Please read the [changelog]'s "migrating" section for more
details.

---

**Bcoin** is an alternative implementation of the bitcoin protocol, written in
node.js.

Although still in a beta state, bcoin is well tested and aware of all known
consensus rules. It is currently used in production as the consensus backend
and wallet system for [purse.io][purse].

## Uses

- Full Node
- SPV Node
- Wallet Backend (bip44 derivation)
- Mining Backend (getblocktemplate support)
- Layer 2 Backend (lightning)
- General Purpose Bitcoin Library

Try it in the browser: http://bcoin.io/browser.html

## Install

```
$ git clone git://github.com/bcoin-org/bcoin.git
$ cd bcoin
$ npm install
$ ./bin/bcoin
```

See the [Beginner's Guide][guide] for more in-depth installation instructions.

## Documentation

- API Docs: http://bcoin.io/docs/
- REST Docs: http://bcoin.io/api-docs/index.html
- Docs: [docs/](docs/README.md)

## Support

Join us on [freenode][freenode] in the [#bcoin][irc] channel.

## Disclaimer

Bcoin does not guarantee you against theft or lost funds due to bugs, mishaps,
or your own incompetence. You and you alone are responsible for securing your
money.

## Contribution and License Agreement

If you contribute code to this project, you are implicitly allowing your code
to be distributed under the MIT license. You are also implicitly verifying that
all code is your original work. `</legalese>`

## License

- Copyright (c) 2014-2015, Fedor Indutny (MIT License).
- Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).

See LICENSE for more info.

[purse]: https://purse.io
[guide]: https://github.com/bcoin-org/bcoin/blob/master/docs/Beginner's-Guide.md
[freenode]: https://freenode.net/
[irc]: irc://irc.freenode.net/bcoin
[changelog]: https://github.com/bcoin-org/bcoin/blob/master/CHANGELOG.md
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
gdax-node: The official Node.js library for the GDAX API
Github repo
Name: gdax-node
Tagline: The official Node.js library for the GDAX API
Homepage: https://docs.gdax.com
Languages:
JavaScript = 80861 bytes

# GDAX [![CircleCI](https://circleci.com/gh/coinbase/gdax-node.svg?style=svg)](https://circleci.com/gh/coinbase/gdax-node) [![npm version](https://badge.fury.io/js/gdax.svg)](https://badge.fury.io/js/gdax)

The official Node.js library for Coinbase's [GDAX API](https://docs.gdax.com/).

## Features

* Easy functionality to use in programmatic trading
* A customizable, websocket-synced Order Book implementation
* API clients with convenient methods for every API endpoint
* Abstracted interfaces – don't worry about HMAC signing or JSON formatting; the
library does it for you

## Installation

```bash
npm install gdax
```

You can learn about the API responses of each endpoint [by reading our
documentation](https://docs.gdax.com/#market-data).

## Quick Start

The GDAX API has both public and private endpoints. If you're only interested in
the public endpoints, you should use a `PublicClient`.

```js
const Gdax = require('gdax');
const publicClient = new Gdax.PublicClient();
```

All methods, unless otherwise specified, can be used with either a promise or
callback API.

### Using Promises

```js
publicClient
.getProducts()
.then(data => {
// work with data
})
.catch(error => {
// handle the error
});
```

The promise API can be used as expected in `async` functions in ES2017+
environments:

```js
async function yourFunction() {
try {
const products = await publicClient.getProducts();
} catch (error) {
/* ... */
}
}
```

### Using Callbacks

Your callback should accept two arguments:

* `error`: contains an error message (`string`), or `null` if no was error
encountered
* `response`: a generic HTTP response abstraction created by the [`request`
library](https://github.com/request/request)
* `data`: contains data returned by the GDAX API, or `undefined` if an error was
encountered

```js
publicClient.getProducts((error, response, data) => {
if (error) {
// handle the error
} else {
// work with data
}
});
```

**NOTE:** if you supply a callback, no promise will be returned. This is to
prevent potential `UnhandledPromiseRejectionWarning`s, which will cause future
versions of Node to terminate.

```js
const myCallback = (err, response, data) => {
/* ... */
};

const result = publicClient.getProducts(myCallback);

result.then(() => {
/* ... */
}); // TypeError: Cannot read property 'then' of undefined
```

### Optional Parameters

Some methods accept optional parameters, e.g.

```js
publicClient.getProductOrderBook('BTC-USD', { level: 3 }).then(book => {
/* ... */
});
```

To use optional parameters with callbacks, supply the options as the first
parameter(s) and the callback as the last parameter:

```js
publicClient.getProductOrderBook(
'ETH-USD',
{...
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
node: Stampery API for NodeJS. Notarize all your data using the blockchain
Github repo
Name: node
Tagline: Stampery API for NodeJS. Notarize all your data using the blockchain
Languages:
CoffeeScript = 12323 bytes

# Stampery

[![NPM Package](https://img.shields.io/npm/v/stampery.svg?style=flat-square)](https://www.npmjs.org/package/stampery)
[![Build Status](https://travis-ci.org/stampery/node.svg?branch=master)](https://travis-ci.org/stampery/node)
[![Code Climate](https://codeclimate.com/github/stampery/node/badges/gpa.svg)](https://codeclimate.com/github/stampery/node)
[![Test Coverage](https://codeclimate.com/github/stampery/node/badges/coverage.svg)](https://codeclimate.com/github/stampery/node/coverage)
[![Issue Count](https://codeclimate.com/github/stampery/node/badges/issue_count.svg)](https://codeclimate.com/github/stampery/node)

__NodeJS__ client library for [__Stampery API__](https://stampery.com/api), the __blockchain-powered__, __industrial-scale certification platform__.

Seamlessly integrate industrial-scale data certification and timestamping into your own NodeJS apps. The Stampery API adds a layer of __transparency__, __attribution__, __accountability__ and __auditability__ to your applications by connecting them to Stampery's infinitely scalable [__Blockchain Timestamping Architecture__](https://stampery.com/tech).

## Background

The Stampery API allows you to __prove the existence__, __integrity__ and __ownership__ of all your data by anchoring (embedding) unique identifiers (hashes) of your files and datasets into the __Ethereum__ and __Bitcoin__ blockchains.

The timestamps and proofs generated by this API are __independently verifiable__ at no cost by anyone in the world, and they will be __valid forever__—even if Stampery disappeared.

Each proof connects every single stamped hash to a transaction contained in the next Ethereum and Bitcoin block. This means that __Ethereum receipts take ~30 seconds__ in average to be generated, while __Bitcoin ones take ~5 minutes__.

Our __BTA__ technology aggregates all hashes received between one transaction and the next one by putting them inside a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree) and then broadcasting the result of the aggregation—which we call the __Merkle root__. This allows us to include __millions of hashes__ in every transaction at a fraction of the cost and without loosing the immutabiity properties of public blockchains.

The proofs themselves contain only a few auxiliar hashes that when concurrently hashed together with your stamped hash, allow anyone to reconstruct the state of the Merkle tree at the very exact point in time when the stamping took place.

As all the hash functions involved in the aggregation are [one-way functions](https://en.wikipedia.org/wiki/One-way_function), __there is no way to counterfeit a proof__ that would connect a certain hash to any past transaction. Likewise, it is impossible to make up a fake proof that would be valid for a tampered file.

__You can read more about BTA and blockchain anchoring in__ [__our whitepaper__](https://s3.amazonaws.com/stampery-cdn/docs/Stampery-BTA-v5-whitepaper.pdf).

#### Glossary

* The process of anchoring one __hash__ into a blockchain is called __stamping__.
* One embeded hash is called a __stamp__.
* The stamping process will return one __receipt__ for every blockchain being used.
*...
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
coinbase: wrapper for the coinbase bitcoin wallet & exchange API
Github repo
Name: coinbase
Tagline: wrapper for the coinbase bitcoin wallet & exchange API
Languages:
JavaScript = 20250 bytes
Makefile = 323 bytes

Coinbase
=====

Coinbase is a wrapper around the Coinbase.com bitcoin wallet and exchange API.

How to use it:

Require coinbase

```
var Coinbase = require('coinbase');
var coinbase = new Coinbase({
APIKey: process.env.COINBASE_API_KEY,
APISecret: process.env.COINBASE_API_SECRET
});
```

Make a call to the API using a chosen method.

```
coinbase.account.balance(function (err, data) {
if (err) throw err;
log('data: ' + util.inspect(data));
data.should.have.property('amount');
data.should.have.property('currency', 'BTC');
done();
});
```

The following methods have been implemented and work against the Coinbase api.

# TOC
- [coinbase.account.balance](#coinbaseaccountbalance)
- [coinbase.account.receiveAddress](#coinbaseaccountreceiveaddress)
- [coinbase.account.generateReceiveAddress](#coinbaseaccountgeneratereceiveaddress)
- [coinbase.button](#coinbasebutton)
- [coinbase.buy](#coinbasebuy)
- [coinbase.contacts](#coinbasecontacts)
- [coinbase.currencies.list](#coinbasecurrencieslist)
- [coinbase.currencies.exchangeRates](#coinbasecurrenciesexchangerates)
- [coinbase.orders.list](#coinbaseorderslist)
- [coinbase.orders.get](#coinbaseordersget)
- [coinbase.orders.create](#coinbaseorderscreate)
- [coinbase.prices.buy](#coinbasepricesbuy)
- [coinbase.prices.sell](#coinbasepricessell)
- [coinbase.transactions.list](#coinbasetransactionslist)
- [coinbase.transactions.get](#coinbasetransactionsget)
- [coinbase.transfers.list](#coinbasetransferslist)
<a name=""></a>

<a name="coinbaseaccountbalance"></a>
# coinbase.account.balance
should return account balance.

```js
coinbase.account.balance(function (err, data) {
if (err) throw err;
log('data: ' + util.inspect(data));
data.should.have.property('amount');
data.should.have.property('currency', 'BTC');
done();
});
```

<a name="coinbaseaccountreceiveaddress"></a>
# coinbase.account.receiveAddress
should return the user's current bitcoin receive address.

```js
coinbase.account.receiveAddress(function (err, data) {
if (err) throw err;
log('data: ' + util.inspect(data));
data.should.have.property('success', true);
data.should.have.property('address');
data.should.have.property('callback_url');
done();
});
```

<a name="coinbaseaccountgeneratereceiveaddress"></a>
# coinbase.account.generateReceiveAddress
should generate a new receive address.

```js
coinbase.account.generateReceiveAddress(function (err, data) {
if (err) throw err;
log('data: ' + util.inspect(data));
data.should.have.property('success', true);
data.should.have.property('address');
data.should.have.property('callback_url');
done();
});
```

should generate a new receive address with...
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
coinbase-node: The official Node.js library for the Coinbase API.
Github repo
Name: coinbase-node
Tagline: The official Node.js library for the Coinbase API.
Homepage: https://developers.coinbase.com
Languages:
JavaScript = 102805 bytes

# Coinbase

The official Node.js library for the [Coinbase API](https://developers.coinbase.com/api/v2).

## Features

* Full Test coverage.
* Support for both [API Key + Secret](https://developers.coinbase.com/api/v2#api-key) and [OAuth 2](https://developers.coinbase.com/api/v2#oauth2-coinbase-connect) authentication.
* Convenient methods for making calls to the API.
* Automatic parsing of API responses into relevant Javascript objects.
* Adheres to the nodejs error-first callback protocol.
* Continuous Integration testing against node 0.10, 0.11, and 0.12.

## Installation

`npm install coinbase`

## Version Compatibility

Version | GitHub repository
--------|------------------
`2.0.x` | This repository
`0.1.x` | [mateodelnorte/coinbase](https://github.com/mateodelnorte/coinbase)

Npm `coinbase` package name used to refer to the unofficial [coinbase](https://github.com/mateodelnorte/coinbase) library maintained by [Matt Walters](https://github.com/mateodelnorte). Matt graciously allowed us to use the name for this package instead. You can still find that package on [Github](https://github.com/mateodelnorte/coinbase). Thanks, Matt.

## Quick Start

The first thing you'll need to do is [sign up for coinbase](https://coinbase.com).

## API Key

If you're writing code for your own Coinbase account, [enable an API key](https://coinbase.com/settings/api). Next, create a ``Client`` object for interacting with the API:

```javascript
var Client = require('coinbase').Client;
var client = new Client({'apiKey': mykey, 'apiSecret': mysecret});
```

## OAuth2

If you're writing code that will act on behalf of another user, start by
[creating a new OAuth 2 application](https://coinbase.com/oauth/applications). You will need to do some work to obtain OAuth credentials for your users; while outside the scope of this document, please refer to our [OAuth 2 tutorial](https://developers.coinbase.com/docs/wallet/coinbase-connect/integrating) and [documentation](https://developers.coinbase.com/docs/wallet/coinbase-connect/reference). Once you have these credentials, create a client:

```javascript
var Client = require('coinbase').Client;
var client = new Client({'accessToken': accessToken, 'refreshToken': refreshToken});
```

## Making API Calls

With a `client instance`, you can now make API calls. We've included some examples below, but in general the library has Javascript prototypes for each of the objects described in our [REST API documentation](https://developers.coinbase.com/api/v2). These classes each have methods for making the relevant API calls; for instance, ``coinbase.model.Transaction.complete`` maps to the [complete bitcoin request](https://developers.coinbase.com/api/v2#complete-request-money) API endpoint. The comments of each method in the code references the endpoint it implements. Each API method returns an ``object`` representing the JSON response from the API.

**Listing available accounts**

```javascript
var...
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
coinbase-trader: Node.js application to bypass Bitcoin buying limitations on Coinbase.
Github repo
Name: coinbase-trader
Tagline: Node.js application to bypass Bitcoin buying limitations on Coinbase.
Languages:
JavaScript = 5316 bytes

coinbase-trader
===============

Node.js application to bypass buying limitations on Coinbase.

![Example Bitcoin Trader](http://i.imgur.com/xIkPb66.png)

## Instructions
You must first have node.js and [an API key from Coinbase](https://coinbase.com/docs/api/overview). The button you'll need is a little ways down on the page:

![API key enabled](http://i.imgur.com/0YHPqhU.png)

1. Clone the repo.
2. In the repo folder, run `git submodule init; git submodule update`
3. Edit config.js to provide your Coinbase API key.
4. Run `node trader.js`

You should now have a console to set up BTC buy orders. They will remain open until the Coinbase limit is lifted, at which point they'll be filled normally.

Use `BUY <amount>` to purchase Bitcoins, and `SELL <amount>` to sell. Orders will be retried at the configurable interval (default: 5 seconds) until filled. Every 60 seconds, a report will be printed of outstanding orders.

Use `BUY <amount> [currency]` to buy as many Bitcoin as possible using `<amount>` of `[currency]` at the current exchange rates, updated once per 60 seconds. Coinbase fees are included in the calculations, but fluctuating prices can result in slight over and under spends.

## Notes
Currently, only buy orders are supported.

## Donations
You can send donations to: 1LQTXi1iWULMd4aKn5tKpcgT3xgJiTV5Dm
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
coinboss: ⚡️💸💰 A Serverless Coinbase tradingbot.
Github repo
Name: coinboss
Tagline: ⚡️💸💰 A Serverless Coinbase tradingbot.
Languages:
JavaScript = 17308 bytes

[![serverless](http://public.serverless.com/badges/v3.svg)](http://www.serverless.com)
[![Coverage-Status](https://coveralls.io/repos/github/nicka/coinboss/badge.svg?branch=master)](https://coveralls.io/github/nicka/coinboss?branch=master)
[![Build-Status](https://travis-ci.org/nicka/coinboss.svg?branch=master)](https://travis-ci.org/nicka/coinboss)

<div align="center">
<img src="https://user-images.githubusercontent.com/195404/27678009-e8f765d4-5cb3-11e7-934a-76309f796af3.png">
</div>

---

Automagically buy BTC, ETH or LTC on Coinbase, based on user defined thresholds.

>**Tradingbots:** Typically, bots perform tasks that are both simple and structurally repetitive, at a much higher rate than would be possible for a human alone.

# Architecture

![coinboss](https://user-images.githubusercontent.com/195404/27678017-ecb67dd6-5cb3-11e7-9439-cc01ff71f7b3.png)

# Prerequisites

## Yarn

For node module management Coinboss uses [Yarn](https://yarnpkg.com/) over NPM.

To install yarn globally on your machine please check [Installing Yarn](https://yarnpkg.com/en/docs/install#mac-tab).

After that you can install all service dependencies with:

```bash
yarn
```

## Coinbase

You need a Coinbase.com API key with the following permissions:

- `wallet:accounts:read`
- `wallet:buys:create`
- `wallet:payment-methods:read`
- `wallet:sells:create`

# Quick Start

1. Setup project

>This is a convenience method to install a pre-made Serverless Service locally by downloading the Github repo and unzipping it. Services are listed below.

```bash
serverless install -u https://github.com/nicka/coinboss
```

2. Install development dependencies

```bash
yarn
```

3. Setup environment

```bash
cp .env.example .env.dev
```

4. Update configuration within `.env.dev`

5. Deploy your Coinboss

```bash
STAGE="dev" yarn run deploy
```

# How

![cloudwatch-dashboard](https://user-images.githubusercontent.com/195404/27678272-ea84e754-5cb4-11e7-957f-96d03029a2a9.png)

Coinboss is triggered based on CloudWatch alarms. The thresholds can be found within the projects [.env.example](.env.example).

# Test

For testing Coinboss uses [Jest](https://facebook.github.io/jest/), for more information please check their [documentation](https://facebook.github.io/jest/#getting-started).

>NOTE: To update Jest snapshots supply ` -- -u` to any of the test commands.

**Running the tests**

```bash
yarn run test
```

**Code coverage**

In order to inspect code coverage:

```bash
open coverage/lcov-report/index.html
```

# Simulate

Local API Gateway simulation.

```bash
STAGE="dev" yarn run serve
```

# Build

Create build artifacts.

```bash
STAGE="dev" yarn run build
```

# Deploy

Deploy build artifacts.

```bash
STAGE="dev" yarn run deploy
```

# Todo

- [ ] Increase test coverage
- [ ]...
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
coinbase-spreadsheet: Get bitcoin price in a Google spreadsheet
Github repo
Name: coinbase-spreadsheet
Tagline: Get bitcoin price in a Google spreadsheet
Languages:
JavaScript = 685 bytes

coinbase-spreadsheet
====================

Get Coinbase bitcoin (sell/buy) price in a Google spreadsheet

1. Open the Google spreadsheet where you want to import the Coinbase price
2. Go to "Tools" --> "Script Manager". Click on "New" --> "Blank Project"
3. Replace:

```
function myFunction() {

}
```

with the code from '[coinbase_fetch.gs](coinbase_fetch.gs)' (simply copy/paste it from '[coinbase_fetch.gs](coinbase_fetch.gs)')

4. Change the following two variables:
```
var buy_price_cell = 'E4'
var sell_price_cell = 'E3'
```
and put the cells (from your Google spreadsheet) where you want the respective prices to appear e.g., 'A1', 'B4' etc.

5. Go to "File" --> "Rename" and in "Enter new project name" enter something like 'coinbase_price'
6. Go to "Resources" --> "Current project's triggers" --> and add a new trigger. In "Events" make it "Time-driven" and select the hours/minutes after which you want the price to refresh.
7. Google will say "Authorization required", give the script the required authorization to run.
8. Go back to your spreadsheet window and reload the 'Script manager', you should see the 'coinbase_price' script there now.

If you followed these steps correctly, you should now see the Coinbase buy and sell price appear in the cells you entered (in step 4).

If you have questions, contact [Muneeb Ali](http://twitter.com/muneeb)
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
coinbase: Meteor package for Coinbase API
Github repo
Name: coinbase
Tagline: Meteor package for Coinbase API
Languages:
JavaScript = 643 bytes

__This package is deprecated.__ Coinbase has released an official node library:

https://www.npmjs.com/package/coinbase

It supports both API keys and Oauth. Include it using `meteorhacks:npm`, and use `Meteor.wrapAsync`. See https://atmospherejs.com/idrism/accounts-coinbase for Oauth integration.

[![Build Status](https://travis-ci.org/parlaywithme/coinbase.svg)](https://travis-ci.org/parlaywithme/coinbase)

Meteor wrapper for `coinbase-api` npm package.

[coinbase-api npm package](http://emiliote.github.io/node-coinbase-api/)

[Coinbase API](https://www.coinbase.com/docs/api/overview)

It was the most actively-maintained package when I searched in Jan 2015. There were no packages other than `passport-coinbase` that supported OAuth, and afaict no one has successfully integrated `passport` with Meteor. So if you need OAuth, I recommend using the `oauth` Meteor package, with the `twitter` package as a guide.

`meteor add parlay:coinbase`

Add to your `.bashrc`:

```bash
export COINBASE_KEY="[your key goes here]"
export COINBASE_SECRET="[secret here]"
```

```js
coinbase = Coinbase({ api: process.env.COINBASE_KEY, secret: process.env.COINBASE_SECRET });

coinbase.addresses(function(error, data) {
if (error) return console.log(error);

console.log(data);
});
```
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
nodecoinbase: NodeJS client library for coinbase
Github repo
Name: nodecoinbase
Tagline: NodeJS client library for coinbase
Languages:
JavaScript = 8774 bytes

Simple nodejs client for interacting with portions of the Coinbase API.

Currently only supports API Key based access.

Highly Alpha.

Use at your own risk.

Do not operate while using heavy machinery.
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
coinbase_exchange_bot: a trade bot for the coinbase exchange
Github repo
Name: coinbase_exchange_bot
Tagline: a trade bot for the coinbase exchange
Languages:
JavaScript = 45147 bytes
CSS = 1909 bytes
HTML = 1088 bytes

# Coinbase Exchange Trade Bot

##### This is an experimental / prototype project. Use with careful consideration.

### About
A Coinbase exchange trade bot that uses the [Websocket Feed](https://docs.exchange.coinbase.com/#websocket-feed) and [Authenticated API](https://docs.exchange.coinbase.com/#private) to make trades based on market spread or moving average trends. Utilizes the [coinbase-exchange-node](https://github.com/coinbase/coinbase-exchange-node) official node library.

### The Bot

Overview:
- API Access configured through config.json
- intitializes the current USD and BTC account balance
- attempts to keep an up to date order book based on the websocket feed
- attempts to track the highest buy order price and lowest sell order price
- stores match orders in a "order" postgres table as defined in /bot/util/definitions.js
- stores settled buys and sells made by the bot in a "trade" postgres table also
defined in /bot/util/definitions.js
- uses stored match data to calculate moving averages over 1, 3, 5, 10, and 15 minute
time intervals
- differences in moving averages defined in /bot/trend.js
- primary app logic defined in /bot/macd.js
- buy and sell order wrappers are defined in /bot/order/buy_order.js and /bot/order/sell_order.js
- the primary logic for deciding trade price margins, trade amounts, and tracking active and last active orders is located in /bot/trade_manager/trade_manager.js
- when a buy or sell order is placed, the api will be polled at an interval as defined
in /bot/order/order.js until the order is settled or hits a max try count and is cancelled, at which point a trend shift is identified or the order is retried at a new price
- the bot will only make one buy or sell order at a time, attempting to pair one with the other, unless the trend changes and the next order is no longer favorable. e.g. If the trend is bullish, a buy order is placed. If the buy order is successful it will then wait until the trend switches to bearish and then place a sell order.

To run the bot:
./bot/run.js -a macd

Note: most bot status info and debugging done through the console

### The Dash Server
An unfinished dash server is also included. If started after the bot it will connect to the websocket feed exposed by the bot which emits successful buy and sell order data. Order data will then be emitted in turn to a dash which is simply appended to the page.

The dash requires gulp to be run in order to include compiled js and less. Gulpfile is setup to support [Babel](https://babeljs.io/) and [Browserify](http://browserify.org/)

### Notes

I'm opening this project up because it's success is marginal or not *currently* worthwhile at scale. Also, I hope that someone else can benefit from the example of interacting with the exchange API. This was an experiment in learning more about BTC exchanges and automated trading. At very small order sizes, trading on the spread or using moving averages is sometimes successful. However, when attempting to increase trade size, the bot does not account for partial order fills, and the exchange volume and trade sizes make success more complex / difficult.
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
b2x-insight-ui: b2x-insight-ui
Github repo
Name: b2x-insight-ui
Tagline: b2x-insight-ui
Languages:
JavaScript = 170825 bytes
HTML = 58310 bytes
CSS = 16070 bytes

# Segwit2x Insight UI

A Segwit2x blockchain explorer web application service for [Segwit2x Node](https://github.com/SegwitB2X/b2x-node) using the [Insight API](https://github.com/bitpay/insight-api).

## Getting Started

To manually install all of the necessary components, you can run these commands:

```bash
npm install -g b2x-node
b2x-node create mynode
cd mynode
b2x-node install b2x-insight-api
b2x-node install b2x-insight-ui
b2x-node start
```

Open a web browser to `http://localhost:3001/b2x-insight/`

## Development

To build Insight UI locally:

```
$ npm run build
```

A watch task is also available:

```
$ npm run watch
```

## Changing routePrefix and apiPrefix

By default, the `insightConfig` in `package.json` is:

```json
"insightConfig": {
"apiPrefix": "b2x-insight-api",
"routePrefix": "b2x-insight-ui"
}
```

To change these routes, first make your changes to `package.json`, for example:

```json
"insightConfig": {
"apiPrefix": "api",
"routePrefix": ""
}
```

Then rebuild the `insight-ui` service:

```
$ npm run build
```

## Multilanguage support

Insight UI uses [angular-gettext](http://angular-gettext.rocketeer.be) for multilanguage support.

To enable a text to be translated, add the ***translate*** directive to html tags. See more details [here](http://angular-gettext.rocketeer.be/dev-guide/annotate/). Then, run:

```
grunt compile
```

This action will create a template.pot file in ***po/*** folder. You can open it with some PO editor ([Poedit](http://poedit.net)). Read this [guide](http://angular-gettext.rocketeer.be/dev-guide/translate/) to learn how to edit/update/import PO files from a generated POT file. PO file will be generated inside po/ folder.

If you make new changes, simply run **grunt compile** again to generate a new .pot template and the angular javascript ***js/translations.js***. Then (if use Poedit), open .po file and choose ***update from POT File*** from **Catalog** menu.

Finally changes your default language from ***public/src/js/config***

```
gettextCatalog.currentLanguage = 'es';
```

This line will take a look at any *.po files inside ***po/*** folder, e.g.
**po/es.po**, **po/nl.po**. After any change do not forget to run ***grunt
compile***.

## Note

For more details about the [Segwit2X Insight API](https://github.com/SegwitB2X/b2x-insight-api) configuration and end-points, go to [Segwit2X Insight API GitHub repository](https://github.com/SegwitB2X/b2x-insight-api).

## Contribute

Contributions and suggestions are welcomed at the [Segwit2X Insight UI GitHub repository](https://github.com/SegwitB2X/b2x-insight-ui).
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
b2x-insight-api: b2x-insight-api
Github repo
Name: b2x-insight-api
Tagline: b2x-insight-api
Languages:
JavaScript = 155772 bytes

# Segwit2X Insight API

A Segwit2X blockchain REST and web socket API service for [Segwit2X Node](https://github.com/SegwitB2X/b2x-node).

This is a backend-only service. If you're looking for the web frontend application, take a look at https://github.com/SegwitB2X/b2x-insight-ui.

## Getting Started

```bashl
npm install -g b2x-node@latest
b2x-node create mynode
cd mynode
b2x-node install b2x-insight-api
b2x-node start
```

The API endpoints will be available by default at: `http://localhost:3001/b2x-insight-api/`

## Prerequisites

- [Segwit2X Node](https://github.com/SegwitB2X/b2x-node)

**Note:** You can use an existing Segwit2X data directory, however `txindex`, `addressindex`, `timestampindex` and `spentindex` needs to be set to true in `bitcoinx.conf`, as well as a few other additional fields.

## Query Rate Limit

To protect the server, b2x-insight-api has a built it query rate limiter. It can be configurable in `b2x-node.json` with:
``` json
"servicesConfig": {
"b2x-insight-api": {
"rateLimiterOptions": {
"whitelist": ["::ffff:127.0.0.1"]
}
}
}
```

Or disabled entirely with:
``` json
"servicesConfig": {
"insight-api": {
"disableRateLimiter": true
}
}
```


## API HTTP Endpoints

### Total Supply

```
`GET` /insight-api/supply
```
or
```
`GET` /insight-api/supply?format=object
```
This would return:
```
100091264
```
or
```
{
"supply": "100091264"
}
```

### Statistic Addresses Info

```
`GET` /statistics/addresses/info
```

This would return:
```
{
"count_active_addresses": 117,
"count_addresses_with_balance": 4946,
"average_balance": "3421.93439142"
}
```

### Block
```
/insight-api/block/[:hash]
/insight-api/block/00000000a967199a2fad0877433c93df785a8d8ce062e5f9b451cd1397bdbf62
```

### Block Index
Get block hash by height
```
/insight-api/block-index/[:height]
/insight-api/block-index/0
```
This would return:
```
{
"blockHash":"000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
}
```
which is the hash of the Genesis block (0 height)

### Raw Block
```
/insight-api/rawblock/[:blockHash]
/insight-api/rawblock/[:blockHeight]
```

This would return:
```
{
"rawblock":"blockhexstring..."
}
```

### Block Summaries

Get block summaries by date:
```
/insight-api/blocks?limit=3&blockDate=2016-04-22
```

Example response:
```
{
"blocks": [
{
"height": 408495,
"size": 989237,
"hash": "00000000000000000108a1f4d4db839702d72f16561b1154600a26c453ecb378",
"time": 1461360083,
"txlength": 1695,
"poolInfo": {
"poolName": "BTCC Pool",
"url": "https://pool.btcc.com/"
}
}
],
...
github  programming  github-starred-to-pinboard  crypto 
february 2018 by brianyang
« earlier      
per page:    204080120160

Copy this bookmark:



description:


tags: